• Home
• org.choco-solver
• choco-parsers
• 3.3.3
• source code
• XParser.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.chocosolver.parser.xcsp.tools.XParser Maven / Gradle / Ivy

package org.chocosolver.parser.xcsp.tools;

import org.chocosolver.parser.xcsp.tools.XConstraints.*;
import org.chocosolver.parser.xcsp.tools.XDomains.*;
import org.chocosolver.parser.xcsp.tools.XEnums.*;
import org.chocosolver.parser.xcsp.tools.XNodeExpr.XNodeLeaf;
import org.chocosolver.parser.xcsp.tools.XNodeExpr.XNodeParent;
import org.chocosolver.parser.xcsp.tools.XObjectives.Objective;
import org.chocosolver.parser.xcsp.tools.XObjectives.ObjectiveExpr;
import org.chocosolver.parser.xcsp.tools.XObjectives.ObjectiveSpecial;
import org.chocosolver.parser.xcsp.tools.XValues.*;
import org.chocosolver.parser.xcsp.tools.XVariables.Array;
import org.chocosolver.parser.xcsp.tools.XVariables.TypeVar;
import org.chocosolver.parser.xcsp.tools.XVariables.Var;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpressionException;
import javax.xml.xpath.XPathFactory;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

import static org.chocosolver.parser.xcsp.tools.XConstants.*;
import static org.chocosolver.parser.xcsp.tools.XUtility.*;

/**
 * This class corresponds to a Java parser that uses DOM (Document Object Model) to parse XCSP3 instances. 

 * Here, we assume that the instance is well-formed (valid). This class is given for illustration purpose. Feel free to adapt it !
 * 
 * @author Christophe Lecoutre, CRIL-CNRS - [email protected]
 * @version 1
 */
public class XParser {

	/** The document to be parsed. */
	private Document document; //

	/** An XPath object that is useful for some tasks (queries). */
	private XPath xpath = XPathFactory.newInstance().newXPath();

	/** The map that stores pairs (id,variable). */
	private Map mapForVars = new HashMap<>();

	/** The map that stores pairs (id,array). */
	private Map mapForArrays = new HashMap<>();

	/** A map used as a cache for avoiding building several times the same domain objects; it stores pairs (textual-content,domain). */
	private Map cacheForContentToDomain = new HashMap<>();

	/** The list of entries of the element . It contains variables and arrays. */
	public List entriesOfVariables = new ArrayList<>();

	/**
	 * The list of entries of the element . It contains stand-alone constraints (extension, intension, allDifferent, ...), groups of constraints,
	 * and meta-constraints (sliding and logical constructions).
	 */
	public List entriesOfConstraints = new ArrayList<>();

	/** The list of objectives of the element . Typically, it contains 0 or 1 objective. */
	public List objectives = new ArrayList<>();

	/**********************************************************************************************
	 * Parsing of Variables (and Domains)
	 *********************************************************************************************/

	/** Parses a basic domain, i.e., a domain for an integer, symbolic, float or stochastic variable (or array). */
	private DomBasic parseDomBasic(Element elt, TypeVar type) {
		String content = elt.getTextContent().trim();
		DomBasic dom = (DomBasic) cacheForContentToDomain.get(content);
		if (dom == null)
			cacheForContentToDomain.put(content, dom = DomBasic.parse(content, type));
		return dom;
	}

	/** Parse a complex domain for a set variable (or array). */
	private DomSet parseDomSet(Element elt, TypeVar type) {
		Element[] childs = childElementsOf(elt);
		String req = childs[0].getTextContent().trim(), pos = childs[1].getTextContent().trim(), content = req + " | " + pos;
		DomSet dom = (DomSet) cacheForContentToDomain.get(content);
		if (dom == null)
			cacheForContentToDomain.put(content, dom = DomSet.parse(req, pos, type));
		return dom;
	}

	/** Parse a complex domain for a graph variable (or array). */
	private DomGraph parseDomGraph(Element elt, TypeVar type) {
		Element[] childs = childElementsOf(elt), req = childElementsOf(childs[0]), pos = childElementsOf(childs[1]);
		String reqV = req[0].getTextContent().trim(), reqE = req[1].getTextContent().trim();
		String posV = pos[0].getTextContent().trim(), posE = pos[1].getTextContent().trim();
		String content = reqV + " | " + reqE + " | " + posV + " | " + posE;
		DomGraph dom = (DomGraph) cacheForContentToDomain.get(content);
		if (dom == null)
			cacheForContentToDomain.put(content, dom = DomGraph.parse(reqV, reqE, posV, posE, type));
		return dom;
	}

	/** Parse a domain for any type of variable (or array). */
	private Dom parseDomain(Element elt, TypeVar type) {
		return type.isBasic() ? parseDomBasic(elt, type) : type.isSet() ? parseDomSet(elt, type) : parseDomGraph(elt, type);
	}

	/** Gives the type of the variable (or array). Recall that integer is the default value. */
	private TypeVar giveTypeVar(Element elt) {
		String s = elt.getAttribute(TypeAtt.type.name());
		return s.length() == 0 ? TypeVar.integer : TypeVar.valueOf(s.replaceFirst("\\s+", "_"));
	}

	/** Gives the 'size' (an array of integers as defined in XCSP3) of the array of variables. */
	private int[] giveArraySize(Element elt) {
		StringTokenizer st = new StringTokenizer(elt.getAttribute(TypeAtt.size.name()), "[]");
		return IntStream.range(0, st.countTokens()).map(i -> Integer.parseInt(st.nextToken())).toArray();
	}

	/** Allows us to manage aliases, i.e., indirection due to the use of the 'as' attribute. */
	private Element getActualElementToAnalyse(Element elt) {
		try {
			String id = elt.getAttribute(TypeAtt.as.name());
			return id.length() == 0 ? elt : (Element) xpath.evaluate("//*[@id='" + id + "']", document, XPathConstants.NODE);
		} catch (XPathExpressionException e) {
			e.printStackTrace();
			return (Element) XUtility.control(false, "Bad use of 'as'" + elt.getTagName());
		}
	}

	/** Parses all elements inside the element . */
	public void parseVariables() {
		Map cacheForId2Domain = new HashMap<>(); // a map for managing pairs (id,domain); remember that aliases can be encountered
		for (Element elt : childElementsOf(document, VARIABLES)) {
			String id = elt.getAttribute(TypeAtt.id.name());
			TypeVar type = giveTypeVar(elt);
			Element actualForElt = getActualElementToAnalyse(elt); // managing aliases, i.e., 'as' indirection
			Dom dom = cacheForId2Domain.get(actualForElt.getAttribute(TypeAtt.id.name())); // necessary not null when 'as' indirection
			if (elt.getTagName().equals(VAR)) {
				if (dom == null && !type.isQualitative())
					cacheForId2Domain.put(id, dom = parseDomain(actualForElt, type));
				entriesOfVariables.add(new Var(id, type, dom));
			} else {
				int[] size = giveArraySize(elt);
				if (dom == null && !type.isQualitative()) {
					Element[] childs = childElementsOf(actualForElt);
					if (childs.length > 0 && childs[0].getTagName().equals(DOMAIN)) { // we have to deal with mixed domains
						Array array = new Array(id, type, size);
						Stream.of(childs).forEach(child -> {
							Element actualForChild = getActualElementToAnalyse(child);
							Dom domChild = cacheForId2Domain.get(actualForChild.getAttribute(TypeAtt.id.name()));
							if (domChild == null) {
								domChild = parseDomain(actualForChild, type);
								String idChild = child.getAttribute(TypeAtt.id.name());
								if (idChild.length() > 0)
									cacheForId2Domain.put(idChild, domChild);
							}
							array.setDom(child.getAttribute("for"), domChild);
						});
						entriesOfVariables.add(array);
					} else {
						cacheForId2Domain.put(id, dom = parseDomain(actualForElt, type));
						entriesOfVariables.add(new Array(id, type, size, dom));
					}
				} else
					entriesOfVariables.add(new Array(id, type, size, dom));
			}
		}
		for (XVariables.Entry entry : entriesOfVariables)
			if (entry instanceof Var)
				mapForVars.put(entry.id, (Var) entry);
			else {
				Stream.of(((Array) entry).vars).forEach(var -> mapForVars.put(var.id, var));
				mapForArrays.put(entry.id, (Array) entry);
			}
		// entriesOfVariables.stream().forEach(e -> System.out.println(e));
	}

	/**********************************************************************************************
	 * General Parsing Methods (for basic entities, conditions, simple and double sequences)
	 *********************************************************************************************/

	/**
	 * Parse the specified token, as a variable, an interval, a rational, a decimal, a long, a set (literal), a parameter, or a functional expression. If
	 * nothing above matches, the token is returned (and considered as a symbolic value).
	 */
	private Object parseData(String tok) {
		if (mapForVars.get(tok) != null)
			return mapForVars.get(tok);
		if (Character.isDigit(tok.charAt(0)) || tok.charAt(0) == '+' || tok.charAt(0) == '-') {
			String[] t = tok.split("\\.\\.");
			if (t.length == 2)
				return new IntegerInterval(safeLong(t[0]), safeLong(t[1]));
			t = tok.split("/");
			if (t.length == 2)
				return new Rational(safeLong(t[0]), safeLong(t[1]));
			t = tok.split("\\.");
			if (t.length == 2)
				return new Decimal(safeLong(t[0]), safeLong(t[1]));
			return safeLong(tok);
		}
		if (tok.charAt(0) == '{') { // set value
			String sub = tok.substring(1, tok.length() - 1); // empty set if sub.length() = 0
			return sub.length() == 0 ? new Object[] {} : Stream.of(sub.split("\\s*,\\s*")).mapToLong(s -> safeLong(s)).toArray();
		}
		if (tok.charAt(0) == '%')
			return new Parameter(tok.equals("%...") ? -1 : Integer.parseInt(tok.substring(1)));
		if (tok.indexOf("(") != -1)
			return parseExpression(tok);
		return tok; // tok must be a symbolic value
	}

	private Object parseData(Element elt) {
		return parseData(elt.getTextContent().trim());
	}

	/** Parses a pair of the form (operator, operand) */
	private Object[] parseCondition(String tok) {
		int pos = tok.indexOf(',');
		String left = tok.substring(tok.charAt(0) != '(' ? 0 : 1, pos), right = tok.substring(pos + 1, tok.length()
				- (tok.charAt(tok.length() - 1) == ')' ? 1 : 0));
		return new Object[] { TypeConditionOperator.valueOf(left), parseData(right) };
	}

	/** Parses a pair of the form (operator, operand) */
	private Object[] parseCondition(Element elt) {
		return parseCondition(elt.getTextContent().trim());
	}

	/** Parses a sequence of pairs of the form (operator, operand) */
	private Object[][] parseConditions(Element elt) {
		return Stream.of(elt.getTextContent().trim().split(DELIMITER_LISTS)).skip(1).map(tok -> parseCondition(tok)).toArray(Object[][]::new);
	}

	/**
	 * Parse a sequence of tokens (separated by the specified delimiter). Each token can represent a compact list of array variables, or a basic entity.
	 */
	private Object[] parseSequence(String seq, String delimiter) {
		List