com.helger.schematron.pure.model.PSPattern Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of ph-schematron Show documentation
Show all versions of ph-schematron Show documentation
Library for validating XML documents with Schematron
/**
* Copyright (C) 2014-2017 Philip Helger (www.helger.com)
* philip[at]helger[dot]com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.helger.schematron.pure.model;
import java.util.Map;
import javax.annotation.Nonnegative;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import javax.annotation.concurrent.NotThreadSafe;
import com.helger.commons.ValueEnforcer;
import com.helger.commons.annotation.ReturnsMutableCopy;
import com.helger.commons.collection.CollectionHelper;
import com.helger.commons.collection.ext.CommonsArrayList;
import com.helger.commons.collection.ext.CommonsLinkedHashMap;
import com.helger.commons.collection.ext.ICommonsList;
import com.helger.commons.collection.ext.ICommonsOrderedMap;
import com.helger.commons.string.StringHelper;
import com.helger.commons.string.ToStringGenerator;
import com.helger.schematron.CSchematron;
import com.helger.schematron.CSchematronXML;
import com.helger.schematron.pure.errorhandler.IPSErrorHandler;
import com.helger.xml.microdom.IMicroElement;
import com.helger.xml.microdom.MicroElement;
/**
* A single Schematron pattern-element.
* A structure, simple or complex. A set of rules giving constraints that are in
* some way related. The id attribute provides a unique name for the pattern and
* is required for abstract patterns.
* The title and p elements allow rich documentation.
* The icon, see and fpi attributes allow rich interfaces and documentation.
* When a pattern element has the attribute abstract with a value true, then the
* pattern defines an abstract pattern. An abstract pattern shall not have a
* is-a attribute and shall have an id attribute.
* Abstract patterns allow a common definition mechanism for structures which
* use different names and paths, but which are at heart the same. For example,
* there are different table markup languages, but they all can be in large part
* represented as an abstract pattern where a table contains rows and rows
* contain entries, as defined in the following example using the default query
* language binding:
*
*
* <sch:pattern abstract="true" id="table">
* <sch:rule context="$table">
* <sch:assert test="$row">
* The element <sch:name/> is a table. Tables contain rows.
* </sch:assert>
* </sch:rule>
* <sch:rule context="$row">
* <sch:assert test="$entry">
* The element <sch:name/> is a table row. Rows contain entries.
* </sch:assert>
* </sch:rule>
* </sch:pattern>
*
*
* When a pattern element has the attribute is-a with a value specifying the
* name of an abstract pattern, then the pattern is an instance of an abstract
* pattern. Such a pattern shall not contain any rule elements, but shall have
* param elements for all parameters used in the abstract pattern.
* The following example uses the abstract pattern for tables given above to
* create three patterns for tables with different names or structures.
*
*
* <sch:pattern is-a="table" id="HTML_Table">
* <sch:param name="table" value="table"/>
* <sch:param name="row" value="tr"/>
* <sch:param name="entry" value="td|th"/>
* </sch:pattern>
* <sch:pattern is-a="table" id="CALS_Table">
* <sch:param name="table" value="table"/>
* <sch:param name="row" value=".//row"/>
* <sch:param name="entry" value="cell"/>
* </sch:pattern>
* <sch:pattern is-a="table" id="calendar">
* <sch:param name="table" value="calendar/year"/>
* <sch:param name="row" value="week"/>
* <sch:param name="entry" value="day"/>
* </sch:pattern>
*
*
* When creating an instance of an abstract pattern, the parameter values
* supplied by the param element replace the parameter references used in the
* abstract patterns. The examples above use the default query language binding
* in which the character $ is used as the delimiter for parameter references.
*
* Thus, given the abstract patterns defined earlier in this clause, the
* patterns defined above are equivalent to the following, with the id elements
* shown expanded:
*
*
* <sch:pattern id="HTML_table">
* <sch:rule context="table">
* <sch:assert test="tr">
* The element table is a table. Tables containing rows.
* </sch:assert>
* </sch:rule>
* <sch:rule context="tr">
* <sch:assert test="td|th">
* The element tr is a table row. Rows contain entries.
* </sch:assert>
* </sch:rule>
* </sch:pattern>
* <sch:pattern id="CALS_table">
* <sch:rule context="table">
* <sch:assert test=".//row">
* The element table is a table. Tables containing rows.
* </sch:assert>
* </sch:rule>
* <sch:rule context=".//row">
* <sch:assert test="cell">
* The element row is a table row. Rows contain entries.
* </sch:assert>
* </sch:rule>
* </sch:pattern>
* <sch:pattern id="calendar">
* <sch:rule context="calendar/year">
* <sch:assert test="week">
* The element year is a table. Tables containing rows.
* </sch:assert>
* </sch:rule>
* <sch:rule context="week">
* <sch:assert test="day">
* The element week is a table row. Rows contain entries.
* </sch:assert>
* </sch:rule>
* </sch:pattern>
*
*
* @author Philip Helger
*/
@NotThreadSafe
public class PSPattern implements
IPSElement,
IPSHasID,
IPSHasForeignElements,
IPSHasIncludes,
IPSHasLets,
IPSHasRichGroup
{
private boolean m_bAbstract = false;
private String m_sID;
private String m_sIsA;
private PSRichGroup m_aRich;
private final ICommonsList m_aIncludes = new CommonsArrayList <> ();
private PSTitle m_aTitle;
private final ICommonsList m_aContent = new CommonsArrayList <> ();
private ICommonsOrderedMap m_aForeignAttrs;
private ICommonsList m_aForeignElements;
public PSPattern ()
{}
public boolean isValid (@Nonnull final IPSErrorHandler aErrorHandler)
{
// If abstract, an ID must be present
if (m_bAbstract && StringHelper.hasNoText (m_sID))
{
aErrorHandler.error (this, "abstract does not have an 'id'");
return false;
}
// is-a may not be present for abstract rules
if (m_bAbstract && StringHelper.hasText (m_sIsA))
{
aErrorHandler.error (this, "abstract may not have an 'is-a'");
return false;
}
if (StringHelper.hasNoText (m_sIsA))
{
// param only if is-a is set
for (final IPSElement aContent : m_aContent)
if (aContent instanceof PSParam)
{
aErrorHandler.error (this, " without 'is-a' may not contain s");
return false;
}
}
else
{
// rule and let only if is-a is not set
for (final IPSElement aContent : m_aContent)
{
if (aContent instanceof PSRule)
{
aErrorHandler.error (this, " with 'is-a' may not contain s");
return false;
}
if (aContent instanceof PSLet)
{
aErrorHandler.error (this, " with 'is-a' may not contain s");
return false;
}
}
}
for (final PSInclude aInclude : m_aIncludes)
if (!aInclude.isValid (aErrorHandler))
return false;
if (m_aTitle != null && !m_aTitle.isValid (aErrorHandler))
return false;
for (final IPSElement aContent : m_aContent)
if (!aContent.isValid (aErrorHandler))
return false;
return true;
}
public void validateCompletely (@Nonnull final IPSErrorHandler aErrorHandler)
{
// If abstract, an ID must be present
if (m_bAbstract && StringHelper.hasNoText (m_sID))
aErrorHandler.error (this, "abstract does not have an 'id'");
// is-a may not be present for abstract rules
if (m_bAbstract && StringHelper.hasText (m_sIsA))
aErrorHandler.error (this, "abstract may not have an 'is-a'");
if (StringHelper.hasNoText (m_sIsA))
{
// param only if is-a is set
for (final IPSElement aContent : m_aContent)
if (aContent instanceof PSParam)
aErrorHandler.error (this, " without 'is-a' may not contain s");
}
else
{
// rule and let only if is-a is not set
for (final IPSElement aContent : m_aContent)
{
if (aContent instanceof PSRule)
aErrorHandler.error (this, " with 'is-a' may not contain s");
if (aContent instanceof PSLet)
aErrorHandler.error (this, " with 'is-a' may not contain s");
}
}
for (final PSInclude aInclude : m_aIncludes)
aInclude.validateCompletely (aErrorHandler);
if (m_aTitle != null)
m_aTitle.validateCompletely (aErrorHandler);
for (final IPSElement aContent : m_aContent)
aContent.validateCompletely (aErrorHandler);
}
public boolean isMinimal ()
{
if (m_bAbstract)
return false;
if (StringHelper.hasText (m_sIsA))
return false;
for (final PSInclude aInclude : m_aIncludes)
if (!aInclude.isMinimal ())
return false;
if (m_aTitle != null && !m_aTitle.isMinimal ())
return false;
for (final IPSElement aContent : m_aContent)
if (!aContent.isMinimal ())
return false;
return true;
}
public void addForeignElement (@Nonnull final IMicroElement aForeignElement)
{
ValueEnforcer.notNull (aForeignElement, "ForeignElement");
if (aForeignElement.hasParent ())
throw new IllegalArgumentException ("ForeignElement already has a parent!");
if (m_aForeignElements == null)
m_aForeignElements = new CommonsArrayList <> ();
m_aForeignElements.add (aForeignElement);
}
public boolean hasForeignElements ()
{
return m_aForeignElements != null && m_aForeignElements.isNotEmpty ();
}
@Nonnull
@ReturnsMutableCopy
public ICommonsList getAllForeignElements ()
{
return new CommonsArrayList <> (m_aForeignElements);
}
public void addForeignAttribute (@Nonnull final String sAttrName, @Nonnull final String sAttrValue)
{
ValueEnforcer.notNull (sAttrName, "AttrName");
ValueEnforcer.notNull (sAttrValue, "AttrValue");
if (m_aForeignAttrs == null)
m_aForeignAttrs = new CommonsLinkedHashMap <> ();
m_aForeignAttrs.put (sAttrName, sAttrValue);
}
public boolean hasForeignAttributes ()
{
return m_aForeignAttrs != null && m_aForeignAttrs.isNotEmpty ();
}
@Nonnull
@ReturnsMutableCopy
public ICommonsOrderedMap getAllForeignAttributes ()
{
return new CommonsLinkedHashMap <> (m_aForeignAttrs);
}
public void setAbstract (final boolean bAbstract)
{
m_bAbstract = bAbstract;
}
public boolean isAbstract ()
{
return m_bAbstract;
}
public void setID (@Nullable final String sID)
{
m_sID = sID;
}
@Nullable
public String getID ()
{
return m_sID;
}
public void setIsA (@Nullable final String sIsA)
{
m_sIsA = sIsA;
}
@Nullable
public String getIsA ()
{
return m_sIsA;
}
public void setRich (@Nullable final PSRichGroup aRich)
{
m_aRich = aRich;
}
@Nullable
public PSRichGroup getRich ()
{
return m_aRich;
}
public void addInclude (@Nonnull final PSInclude aInclude)
{
ValueEnforcer.notNull (aInclude, "Include");
m_aIncludes.add (aInclude);
}
public boolean hasAnyInclude ()
{
return m_aIncludes.isNotEmpty ();
}
@Nonnull
@ReturnsMutableCopy
public ICommonsList getAllIncludes ()
{
return m_aIncludes.getClone ();
}
public void setTitle (@Nullable final PSTitle aTitle)
{
m_aTitle = aTitle;
}
@Nullable
public PSTitle getTitle ()
{
return m_aTitle;
}
public boolean hasTitle ()
{
return m_aTitle != null;
}
public void addRule (@Nonnull final PSRule aRule)
{
ValueEnforcer.notNull (aRule, "Rule");
m_aContent.add (aRule);
}
@Nullable
public PSRule getRuleOfID (@Nullable final String sID)
{
if (StringHelper.hasText (sID))
for (final IPSElement aElement : m_aContent)
if (aElement instanceof PSRule)
{
final PSRule aRule = (PSRule) aElement;
if (sID.equals (aRule.getID ()))
return aRule;
}
return null;
}
@Nonnull
@ReturnsMutableCopy
public ICommonsList getAllRules ()
{
return m_aContent.getAllInstanceOf (PSRule.class);
}
@Nonnegative
public int getRuleCount ()
{
return m_aContent.getCount (e -> e instanceof PSRule);
}
public void addParam (@Nonnull final PSParam aParam)
{
ValueEnforcer.notNull (aParam, "Param");
m_aContent.add (aParam);
}
@Nonnull
@ReturnsMutableCopy
public ICommonsList getAllParams ()
{
return m_aContent.getAllInstanceOf (PSParam.class);
}
public boolean hasAnyParam ()
{
return m_aContent.containsAny (e -> e instanceof PSParam);
}
public void addP (@Nonnull final PSP aP)
{
ValueEnforcer.notNull (aP, "P");
m_aContent.add (aP);
}
@Nonnull
@ReturnsMutableCopy
public ICommonsList getAllPs ()
{
return m_aContent.getAllInstanceOf (PSP.class);
}
public void addLet (@Nonnull final PSLet aLet)
{
ValueEnforcer.notNull (aLet, "Let");
m_aContent.add (aLet);
}
public boolean hasAnyLet ()
{
return m_aContent.containsAny (e -> e instanceof PSLet);
}
@Nonnull
@ReturnsMutableCopy
public ICommonsList getAllLets ()
{
return m_aContent.getAllInstanceOf (PSLet.class);
}
@Nonnull
@ReturnsMutableCopy
public ICommonsOrderedMap getAllLetsAsMap ()
{
final ICommonsOrderedMap ret = new CommonsLinkedHashMap <> ();
for (final IPSElement aElement : m_aContent)
if (aElement instanceof PSLet)
{
final PSLet aLet = (PSLet) aElement;
ret.put (aLet.getName (), aLet.getValue ());
}
return ret;
}
/**
* @return A list consisting of {@link PSP}, {@link PSLet}, {@link PSRule} and
* {@link PSParam} parameters
*/
@Nonnull
@ReturnsMutableCopy
public ICommonsList getAllContentElements ()
{
return m_aContent.getClone ();
}
@Nonnull
public IMicroElement getAsMicroElement ()
{
final IMicroElement ret = new MicroElement (CSchematron.NAMESPACE_SCHEMATRON, CSchematronXML.ELEMENT_PATTERN);
if (m_bAbstract)
ret.setAttribute (CSchematronXML.ATTR_ABSTRACT, "true");
ret.setAttribute (CSchematronXML.ATTR_ID, m_sID);
ret.setAttribute (CSchematronXML.ATTR_IS_A, m_sIsA);
if (m_aRich != null)
m_aRich.fillMicroElement (ret);
if (m_aForeignElements != null)
for (final IMicroElement aForeignElement : m_aForeignElements)
ret.appendChild (aForeignElement.getClone ());
for (final PSInclude aInclude : m_aIncludes)
ret.appendChild (aInclude.getAsMicroElement ());
if (m_aTitle != null)
ret.appendChild (m_aTitle.getAsMicroElement ());
for (final IPSElement aContent : m_aContent)
ret.appendChild (aContent.getAsMicroElement ());
if (m_aForeignAttrs != null)
for (final Map.Entry aEntry : m_aForeignAttrs.entrySet ())
ret.setAttribute (aEntry.getKey (), aEntry.getValue ());
return ret;
}
@Override
public String toString ()
{
return new ToStringGenerator (this).append ("abstract", m_bAbstract)
.appendIfNotNull ("id", m_sID)
.appendIfNotNull ("is-a", m_sIsA)
.appendIfNotNull ("rich", m_aRich)
.appendIf ("includes", m_aIncludes, CollectionHelper::isNotEmpty)
.appendIfNotNull ("title", m_aTitle)
.appendIf ("content", m_aContent, CollectionHelper::isNotEmpty)
.appendIf ("foreignAttrs", m_aForeignAttrs, CollectionHelper::isNotEmpty)
.appendIf ("foreignElements", m_aForeignElements, CollectionHelper::isNotEmpty)
.getToString ();
}
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy