/*============================================================================= * parser for CSP instances represented in XCSP3 Format * * Copyright (c) 2015 xcsp.org (contact xcsp.org) * * 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. *============================================================================= */ #ifndef XCONSTRAINT_H #define XCONSTRAINT_H #include "XCSP3Variable.h" #include "XCSP3utils.h" #include "XCSP3Constants.h" #include #include #include namespace XCSP3Core { using namespace std; class XConstraintGroup; class XConstraintIntension; /*************************************************************************** * A constraint XValue **************************************************************************/ class XConstraint { public : std::string id; vector list; string classes; XConstraint(std::string dd, std::string c) : id(dd), classes(c) {} virtual ~XConstraint() {} virtual void unfoldParameters(XConstraintGroup *group, vector &arguments, XConstraint *original); }; /*************************************************************************** * A constraint group * Only basic abstraction is implemented: All parameters occur in the same tag **************************************************************************/ class XConstraintGroup : public XConstraint { public : XConstraint *constraint; // A Constraint group contains a constraint vector > arguments; // The list of all arguments ConstraintType type; // Use it to discover the type of constraint... and perform cast map toArguments; XConstraintGroup(std::string idd, std::string c) : XConstraint(idd, c), constraint(NULL), type(UNKNOWN) {} virtual ~XConstraintGroup() { delete constraint; } void unfoldVector(vector &toUnfold, vector &args, vector &initial); void unfoldString(string &toUnfold, vector &args); void unfoldArgumentNumber(int, XConstraint *builtConstraint); }; // All different structures related to XVariables used in constraints // This facilitates the unfolding of group constraint class XCondition { public : OrderType op; OperandType operandType; int val; int min, max; string var; friend ostream &operator<<(ostream &f, const XCSP3Core::XCondition &ie); }; class XInitialCondition { public : string condition; void unfoldParameters(XConstraintGroup *group, vector &arguments, XConstraint *original); void extractCondition(XCondition &xc); // Create the op and the operand (which can be a value, an interval or a XVariable) }; class XValues { public : vector values; // Only XVariable or XInteger void unfoldParameters(XConstraintGroup *group, vector &arguments, XConstraint *original); }; class XValue { public : XVariable *value; XValue() : value(0) {} void unfoldParameters(XConstraintGroup *group, vector &arguments, XConstraint *original); }; class XIndex { public : XVariable *index; XIndex() : index(0) {} void unfoldParameters(XConstraintGroup *group, vector &arguments, XConstraint *original); }; class XLengths { public : vector lengths; void unfoldParameters(XConstraintGroup *group, vector &arguments, XConstraint *original); }; /*************************************************************************** * constraint extension **************************************************************************/ class XConstraintExtension : public XConstraint { public : vector > tuples; bool isSupport; bool containsStar; XConstraintExtension(std::string idd, std::string c) : XConstraint(idd, c), containsStar(false) {} void unfoldParameters(XConstraintGroup *group, vector &arguments, XConstraint *original) override; }; /*************************************************************************** * constraint intension **************************************************************************/ class XConstraintIntension : public XConstraint { public : string function; XConstraintIntension(std::string idd, std::string c) : XConstraint(idd, c) {} void unfoldParameters(XConstraintGroup *group, vector &arguments, XConstraint *original) override; }; /*************************************************************************** **************************************************************************** * CONSTRAINTS DEFINED ON LANGAGES **************************************************************************** ***************************************************************************/ /*************************************************************************** * constraint regular **************************************************************************/ class XTransition { public : XTransition(string f, int v, string t) : from(f), val(v), to(t) {} string from; int val; string to; }; static vector tr; // Not beautiful but remove code to fixed data in group constraint. static string st; static vector fi; class XConstraintRegular : public XConstraint { public : string &start; vector &final; vector &transitions; XConstraintRegular(std::string idd, std::string c) : XConstraint(idd, c), start(st), final(fi), transitions(tr) {} }; /*************************************************************************** * constraint mdd **************************************************************************/ class XConstraintMDD : public XConstraint { public : vector &transitions; XConstraintMDD(std::string idd, std::string c) : XConstraint(idd, c), transitions(tr) {} }; /*************************************************************************** **************************************************************************** * COMPARISON BASED CONSTRAINTS **************************************************************************** ***************************************************************************/ static vector _except; class XConstraintAllDiff : public XConstraint { public : vector &except; XConstraintAllDiff(std::string idd, std::string c) : XConstraint(idd, c), except(_except) {} }; class XConstraintAllDiffMatrix : public XConstraint { public : vector > matrix; XConstraintAllDiffMatrix(std::string idd, std::string c) : XConstraint(idd, c) {} XConstraintAllDiffMatrix(std::string idd, std::string c, vector > &mat) : XConstraint(idd, c) { matrix.resize(mat.size()); for(unsigned int i = 0 ; i < mat.size() ; i++) matrix[i].assign(mat[i].begin(), mat[i].end()); } void unfoldParameters(XConstraintGroup *group, vector &arguments, XConstraint *original) override; }; typedef XConstraintAllDiffMatrix XConstraintAllDiffList; typedef XConstraint XConstraintAllEqual; /*************************************************************************** * constraint ordered and lex **************************************************************************/ static OrderType _op; class XConstraintOrdered : public XConstraint, public XLengths { public : OrderType &op; XConstraintOrdered(std::string idd, std::string c) : XConstraint(idd, c), op(_op) {} void unfoldParameters(XConstraintGroup *group, vector &arguments, XConstraint *original) override; }; class XConstraintLex : public XConstraintOrdered { public : // list is cleard and all lists are stored in lists vector > lists; XConstraintLex(std::string idd, std::string c) : XConstraintOrdered(idd, c) {} void unfoldParameters(XConstraintGroup *group, vector &arguments, XConstraint *original) override; }; class XConstraintLexMatrix : public XConstraintOrdered { public : vector > matrix; XConstraintLexMatrix(std::string idd, std::string c) : XConstraintOrdered(idd, c) {} void unfoldParameters(XConstraintGroup *group, vector &arguments, XConstraint *original) override; }; /*************************************************************************** **************************************************************************** * SUMMING and COUNTING CONSTRAINTS **************************************************************************** ***************************************************************************/ /*************************************************************************** * constraint sum **************************************************************************/ //static vector _coeffs; class XConstraintSum : public XConstraint, public XInitialCondition, public XValues { public : // vector &coeffs; XConstraintSum(std::string idd, std::string c) : XConstraint(idd, c) {} void unfoldParameters(XConstraintGroup *group, vector &arguments, XConstraint *original) override; }; class XConstraintNValues : public XConstraint, public XInitialCondition { public : vector &except; XConstraintNValues(std::string idd, std::string c) : XConstraint(idd, c), except(_except) {} void unfoldParameters(XConstraintGroup *group, vector &arguments, XConstraint *original) override; }; class XConstraintCardinality : public XConstraint, public XValues { public : vector occurs; bool closed; XConstraintCardinality(std::string idd, std::string c) : XConstraint(idd, c) {} void unfoldParameters(XConstraintGroup *group, vector &arguments, XConstraint *original) override; }; /*************************************************************************** * constraint count **************************************************************************/ class XConstraintCount : public XConstraint, public XInitialCondition, public XValues { public : XConstraintCount(std::string idd, std::string c) : XConstraint(idd, c) {} void unfoldParameters(XConstraintGroup *group, vector &arguments, XConstraint *original) override; }; /*************************************************************************** **************************************************************************** * CONNECTION CONSTRAINTS **************************************************************************** ***************************************************************************/ /*************************************************************************** * constraint minimum and maximum * startIndex and rank are useful iff index!=NULL * in such a case condition is optionnal (=="") **************************************************************************/ class XConstraintMaximum : public XConstraint, public XInitialCondition, public XIndex { public : int startIndex; RankType rank; XConstraintMaximum(std::string idd, std::string c) : XConstraint(idd, c), startIndex(0), rank(ANY) {} void unfoldParameters(XConstraintGroup *group, vector &arguments, XConstraint *original) override; }; typedef XConstraintMaximum XConstraintMinimum; /*************************************************************************** * constraint element **************************************************************************/ class XConstraintElement : public XConstraint, public XIndex, public XValue { public : int startIndex; RankType rank; XConstraintElement(std::string idd, std::string c) : XConstraint(idd, c), startIndex(0), rank(ANY) {} void unfoldParameters(XConstraintGroup *group, vector &arguments, XConstraint *original) override; }; /*************************************************************************** * constraint channel **************************************************************************/ class XConstraintChannel : public XConstraint, public XValue { public : vector secondList; int startIndex1; int startIndex2; XConstraintChannel(std::string idd, std::string c) : XConstraint(idd, c), startIndex1(0), startIndex2(0) {} void unfoldParameters(XConstraintGroup *group, vector &arguments, XConstraint *original) override; }; /*************************************************************************** **************************************************************************** * PACKING AND SCHEDULING CONSTRAINTS **************************************************************************** ***************************************************************************/ /*************************************************************************** * constraint noOverlap **************************************************************************/ class XConstraintNoOverlap : public XConstraint, public XLengths { public : // Be careful origins is the vector list!!! vector &origins; bool zeroIgnored; XConstraintNoOverlap(std::string idd, std::string c) : XConstraint(idd, c), origins(list) {} void unfoldParameters(XConstraintGroup *group, vector &arguments, XConstraint *original) override; }; /*************************************************************************** * constraint Cumulative **************************************************************************/ class XConstraintCumulative : public XConstraint, public XLengths, public XInitialCondition { public : // Be careful origin is the vector list!!! vector &origins; vector ends; vector heights; XConstraintCumulative(std::string idd, std::string c) : XConstraint(idd, c), origins(list) {} void unfoldParameters(XConstraintGroup *group, vector &arguments, XConstraint *original) override; }; /*************************************************************************** * constraint stretch **************************************************************************/ class XConstraintStretch : public XConstraint { public : vector values; // Only integers vector widths; // interval vector > patterns; XConstraintStretch(std::string idd, std::string c) : XConstraint(idd, c) {} // Group is valied with lists only. void unfoldParameters(XConstraintGroup *group, vector &arguments, XConstraint *original) override; }; /*************************************************************************** * constraint instantiation **************************************************************************/ static vector _values; class XConstraintInstantiation : public XConstraint { public : vector &values; XConstraintInstantiation(std::string idd, std::string c) : XConstraint(idd, c), values(_values) {} }; /*************************************************************************** **************************************************************************** * COMPARISON BASED CONSTRAINTS **************************************************************************** ***************************************************************************/ class XConstraintCircuit : public XConstraint, public XValue { // value => size public : XConstraintCircuit(std::string idd, std::string c) : XConstraint(idd, c) {} int startIndex; void unfoldParameters(XConstraintGroup *group, vector &arguments, XConstraint *original) override; }; } #endif /* XCONSTRAINT_H */