/// /// <summary> * Inverts the boolean state of a Term child element (and, or, xor, not, /// * Evaluation, TestRef) /// * </summary> /// * <param name="jdf"> /// * JDFNode we test to know if the Device can accept it </param> /// * <param name="reportRoot"> /// * the report to generate. Set to <code>null</code> if no report /// * is requested. </param> /// * <returns> boolean - true, if boolean “not” expression evaluates to “true” </returns> /// public override bool fitsJDF(KElement jdf, KElement reportRoot) { KElement reportRootLocal = reportRoot; VElement v = getTermVector(null); int siz = v.Count; bool b = false; if (reportRootLocal != null) { reportRootLocal = reportRootLocal.appendElement("not"); } int count = 0; for (int i = 0; i < siz; i++) { JDFTerm t = (JDFTerm)v[i]; b = !t.fitsJDF(jdf, reportRootLocal); count++; if (reportRootLocal != null) { reportRootLocal.setAttribute("Value", b, null); } } if (reportRootLocal != null && count != 1) { reportRootLocal.setAttribute("SyntaxWarning", "Warning: not element with more than one term, count=" + Convert.ToString(count)); } return(b); }
/// /// <summary> * Evaluates the boolean expression (child Term element) if it fits the /// * JDFNode 'jdf' a value of true corresponds to a failed test, i.e. the test /// * describes INVALID states for the jdf /// * </summary> /// * <param name="jdf"> /// * JDFNode to test to know if the Device can accept it </param> /// * <param name="reportRoot"> /// * the report to generate. Set to <code>null</code> if no report /// * is requested. </param> /// * <returns> boolean - true, if boolean expression (child Term element) /// * evaluates to “true” </returns> /// public override bool fitsJDF(KElement jdf, KElement reportRoot) { KElement reportRootLocal = reportRoot; if (reportRootLocal != null) { reportRootLocal = reportRootLocal.appendElement("TestReport"); } JDFTerm t = getTerm(); if (t == null) { return(true); // no term --> assume it is a non test; i.e. ok } bool checkContext = true; if (hasAttribute(AttributeName.CONTEXT)) { checkContext = !jdf.matchesPath(getContext(), true); } if (checkContext && !t.fitsContext(jdf)) { return(true); } bool b = t.fitsJDF(jdf, reportRootLocal); if (reportRootLocal != null) { reportRootLocal.setAttribute("Value", b, null); } return(b); }
/// /// <summary> * check whether the boolean logic defined by a Test and a test's /// * subelements make sense in the context of the tested element jdf </summary> /// public override bool fitsContext(KElement testElement) { // we only want the leaves as of now if (testElement is JDFResource) { JDFResource r = (JDFResource)testElement; if (!r.isLeaf()) { return(false); } } VElement v = getTermVector(null); int siz = v.Count; for (int i = 0; i < siz; i++) { JDFTerm t = (JDFTerm)v[i]; if (!t.fitsContext(testElement)) // one bad context spoils the // barrell { return(false); } } return(siz > 0); // if no subelements, then no context }
/// /// <summary> * Evaluates two or more Term elements (and, or, xor, not, Evaluation, /// * TestRef) to determine if, as a set, they evaluate to “true” when combined /// * in a boolean “or” function. /// * </summary> /// * <param name="jdf"> /// * JDFNode we test iot know if the Device can accept it </param> /// * <returns> boolean - true, if boolean “or” expression evaluates to “true” </returns> /// public override bool fitsJDF(KElement jdf, KElement reportRoot) { KElement reportRootLocal = reportRoot; VElement v = getTermVector(null); int siz = v.Count; if (reportRootLocal != null) { reportRootLocal = reportRootLocal.appendElement("or"); } bool b = false; for (int i = 0; i < siz; i++) { JDFTerm t = (JDFTerm)v[i]; bool b2 = t.fitsJDF(jdf, reportRootLocal); if (b2 && reportRootLocal == null) { return(true); // don't need complete report and it is true; ciao } b = b || b2; } if (reportRootLocal != null) { reportRootLocal.setAttribute("Value", b, null); } return(b); }
/// /// <summary> * Inverts the boolean state of a Term element (and, or, xor, not, /// * Evaluation, TestRef).<br> /// * To determine the state of Term tests Evaluations that “not” consists of, /// * it checks whether attribute map 'm' has a key, specified by /// * Evaluation/BasicPreflightTest/@Name. If 'm' has such key, it checks /// * whether its value fits the testlists specified for matching the /// * Evaluation (uses FitsValue(value)) /// * </summary> /// * <param name="m"> /// * key-value pair attribute map </param> /// * <returns> boolean - true, if boolean “not” expression evaluates to “true” </returns> /// public override bool fitsMap(JDFAttributeMap m) { JDFTerm t = getTerm(null, 0); if (t == null) { return(false); } return(!t.fitsMap(m)); }
/// /// <summary> * Evaluates two or more Term elements ( /// * <code>and, or, xor, not, Evaluation, TestRef</code>) to determine if, as /// * a set, they evaluate to “true” when combined in a boolean “and” function. <br> /// * Looks for evaluations which contain <code>and</code>. Tests the status of /// * every evaluation found, until the result of a whole boolean expression /// * will is determinated. <br> /// * Tests if attribute map <code>m</code> has a key, specified by /// * Evaluation/BasicPreflightTest/@Name and if <code>m</code> has such key, /// * checks if its value fits testlists, specified for matching Evaluation /// * (uses <code>FitsValue(value)</code>) /// * </summary> /// * <param name="m"> /// * key-value pair attribute map </param> /// * <returns> boolean - true, if boolean “and” expression evaluates to “true” </returns> /// public override bool fitsMap(JDFAttributeMap m) { VElement v = getTermVector(null); int siz = v.Count; for (int i = 0; i < siz; i++) { JDFTerm t = (JDFTerm)v[i]; if (!t.fitsMap(m)) { return(false); } } return(true); }
/// /// <summary> * Evaluates two or more Term elements (and, or, xor, not, Evaluation, /// * TestRef) to determine if, as a set, they evaluate to “true” when combined /// * in a boolean “xor” function. ! For more than two arguments, exactly one /// * Term must evaluate to “true” for the “xor” to evaluate to “true”.<br> /// * /// * Looks for Evaluations that “xor” consists of, and tests the status of /// * every Evaluation, until the result of a whole boolean expression is /// * determinated. Tests whether attribute map 'm' has a key specified by /// * Evaluation/BasicPreflightTest/@Name. If 'm' has such key, checks if its /// * value fits the testlists, specified for matching Evaluation (uses /// * FitsValue(value)) /// * </summary> /// * <param name="m"> /// * key-value pair attribute map </param> /// * <returns> boolean - true, if boolean “xor” expression evaluates to “true” </returns> /// public override bool fitsMap(JDFAttributeMap m) { VElement v = getChildElementVector(null, null, null, true, 0, false); int siz = v.Count; int count = 0; for (int i = 0; i < siz; i++) { JDFTerm t = (JDFTerm)v[i]; if (t.fitsMap(m)) { count++; } if (count > 1) { return(false); } } return(count == 1); }
/// /// <summary> * Evaluates two or more Term elements (and, or, xor, not, Evaluation, /// * TestRef) to determine if, as a set, they evaluate to “true” when combined /// * in a boolean “xor” function. /// * </summary> /// * <param name="jdf"> /// * JDFNode to test to know if the Device can accept it </param> /// * <param name="reportRoot"> /// * the report to generate; set to <code>null</code> if no report /// * is requested </param> /// * <returns> boolean - true, if boolean “xor” expression evaluates to “true” </returns> /// public override bool fitsJDF(KElement jdf, KElement reportRoot) { KElement reportRootLocal = reportRoot; VElement v = getTermVector(null); if (reportRootLocal != null) { reportRootLocal = reportRootLocal.appendElement("xor"); } int siz = v.Count; int count = 0; for (int i = 0; i < siz; i++) { JDFTerm t = (JDFTerm)v[i]; if (t.fitsJDF(jdf, reportRootLocal)) { count++; } if (count > 1 && reportRootLocal == null) { break; } } bool b = (count == 1); if (reportRootLocal != null) { reportRootLocal.setAttribute("Value", b, null); } return(b); }
/// /// <summary> * Evaluates two or more term elements ( /// * <code>and, or, xor, not, Evaluation, TestRef</code>) to determine if, as /// * a set, they evaluate to “true” when combined in a boolean “and” function. /// * </summary> /// * <param name="jdf"> /// * the JDFNode to be checked iot find out if the device can /// * accept it </param> /// * <returns> boolean - true, if boolean “and” expression evaluates to “true” </returns> /// public override bool fitsJDF(KElement jdf, KElement reportRoot) // const JDFNode { KElement reportRootLocal = reportRoot; VElement v = getTermVector(null); if (reportRootLocal != null) { reportRootLocal = reportRootLocal.appendElement("and"); } int siz = v.Count; bool b = true; for (int i = 0; i < siz; i++) { JDFTerm t = (JDFTerm)v[i]; bool b2 = t.fitsJDF(jdf, reportRootLocal); if (!b2) { if (reportRootLocal == null) { return(false); } } b = b && b2; } if (reportRootLocal != null) { reportRootLocal.setAttribute("Value", b, null); } return(b); }
/// /// <summary> * Evaluates the boolean expression (child Term element) if it fits the /// * attribute map 'm' /// * </summary> /// * <param name="m"> /// * key-value pair attribute map </param> /// * <returns> boolean - true, if the boolean expression (child Term element) /// * evaluates to “true” </returns> /// public override bool fitsMap(JDFAttributeMap m) { JDFTerm t = getTerm(); return(t == null ? false : t.fitsMap(m)); }