D-Net

package eu.dnetlib.functionality.index.solr.utils;

import org.springframework.beans.factory.annotation.Required;

public class MetadataReferenceFactory {

	/**

	 * Default interpretation, to be used for the lookup method which doesn't have an interpretation parameter.

	 */

	private String interpretation;

	public MetadataReference getMetadata(final String format, final String layout, final String interpretation) {

		return new MetadataReference(format, layout, interpretation);

	}

	public MetadataReference getMetadata(final String format, final String layout) {

		return getMetadata(format, layout, interpretation);

	}

	public MetadataReference decodeMetadata(final String encoded) {

		String[] split = encoded.split("-");

		if (split.length == 3) 

			return getMetadata(split[0], split[1], split[2]);

		if (split.length == 2) 

			return getMetadata(split[0], split[1]);

		throw new IllegalStateException("malformed metadata reference: " + encoded);

	}

	@Required

	public void setInterpretation(String interpretation) {

		this.interpretation = interpretation;

	}

	public String getInterpretation() {

		return interpretation;

	}

}

package eu.dnetlib.functionality.index.solr.utils;

import org.apache.oro.text.perl.Perl5Util;

import eu.dnetlib.miscutils.functional.UnaryFunction;

/**

 * This function removes extra highlight tags from the given document, 

 * according to the CLEAN_REGEX regular expression

 * 

 * @param document

 * 			the document 

 * @return

 * 			cleaned document

 * 

 * @author claudio

 *

 */

public class HighlightUtils implements UnaryFunction<String, String> {

	public final static String DEFAULT_HL_PRE  = "[hl]";

	public final static String DEFAULT_HL_POST = "[/hl]";

	private static String CLEAN_HEADER = "s#\\[/?hl\\]##gm"; 

	private static String CLEAN_REGEX_OPEN = "<([^>]*)\\[hl\\]([^>]*)>";

	private static String CLEAN_REGEX_CLOSE = "<([^>]*)\\[\\/hl\\]([^>]*)>";

//	private static String CLEAN_REGEX_OPEN = "s#<([^>]*)\\[hl\\]([^>]*)>#<$1$2>#gm";

//	private static String CLEAN_REGEX_CLOSE = "s#<([^>]*)\\[\\/hl\\]([^>]*)>#<$1$2>#gm";	

	private Perl5Util p5util = new Perl5Util();

	@Override

	public String evaluate(String doc) {

		String[] chunk = doc.split("</header>");

		String string = cleanHeader(chunk[0]) + "</header>" + cleanBody(chunk[1]);

		return  string;

	}

	private String cleanHeader(String header) {

		return p5util.substitute(CLEAN_HEADER, header);

	}

	//TODO: implement a faster way to do this

	private String cleanBody(String body) {

		String res = body.replaceAll(CLEAN_REGEX_OPEN, "<$1$2>").replaceAll(CLEAN_REGEX_CLOSE, "<$1$2>");

		if (res.equals(body))

			return res;

		return cleanBody(res);

	}	

}

package eu.dnetlib.functionality.index.solr.utils;

/**

 * IndexMap keeps track of IndexDataStructure-to-physical index mappings and vice-versa.

 * 

 * @author claudio

 * 

 */

public class IndexField {

	public static final String INDEX_FIELD_PREFIX = "__";

	public static final String INDEX_DSID_ALL = "ALL";

	public static final String SCORE_FIELD = "score";

	public static final String DS_ID = INDEX_FIELD_PREFIX + "dsid";

	public static final String DS_VERSION = INDEX_FIELD_PREFIX + "dsversion";

	public static final String RESULT = INDEX_FIELD_PREFIX + "result";

	public static final String ALL_FIELDS = INDEX_FIELD_PREFIX + "all";

	public static final String DELETE_DOCUMENT = INDEX_FIELD_PREFIX + "deleted";

	public static final String INDEX_RECORD_ID = INDEX_FIELD_PREFIX + "indexrecordidentifier";

	public static final String FULLTEXT_ID = INDEX_FIELD_PREFIX + "fulltext";

	public static final String INDEXNAME_PARAM = INDEX_FIELD_PREFIX + "indexName";

	public static final String queryAll = "*:*";

	public static final String FIELD_NAME = "name";

	public static final String FIELD_BROWSING_ALIAS_FOR = "browsingAliasFor";

	public static final String XPATH_BROWSING_ALIAS_FOR = "//FIELD[@" + FIELD_BROWSING_ALIAS_FOR + "]";

}

package eu.dnetlib.functionality.index.solr.utils;

import com.google.common.collect.ComparisonChain;

/**

 * Container class for metadata format, layout and interpretation.

 * 

 * @author claudio

 *

 */

public class MetadataReference {

	/**

	 * Metadata format.

	 */

	private String format;

	/**

	 * Metadata layout.

	 */

	private String layout;

	/**

	 * Metadata interpretation.

	 */

	private String interpretation;

	/**

	 * Constructor for MetadataReference.

	 * 

	 * @param format

	 * 			Metadata format

	 * @param layout

	 * 			Metadata layout

	 * @param interpretation

	 * 			Metadata interpretation

	 */

	public MetadataReference(final String format, final String layout, final String interpretation) {

		this.format = format;

		this.layout = layout;

		this.interpretation = interpretation;

	}

	public String getFormat() {

		return format;

	}

	public String getLayout() {

		return layout;

	}

	public String getInterpretation() {

		return interpretation;

	}

	@Override

	public boolean equals(final Object that) {

		if (!(that instanceof MetadataReference))

			return false;

		final MetadataReference mdRef = (MetadataReference) that;

		return ComparisonChain.start()

	        .compare(this.format, mdRef.getFormat())

	        .compare(this.layout, mdRef.getLayout())

	        .compare(this.interpretation, mdRef.getInterpretation())

	        .result() == 0;		

	}

	@Override

	public int hashCode() {

		return getFormat().hashCode() + getLayout().hashCode() + getInterpretation().hashCode();

	}	

	@Override

	public String toString() {

		return getFormat() + "-" + getLayout() + "-" + getInterpretation();

	}

}

package eu.dnetlib.functionality.index.solr.utils;

import java.io.StringReader;

import org.dom4j.Document;

import org.dom4j.DocumentException;

import org.dom4j.io.SAXReader;

import org.xml.sax.InputSource;

public class XmlUtils {

	/**

	 * helper method, parses a list of fields.

	 * 

	 * @param fields

	 *            the given fields

	 * @return the parsed fields

	 * @throws IndexServiceException

	 *             if cannot parse the fields

	 */

	public static Document parse(String xml) {

		try {

			return new SAXReader().read(new StringReader(xml));

		} catch (DocumentException e) {

			throw new IllegalArgumentException("cannot parse: " + xml);

		}

	}

	public static InputSource asInputSource(final String input) throws DocumentException {

		return new InputSource(new StringReader(parse(input).asXML()));

	}

}

package eu.dnetlib.functionality.index.solr.feed;

import java.io.IOException;

import java.net.MalformedURLException;

import java.net.URI;

import java.net.URL;

import java.util.Collection;

import java.util.Iterator;

import java.util.List;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.apache.solr.client.solrj.SolrServer;

import org.apache.solr.client.solrj.SolrServerException;

import org.apache.solr.client.solrj.impl.CloudSolrServer;

import org.apache.solr.client.solrj.impl.HttpSolrServer;

import org.apache.solr.client.solrj.response.UpdateResponse;

import org.apache.solr.common.SolrInputDocument;

import com.google.common.base.Splitter;

import com.google.common.collect.Lists;

import com.google.common.hash.HashFunction;

import com.google.common.hash.Hashing;

import eu.dnetlib.miscutils.functional.xml.DnetXsltFunctions;

public class SolrServerPool {

	/**

	 * logger.

	 */

	private static final Log log = LogFactory.getLog(SolrServerPool.class); // NOPMD by marko on 11/24/08 5:02 PM

	/*

	 * We run into problems when using the ConcurrentUpdateSolrServer, so we're sticking to the HttpSolrServer.

	 */

	private final List<HttpSolrServer> updateServerPool = Lists.newArrayList();

	private CloudSolrServer cloudServer;

	private final HashFunction hash = Hashing.murmur3_32();

	public SolrServerPool(final String updateUrlLocal, final String updateUrlList, final String zkHost, final String collection, final boolean localFeeding) {

		for (URL url : parseUrlListPattern(updateUrlLocal, updateUrlList, localFeeding)) {

			updateServerPool.add(new HttpSolrServer(url + "/" + collection));

		}

		try {

			cloudServer = new CloudSolrServer(zkHost);

			cloudServer.setDefaultCollection(collection);

		} catch (MalformedURLException e) {

			throw new IllegalArgumentException(e);

		}

	}

	public UpdateResponse add(final SolrInputDocument doc) throws SolrServerException, IOException {

		return updateServerPool.get(hashPick(doc)).add(doc);

	}

	public UpdateResponse addAll(final Iterator<SolrInputDocument> docs) throws SolrServerException, IOException {

		if (updateServerPool.size() == 1) { return updateServerPool.get(0).add(docs); }

		int i = Integer.parseInt(DnetXsltFunctions.randomInt(updateServerPool.size()));

		return updateServerPool.get(i).add(docs);

	}

	public UpdateResponse addAll(final Collection<SolrInputDocument> docs) throws SolrServerException, IOException {

		if (updateServerPool.size() == 1) { return updateServerPool.get(0).add(docs); }

		int i = Integer.parseInt(DnetXsltFunctions.randomInt(updateServerPool.size()));

		return updateServerPool.get(i).add(docs);

	}

	public void deleteByQuery(final String query) throws SolrServerException, IOException {

		cloudServer.deleteByQuery(query);

	}

	public void commitAll() throws SolrServerException, IOException {

		cloudServer.commit();

	}

	public void shutdownAll() throws SolrServerException {

		cloudServer.shutdown();

		for (SolrServer server : updateServerPool) {

			server.shutdown();

		}

	}

	// //////////////////

	private int hashPick(final SolrInputDocument doc) {

		final int hashCode = hash.hashBytes(doc.getFieldValue("__indexrecordidentifier").toString().getBytes()).asInt();

		return Math.abs(hashCode) % updateServerPool.size();

	}

	public List<URL> parseUrlListPattern(final String local, final String list, final boolean localFeeding) {

		final List<URL> res = Lists.newArrayList();

		try {

			if (localFeeding) {

				res.add(new URL(local));

			} else {

				Matcher matcher = Pattern.compile("(^.*)\\[(\\d+)\\.\\.(\\d+)\\](.*$)").matcher(list);

				if (matcher.matches()) {

					final String prefix = matcher.group(1);

					int lb = Integer.parseInt(matcher.group(2));

					int ub = Integer.parseInt(matcher.group(3));

					final String suffix = matcher.group(4);

					for (int i = lb; i <= ub; i++) {

						res.add(new URL(prefix + i + suffix));

					}

				}

			}

		} catch (MalformedURLException e) {

			throw new IllegalArgumentException("invalid url list: " + list, e);

		}

		log.info("parsed url(s): " + res);

		return res;

	}

	public List<URL> parseUrlList(final String list) throws MalformedURLException {

		final List<URL> res = Lists.newArrayList();

		for (final String url : Splitter.on(",").trimResults().split(list)) {

			res.add(URI.create(url).toURL());

		}

		return res;

	}

}

package eu.dnetlib.functionality.index.solr.feed;

import java.io.StringReader;

import java.io.StringWriter;

import java.util.ArrayList;

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.Namespace;

import javax.xml.stream.events.StartElement;

import javax.xml.stream.events.XMLEvent;

import org.apache.solr.common.SolrInputDocument;

import com.google.common.collect.Lists;

/**

 * Optimized version of the document parser, drop in replacement of InputDocumentFactory.

 * 

 * <p>

 * Faster because:

 * </p>

 * <ul>

 * <li>Doesn't create a DOM for the full document</li>

 * <li>Doesn't execute xpaths agains the DOM</li>

 * <li>Quickly serialize the 'result' element directly in a string.</li>

 * <li>Uses less memory: less pressure on GC and allows more threads to process this in parallel</li>

 * </ul>

 * 

 * <p>

 * This class is fully reentrant and can be invoked in parallel.

 * </p>

 * 

 * @author marko

 * 

 */

public class StreamingInputDocumentFactory extends InputDocumentFactory {

	protected static final String DNETRESULT = "dnetResult";

	protected static final String TARGETFIELDS = "targetFields";

	protected static final String INDEX_RECORD_ID_ELEMENT = "indexRecordIdentifier";

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

		@Override

		protected XMLInputFactory initialValue() {

			return XMLInputFactory.newInstance();

		}

	};

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

		@Override

		protected XMLOutputFactory initialValue() {

			return XMLOutputFactory.newInstance();

		}

	};

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

		@Override

		protected XMLEventFactory initialValue() {

			return XMLEventFactory.newInstance();

		}

	};

	/**

	 * {@inheritDoc}

	 * 

	 * @throws XMLStreamException

	 * @throws DocumentException

	 * 

	 * @see eu.dnetlib.functionality.index.solr.feed.InputDocumentFactory#parseDocument(eu.dnetlib.functionality.index.solr.feed.IndexDocument,

	 *      java.lang.String)

	 */

	@Override

	public SolrInputDocument parseDocument(final String version, final String inputDocument, String dsId) {

		final StringWriter results = new StringWriter();

		try {

			XMLEventReader parser = inputFactory.get().createXMLEventReader(new StringReader(inputDocument));

			final SolrInputDocument indexDocument = new SolrInputDocument();

			while (parser.hasNext()) {

				final XMLEvent event = parser.nextEvent();

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

					final String localName = event.asStartElement().getName().getLocalPart();

					if (INDEX_RECORD_ID_ELEMENT.equals(localName)) {

						final XMLEvent text = parser.nextEvent();

						String recordId = getText(text);

						indexDocument.addField(INDEX_RECORD_ID, recordId);

					} else if (TARGETFIELDS.equals(localName)) {

						parseTargetFields(indexDocument, parser);

					} else if (DNETRESULT.equals(localName)) {

						copyResult(indexDocument, results, parser);

					}

				}

			}

			if (version != null) {

				indexDocument.addField(DS_VERSION, version);

			}

			if (dsId != null) {

				indexDocument.addField(DS_ID, dsId);

			}

			if (!indexDocument.containsKey(INDEX_RECORD_ID)) {

				indexDocument.clear();

				System.err.println("missing indexrecord id:\n" + inputDocument);

			}

			return indexDocument;

		} catch (XMLStreamException e) {

			return new SolrInputDocument();

		}

	}

	/**

	 * Parse the targetFields block and add fields to the solr document.

	 * 

	 * @param indexDocument

	 * @param parser

	 * @throws XMLStreamException

	 */

	protected void parseTargetFields(final SolrInputDocument indexDocument, final XMLEventReader parser) throws XMLStreamException {

		boolean hasFields = false;

		while (parser.hasNext()) {

			final XMLEvent targetEvent = parser.nextEvent();

			if (targetEvent.isEndElement() && targetEvent.asEndElement().getName().getLocalPart().equals(TARGETFIELDS)) {

				break;

			}

			if (targetEvent.isStartElement()) {

				final String fieldName = targetEvent.asStartElement().getName().getLocalPart();

				final XMLEvent text = parser.nextEvent();

				String data = getText(text);

				addField(indexDocument, fieldName, data);

				hasFields = true;

			}

		}

		if (!hasFields) {

			indexDocument.clear();

		}

	}

	/**

	 * Copy the /indexRecord/result element and children, preserving namespace declarations etc.

	 * 

	 * @param indexDocument

	 * @param results

	 * @param parser

	 * @throws XMLStreamException

	 */

	protected void copyResult(final SolrInputDocument indexDocument, final StringWriter results, final XMLEventReader parser) throws XMLStreamException {

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

		// TODO: newRecord should copy all the namespace prefixes setup in parents

		// fortunately the only parent of the result element is the 'indexrecord', so it should be easy to get

		// the namespaces declared on the root element (and fast)

		final ArrayList<Namespace> namespaces = Lists.newArrayList(

				eventFactory.get().createNamespace("dri", "http://www.driver-repository.eu/namespace/dri"),

				eventFactory.get().createNamespace("dr", "http://www.driver-repository.eu/namespace/dr"),

				eventFactory.get().createNamespace("xsi", "http://www.w3.org/2001/XMLSchema-instance"),

				eventFactory.get().createNamespace("dc", "http://purl.org/dc/elements/1.1/"),

				eventFactory.get().createNamespace("oaf", "http://namespace.openaire.eu/oaf"));

		StartElement newRecord = eventFactory.get().createStartElement("", null, RESULT, null, namespaces.iterator());

		// new root record

		writer.add(newRecord);

		// copy the rest as it is

		while (parser.hasNext()) {

			final XMLEvent resultEvent = parser.nextEvent();

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

			if (resultEvent.isEndElement() && resultEvent.asEndElement().getName().getLocalPart().equals(DNETRESULT)) {

				writer.add(eventFactory.get().createEndElement("", null, RESULT));

				break;

			}

			writer.add(resultEvent);

		}

		writer.close();

		indexDocument.addField(INDEX_RESULT, results);

	}

	/**

	 * Helper used to add a field to a solr doc. It avoids to add empy fields

	 * 

	 * @param indexDocument

	 * @param field

	 * @param value

	 */

	private final void addField(SolrInputDocument indexDocument, String field, String value) {

		String cleaned = value.trim();

		if (!cleaned.isEmpty()) {

			//log.info("\n\n adding field " + field.toLowerCase() + " value: " + cleaned + "\n");

			indexDocument.addField(field.toLowerCase(), cleaned);

		}

	}

	/**

	 * Helper used to get the string from a text element.

	 * 

	 * @param text

	 * @return

	 */

	protected final String getText(XMLEvent text) {

		if (text.isEndElement()) {

			//			log.warn("skipping because isEndOfElement " + text.asEndElement().getName().getLocalPart());

			return "";

		}

		return text.asCharacters().getData();

	}

}

package eu.dnetlib.functionality.index.solr.feed;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Arrays;

import java.util.List;

import javax.xml.stream.XMLStreamException;

import org.apache.solr.common.SolrInputDocument;

/**

 * 

 * @author claudio

 * 

 */

public abstract class InputDocumentFactory {

	public static final String INDEX_FIELD_PREFIX = "__";

	public static final String DS_VERSION = INDEX_FIELD_PREFIX + "dsversion";

	public static final String DS_ID = INDEX_FIELD_PREFIX + "dsid";

	public static final String RESULT = "result";

	public static final String INDEX_RESULT = INDEX_FIELD_PREFIX + RESULT;

	public static final String INDEX_RECORD_ID = INDEX_FIELD_PREFIX + "indexrecordidentifier";

	private static final String outFormat = new String("yyyy-MM-dd'T'hh:mm:ss'Z'");

	private final static List<String> dateFormats = Arrays.asList("yyyy-MM-dd'T'hh:mm:ss", "yyyy-MM-dd", "dd-MM-yyyy", "dd/MM/yyyy", "yyyy");

	public abstract SolrInputDocument parseDocument(final String version, String inputDocument, String dsId) throws XMLStreamException;

	/**

	 * method return a solr-compatible string representation of a date

	 * 

	 * @param date

	 * @return

	 * @throws DocumentException

	 * @throws ParseException

	 */

	public static String getParsedDateField(final String date) {

		for (String formatString : dateFormats) {

			try {

				return new SimpleDateFormat(outFormat).format(new SimpleDateFormat(formatString).parse(date));

			} catch (ParseException e) {

			}

		}

		throw new IllegalStateException("unable to parse date: " + date);

	}

	public String parseDate(final String date) {

		return getParsedDateField(date);

	}

}

package eu.dnetlib.functionality.index.solr.browsing;

import java.util.List;

import javax.xml.bind.annotation.XmlAccessorType;

import javax.xml.bind.annotation.XmlElement;

import javax.xml.bind.annotation.XmlRootElement;

import javax.xml.bind.annotation.XmlAccessType;

import org.springframework.beans.factory.annotation.Required;

/**

 * 

 *	serialization of the browsing result.

 * 

 *	<row>

 *		<groupresult field="facetFieldName1">

 *			<value>facetFieldValue</value>

 *			<count>1</count>

 *     </groupresult>

 *     

 *		<groupresult field="facetFieldName2">

 *			<value>facetFieldValue</value>

 *			<count>1</count>

 *     </groupresult>

 *     

 *	</row>

 *

 * @author claudio

 *

 */

@XmlRootElement(namespace = "", name = "row")

@XmlAccessorType(XmlAccessType.FIELD)

public class BrowsingRow {

	@XmlElement(name = "groupresult", required = true)

	private List<GroupResult> groupresult;

	public BrowsingRow() { }

	public BrowsingRow(List<GroupResult> groupresult) {

		this.groupresult = groupresult;

	}

	/**

	 * adds a GroupResult.

	 * 

	 * @param fieldName

	 * @param fieldValue

	 * @param count

	 */

	public void addBrowsingRow(String fieldName, String fieldValue, int count) {

		groupresult.add(new GroupResult(fieldName, fieldValue, count));

	}

	@Override

	public boolean equals(Object obj) {

		if (!(obj instanceof BrowsingRow)) return false;

		final BrowsingRow brws = (BrowsingRow) obj;

		return groupresult.equals(brws.getGroupResult());

	}

	public List<GroupResult> getGroupResult() {

		return groupresult;

	}

	@Required

	public void setGroupResult(List<GroupResult> groupresult) {

		this.groupresult = groupresult;

	}

}

package eu.dnetlib.functionality.index.solr.browsing;

import javax.xml.bind.annotation.XmlAttribute;

import javax.xml.bind.annotation.XmlRootElement;

import org.springframework.beans.factory.annotation.Required;

/**

 * <pre>

 * {@code

 *	<groupresult field="facetFieldName">

 *		<value>facetFieldValue</value>

 *		<count>1</count>

 *	</groupresult>

 * }

 * </pre>

 * 

 * @author claudio

 *

 */

@XmlRootElement(namespace = "", name = "groupresult")

public class GroupResult {

	private String name;

	private String value;

	private int count; 

	public GroupResult() { }

	/**

	 * Builds a groupResult.

	 * 

	 * @param fieldName

	 * @param fieldValue

	 * @param count

	 */

	public GroupResult(String name, String value, int count) {

		this.name = name;

		this.value = value;

		this.count = count;

	}

	@Override

	public boolean equals(Object obj) {

		if (!(obj instanceof GroupResult)) return false;

		final GroupResult g = (GroupResult)obj;

		if (this.getCount() == g.getCount() &&

			this.getName().equals(g.getName()) &&

			this.getValue().equals(g.getValue()))

			return true;

		return false;

	}

	@XmlAttribute(name = "field", required = true)

	public String getName() {

		return name;

	}

	public String getValue() {

		return value;

	}

	public int getCount() {

		return count;

	}

	@Required

	public void setName(String name) {

		this.name = name;

	}

	@Required

	public void setValue(String value) {

		this.value = value;

	}

	@Required

	public void setCount(int count) {

		this.count = count;

	}

}

package eu.dnetlib.functionality.index.model;

import java.util.Date;

import java.util.List;

/**

 * Interface for a sequence of Any objects.

 * 

 * <p>

 * AnySeq does <b>not</b> allow <code>null</code> values!

 * </p>

 * 

 */

public interface AnySeq extends List<Any>, Any {

	/**

	 * @param element

	 *            The string object to add

	 * @return true if successfully added, false else

	 */

	boolean add(String element);

	/**

	 * Long, Integer, Short and Byte values will be converted to Value object of type LONG, all others to Value object

	 * of type DOUBLE.

	 * 

	 * @param number

	 *            The number object to add

	 * @return true if successfully added, false else

	 */

	boolean add(Number number);

	/**

	 * @param index

	 *            The index where to add the any object

	 * @param element

	 *            The any object to add

	 */

	@Override

	void add(int index, Any element);

	/**

	 * @param index

	 *            The index of the object to return

	 * @return The AnyMap matching to the index, an InvalidValueTypeException is thrown if the value is not of type

	 *         AnyMap

	 */

	AnyMap getMap(int index);

	/**

	 * @param index

	 *            The index of the object to return

	 * @return The AnySeq matching to this index, an InvalidValueTypeException is thrown if the value is not of type

	 */

	AnySeq getSeq(int index);

	/**

	 * @param index

	 *            The index of the object to return

	 * @return The value matching to this index, an InvalidValueTypeException is thrown if the value is no value type.

	 */

	Value getValue(int index);

	/**

	 * @param index

	 *            The index of the object to return

	 * @return The string value matching to this index, an InvalidValueTypeException is thrown if the value is not of

	 *         type string

	 */

	String getStringValue(int index);

	/**

	 * @param index

	 *            The index of the object to return

	 * @return The double value matching to this index, an InvalidValueTypeException is thrown if the value is not of

	 *         type double

	 */

	Double getDoubleValue(int index);

	/**

	 * @param index

	 *            The index of the object to return

	 * @return The long value matching to this index, an InvalidValueTypeException is thrown if the value is not of type

	 *         long

	 */

	Long getLongValue(int index);

	/**

	 * @param index

	 *            The index of the object to return

	 * @return The boolean value matching to this index, an InvalidValueTypeException is thrown if the value is not of

	 *         type boolean

	 */

	Boolean getBooleanValue(int index);

	/**

	 * @param index

	 *            The index of the object to return

	 * @return The date value matching to this index, an InvalidValueTypeException is thrown if the value is not of type

	 *         date

	 */

	Date getDateValue(int index);

	/**

	 * @param index

	 *            The index of the object to return

	 * @return The date time value matching to this index, an InvalidValueTypeException is thrown if the value is not of

	 *         type date time

	 */

	Date getDateTimeValue(int index);

	/**

	 * returns all values as a List of Strings.

	 * 

	 * @throws InvalidValueTypeException

	 *             if not all contained values are strings.

	 */

	List<String> asStrings();

	/**

	 * returns all values as a List of Long.

	 * 

	 * @throws InvalidValueTypeException

	 *             if not all contained values are Longs.

	 */

	List<Long> asLongs();

}

package eu.dnetlib.functionality.index.model;

import eu.dnetlib.functionality.index.model.impl.DefaultDataFactoryImpl;

/**

 * Helper class to decouple Any and Record interfaces better from default implementation.

 */

public final class DataFactoryCreator {

	/**

	 * Private default constructor to avoid instance creation.

	 */

	private DataFactoryCreator() {

	}

	/**

	 * @return instance of the default DataFactory.

	 */

	public static DataFactory newInstance() {

		return new DefaultDataFactoryImpl();

	}

}

package eu.dnetlib.functionality.index.model.impl;

import java.util.Collection;

import java.util.Date;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.Map;

import java.util.Set;

import eu.dnetlib.functionality.index.model.Any;

import eu.dnetlib.functionality.index.model.AnyMap;

import eu.dnetlib.functionality.index.model.AnySeq;

import eu.dnetlib.functionality.index.model.InvalidValueTypeException;

import eu.dnetlib.functionality.index.model.Value;

/**

 * Class implementing AnyMap.

 */

public final class AnyMapImpl extends AbstractAny implements AnyMap {

	/** version. */

	private static final long serialVersionUID = 1L;

	/** internal representation of the AnyMap. */

	private final Map<String, Any> _anyMap;

	/** Constructs a new AnyMapImpl. */

	AnyMapImpl() {

		super(ValueType.MAP);

		_anyMap = new LinkedHashMap<String, Any>();

	}

	/** {@inheritDoc} */

	@Override

	public void add(final String key, final Any value) {

		final Any any = _anyMap.get(key);

		AnySeq anySeq = null;

		if (any == null) {

			anySeq = getFactory().createAnySeq();

			_anyMap.put(key, anySeq);

		} else if (any.isValue() || any.isMap()) {

			anySeq = getFactory().createAnySeq();

			anySeq.add(any);

			_anyMap.put(key, anySeq);

		} else { // any.isSeq()

			anySeq = (AnySeq) any;

		}

		anySeq.add(value);

	}

	/** {@inheritDoc} */

	@Override

	public void clear() {

		_anyMap.clear();

	}

	/** {@inheritDoc} */

	@Override

	public boolean isEmpty() {

		return _anyMap.isEmpty();

	}

	/** {@inheritDoc} */

	@Override

	public Set<String> keySet() {

		return _anyMap.keySet();

	}

	/** {@inheritDoc} */

	@Override

	public Any put(final String key, final String value) {

		try {

			return put(key, new ValueImpl(ValueType.STRING, value));

		} catch (final Exception e) {

			throw new IllegalArgumentException("cannot add value for key: " + key, e);

		}

	}

	/** {@inheritDoc} */

	@Override

	public Any put(final String key, final Number value) {

		if (value == null) {

			throw new IllegalArgumentException("The value of any Any must not be null.");

		}

		if (value instanceof Double) {

			return put(key, new ValueImpl(ValueType.DOUBLE, value));

		} else if (value instanceof Long) {

			return put(key, new ValueImpl(ValueType.LONG, value));

		} else if (value instanceof Integer) {

			return put(key, new ValueImpl(ValueType.LONG, Long.valueOf(value.longValue())));

		} else if (value instanceof Short) {

			return put(key, new ValueImpl(ValueType.LONG, Long.valueOf(value.longValue())));

		} else if (value instanceof Byte) {

			return put(key, new ValueImpl(ValueType.LONG, Long.valueOf(value.longValue())));

		} else { // default: DOUBLE

			return put(key, new ValueImpl(ValueType.DOUBLE, Double.valueOf(value.doubleValue())));

		}

	}

	/** {@inheritDoc} */

	@Override

	public Any put(final String key, final Boolean value) {

		return put(key, new ValueImpl(ValueType.BOOLEAN, value));

	}

	/** {@inheritDoc} */

	@Override

	public Any put(final String key, final Any value) {

		if (value == null) {

			throw new IllegalArgumentException("The value of any Any must not be null.");

		}

		return _anyMap.put(key, value);

	}

	/** {@inheritDoc} */

	@Override

	public int size() {

		return _anyMap.size();

	}

	/** {@inheritDoc} */

	@Override

	public Collection<Any> values() {

		return _anyMap.values();

	}

	/** {@inheritDoc} */

	@Override

	public Iterator<Any> iterator() {

		return _anyMap.values().iterator();

	}

	/** {@inheritDoc} */

	@Override

	public AnyMap getMap(final String key) {

		final Any anyValue = get(key);

		if (anyValue != null) {

			if (anyValue.isMap()) {

				return (AnyMap) anyValue;

			} else {

				throw new InvalidValueTypeException("Cannot convert value of type '" + anyValue.getValueType() + "' to AnyMap.");

			}

		}

		return null;

	}

	/** {@inheritDoc} */

	@Override

	public AnySeq getSeq(final String key) {

		final Any anyValue = get(key);

		if (anyValue != null) {

			if (anyValue.isSeq()) {

				return (AnySeq) anyValue;

			} else {

				throw new InvalidValueTypeException("Cannot convert value of type '" + anyValue.getValueType() + "' to AnySeq.");

			}

		}

		return null;

	}

	/** {@inheritDoc} */

	@Override

	public Value getValue(final String key) {

		final Any anyValue = get(key);

		if (anyValue != null) {

			if (anyValue instanceof Value) {

				return (Value) anyValue;

			} else {

				throw new InvalidValueTypeException("Cannot convert value of type '" + anyValue.getValueType() + "' to Value.");

			}

		}

		return null;

	}

	/** {@inheritDoc} */

	@Override

	public String getStringValue(final String key) {

		final Any anyValue = get(key);

		if (anyValue != null) {

			if (anyValue instanceof Value) {

				return ((Value) anyValue).asString();

			} else {

				throw new InvalidValueTypeException("Cannot convert value of type '" + anyValue.getValueType() + "' to String.");

			}

		}

		return null;

	}

	/** {@inheritDoc} */

	@Override

	public Double getDoubleValue(final String key) {

		final Any anyValue = get(key);

		if (anyValue != null) {

			if (anyValue instanceof Value) {

				return ((Value) anyValue).asDouble();

			} else {

				throw new InvalidValueTypeException("Cannot convert value of type '" + anyValue.getValueType() + "' to double.");

			}

		}

		return null;

	}

	/** {@inheritDoc} */

	@Override

	public Long getLongValue(final String key) {

		final Any anyValue = get(key);

		if (anyValue != null) {

			if (anyValue instanceof Value) {

				return ((Value) anyValue).asLong();

			} else {

				throw new InvalidValueTypeException("Cannot convert value of type '" + anyValue.getValueType() + "' to long.");

			}

		}

		return null;

	}

	/** {@inheritDoc} */

	@Override

	public Boolean getBooleanValue(final String key) {

		final Any anyValue = get(key);

		if (anyValue != null) {

			if (anyValue instanceof Value) {

				return ((Value) anyValue).asBoolean();

			} else {

				throw new InvalidValueTypeException("Cannot convert value of type '" + anyValue.getValueType() + "' to boolean.");

			}

		}

		return null;

	}

	/** {@inheritDoc} */

	@Override

	public Date getDateValue(final String key) {

		final Any anyValue = get(key);

		if (anyValue != null) {

			if (anyValue instanceof Value) {

				return ((Value) anyValue).asDate();

			} else {

				throw new InvalidValueTypeException("Cannot convert value of type '" + anyValue.getValueType() + "' to Date.");

			}

		}

		return null;

	}

	/** {@inheritDoc} */

	@Override

	public Date getDateTimeValue(final String key) {

		final Any anyValue = get(key);

		if (anyValue != null) {

			if (anyValue instanceof Value) {

				return ((Value) anyValue).asDateTime();

			} else {

				throw new InvalidValueTypeException("Cannot convert value of type '" + anyValue.getValueType() + "' to DateTime.");

			}

		}

		return null;

	}

	/** {@inheritDoc} */

	@Override

	public int hashCode() {

		final int prime = 31;

		int result = 1;

		result = prime * result + (_anyMap == null ? 0 : _anyMap.hashCode());

		return result;

	}

	/** {@inheritDoc} */

	@Override

	public boolean equals(final Object obj) {

		if (this == obj) {

			return true;

		}

		if (obj == null) {

			return false;

		}

		if (getClass() != obj.getClass()) {

			return false;

		}

		final AnyMapImpl other = (AnyMapImpl) obj;

		if (_anyMap == null) {

			if (other._anyMap != null) {

				return false;

			}

		} else if (!_anyMap.equals(other._anyMap)) {

			return false;

		}

		return true;

	}

	/**

	 * {@inheritDoc}

	 */

	@Override

	public String toString() {

		return _anyMap.toString();

	}

	/** {@inheritDoc} */

	@Override

	public boolean containsKey(final Object key) {

		return _anyMap.containsKey(key);

	}

	/** {@inheritDoc} */

	@Override

	public boolean containsValue(final Object value) {

		return _anyMap.containsValue(value);

	}

	/** {@inheritDoc} */

	@Override

	public Any get(final Object key) {

		return _anyMap.get(key);

	}

	/** {@inheritDoc} */

	@Override

	public void putAll(final Map<? extends String, ? extends Any> map) {

		_anyMap.putAll(map);

	}

	/** {@inheritDoc} */

	@Override

	public Any remove(final Object key) {

		return _anyMap.remove(key);

	}

	/** {@inheritDoc} */

	@Override

	public Set<java.util.Map.Entry<String, Any>> entrySet() {

		return _anyMap.entrySet();

	}

	/**

	 * {@inheritDoc}

	 * 

	 * @see org.eclipse.smila.datamodel.impl.AbstractAny#asMap()

	 */

	@Override

	public AnyMap asMap() {

		return this;

	}

	/**

	 * {@inheritDoc}

	 * 

	 * @see org.eclipse.smila.datamodel.AnyMap#getMap(java.lang.String, boolean)

	 */

	@Override

	public AnyMap getMap(final String key, final boolean create) {

		AnyMap val = getMap(key);

		if (val == null && create) {

			val = getFactory().createAnyMap();

			this.put(key, val);

		}

		return val;

	}

	/**

	 * {@inheritDoc}

	 * 

	 * @see org.eclipse.smila.datamodel.AnyMap#getSeq(java.lang.String, boolean)

	 */

	@Override

	public AnySeq getSeq(final String key, final boolean create) {

		AnySeq val = getSeq(key);

		if (val == null && create) {

			val = getFactory().createAnySeq();

			this.put(key, val);

		}

		return val;

	}

}

package eu.dnetlib.functionality.index.model.impl;

import java.util.Collection;

import java.util.Collections;

import java.util.Date;

import java.util.Iterator;

import java.util.Map;

import java.util.Set;

import eu.dnetlib.functionality.index.model.Any;

import eu.dnetlib.functionality.index.model.AnyMap;

import eu.dnetlib.functionality.index.model.AnySeq;

import eu.dnetlib.functionality.index.model.DataFactory;

import eu.dnetlib.functionality.index.model.Value;

/**

 * immutable decorator for an AnyMap.

 */

public class ImmutableAnyMapImpl implements AnyMap {

	/** The underlying anymap. */

	private final AnyMap _anyMap;

	/** The underlying map, as immutable. */

	private final Map<String, Any> _immutable;

	/**

	 * @param createAnyMap

	 */

	public ImmutableAnyMapImpl(AnyMap map) {

		_anyMap = map;

		_immutable = Collections.unmodifiableMap(map);

	}

	@Override

	public void add(String key, Any value) {

		throw new UnsupportedOperationException();

	}

	@Override

	public AnyMap asMap() {

		return _anyMap.asMap();

	}

	@Override

	public AnySeq asSeq() {

		return _anyMap.asSeq();

	}

	@Override

	public Value asValue() {

		return _anyMap.asValue();

	}

	/**

	 * 

	 * @see java.util.Map#clear()

	 */

	@Override

	public void clear() {