[Mulgara-svn] r1396 - in trunk/src/jar: resolver-lucene/java/org/mulgara/resolver/lucene resolver-relational/java/org/mulgara/resolver/relational resolver-spi/java/org/mulgara/resolver/spi resolver-xsd/java/org/mulgara/resolver/xsd
ronald at mulgara.org
ronald at mulgara.org
Wed Dec 3 09:26:05 UTC 2008
Author: ronald
Date: 2008-12-03 01:26:04 -0800 (Wed, 03 Dec 2008)
New Revision: 1396
Modified:
trunk/src/jar/resolver-lucene/java/org/mulgara/resolver/lucene/LuceneTransformer.java
trunk/src/jar/resolver-relational/java/org/mulgara/resolver/relational/RelationalConstraint.java
trunk/src/jar/resolver-relational/java/org/mulgara/resolver/relational/RelationalTransformer.java
trunk/src/jar/resolver-spi/java/org/mulgara/resolver/spi/AbstractSymbolicTransformer.java
trunk/src/jar/resolver-spi/java/org/mulgara/resolver/spi/ConjunctiveTransformer.java
trunk/src/jar/resolver-xsd/java/org/mulgara/resolver/xsd/IntervalTransformation.java
trunk/src/jar/resolver-xsd/java/org/mulgara/resolver/xsd/IntervalTransformationUnitTest.java
Log:
Refactored symbolic tranformers to extend new AbstractSymbolicTranformer in
order to handle things like the minus and optional-join constraints properly
and to reduce duplicated code.
Modified: trunk/src/jar/resolver-lucene/java/org/mulgara/resolver/lucene/LuceneTransformer.java
===================================================================
--- trunk/src/jar/resolver-lucene/java/org/mulgara/resolver/lucene/LuceneTransformer.java 2008-12-03 09:26:00 UTC (rev 1395)
+++ trunk/src/jar/resolver-lucene/java/org/mulgara/resolver/lucene/LuceneTransformer.java 2008-12-03 09:26:04 UTC (rev 1396)
@@ -28,15 +28,14 @@
import org.jrdf.graph.URIReference;
+import org.mulgara.query.Constraint;
import org.mulgara.query.ConstraintExpression;
import org.mulgara.query.ConstraintElement;
-import org.mulgara.query.ConstraintImpl;
import org.mulgara.query.ConstraintConjunction;
-import org.mulgara.query.ConstraintDisjunction;
+import org.mulgara.query.ConstraintOperation;
import org.mulgara.query.QueryException;
import org.mulgara.query.rdf.URIReferenceImpl;
-import org.mulgara.resolver.spi.MutableLocalQuery;
-import org.mulgara.resolver.spi.SymbolicTransformation;
+import org.mulgara.resolver.spi.AbstractSymbolicTransformer;
import org.mulgara.resolver.spi.SymbolicTransformationContext;
import org.mulgara.resolver.spi.SymbolicTransformationException;
@@ -53,7 +52,7 @@
* @author Ronald Tschalär
* @licence Apache License v2.0
*/
-public class LuceneTransformer implements SymbolicTransformation {
+public class LuceneTransformer extends AbstractSymbolicTransformer {
private static final Logger logger = Logger.getLogger(LuceneTransformer.class);
private final URI modelTypeURI;
@@ -73,36 +72,27 @@
scorePred = new URIReferenceImpl(scorePredUri);
}
- public void transform(SymbolicTransformationContext context, MutableLocalQuery query)
- throws SymbolicTransformationException {
- ConstraintExpression expr = query.getConstraintExpression();
- ConstraintExpression trans = transformExpr(context, expr);
-
- if (expr != trans) {
- query.setConstraintExpression(trans);
- }
- }
-
- private ConstraintExpression transformExpr(SymbolicTransformationContext context, ConstraintExpression expr) throws SymbolicTransformationException {
- if (expr instanceof ConstraintImpl) {
- return transformConstr(context, (ConstraintImpl)expr);
- }
- if (expr instanceof ConstraintConjunction) {
+ @Override
+ protected ConstraintExpression transformOperation(SymbolicTransformationContext context,
+ ConstraintOperation expr)
+ throws SymbolicTransformationException {
+ if (expr instanceof ConstraintConjunction)
return transformConj(context, (ConstraintConjunction)expr);
- }
- if (expr instanceof ConstraintDisjunction) {
- return transformDisj(context, (ConstraintDisjunction)expr);
- }
-
- return expr;
+ return super.transformOperation(context, expr);
}
- private ConstraintExpression transformConstr(SymbolicTransformationContext context, ConstraintImpl c) throws SymbolicTransformationException {
+ @Override
+ protected ConstraintExpression transformConstraint(SymbolicTransformationContext context,
+ Constraint c)
+ throws SymbolicTransformationException {
+ if (c instanceof LuceneConstraint) return c;
+
try {
ConstraintElement ce = c.getModel();
if (ce instanceof URIReference) {
URI constraintModelType = context.mapToModelTypeURI(((URIReference)ce).getURI());
if (constraintModelType != null && constraintModelType.equals(modelTypeURI)) {
+ if (logger.isTraceEnabled()) logger.trace("Creating LC for: " + c);
return new LuceneConstraint(c, searchPred, scorePred);
}
}
@@ -112,7 +102,7 @@
}
}
- public ConstraintExpression transformConj(SymbolicTransformationContext context, ConstraintConjunction cc) throws SymbolicTransformationException {
+ private ConstraintConjunction transformConj(SymbolicTransformationContext context, ConstraintConjunction cc) throws SymbolicTransformationException {
List<ConstraintExpression> retainedArgs = new ArrayList<ConstraintExpression>();
Map<ConstraintElement, List<LuceneConstraint>> luceneArgs =
new HashMap<ConstraintElement, List<LuceneConstraint>>();
@@ -120,7 +110,7 @@
boolean transformed = false;
for (ConstraintExpression arg : cc.getElements()) {
- ConstraintExpression trans = transformExpr(context, arg);
+ ConstraintExpression trans = transformExpression(context, arg);
if (trans != arg) {
transformed = true;
}
@@ -140,6 +130,7 @@
cumulative.add(lc);
} else {
cumulative.iterator().next().conjoinWith(lc);
+ if (logger.isTraceEnabled()) logger.trace("Updated LC with: " + cumulative.iterator().next() + "; result: " + lc);
transformed = true;
}
} else {
@@ -160,18 +151,4 @@
return cc;
}
}
-
- private ConstraintExpression transformDisj(SymbolicTransformationContext context, ConstraintDisjunction cd) throws SymbolicTransformationException {
- List<ConstraintExpression> transArgs = new ArrayList<ConstraintExpression>();
- boolean transformed = false;
- for (ConstraintExpression ce : cd.getElements()) {
- ConstraintExpression trans = transformExpr(context, ce);
- if (trans != ce) {
- transformed = true;
- }
- transArgs.add(trans);
- }
-
- return transformed ? new ConstraintDisjunction(transArgs) : cd;
- }
}
Modified: trunk/src/jar/resolver-relational/java/org/mulgara/resolver/relational/RelationalConstraint.java
===================================================================
--- trunk/src/jar/resolver-relational/java/org/mulgara/resolver/relational/RelationalConstraint.java 2008-12-03 09:26:00 UTC (rev 1395)
+++ trunk/src/jar/resolver-relational/java/org/mulgara/resolver/relational/RelationalConstraint.java 2008-12-03 09:26:04 UTC (rev 1396)
@@ -58,7 +58,6 @@
import org.mulgara.query.Constraint;
import org.mulgara.query.ConstraintElement;
import org.mulgara.query.ConstraintExpression;
-import org.mulgara.query.ConstraintImpl;
import org.mulgara.query.Value;
import org.mulgara.query.Variable;
import org.mulgara.query.rdf.URIReferenceImpl;
@@ -123,7 +122,7 @@
this.predConstraints = new HashMap<ConstraintElement,List<Constraint>>();
}
- public RelationalConstraint(ConstraintImpl constraint) {
+ public RelationalConstraint(Constraint constraint) {
this();
conjoinWith(constraint);
@@ -145,7 +144,7 @@
}
}
- public void conjoinWith(ConstraintImpl constraint) {
+ public void conjoinWith(Constraint constraint) {
preliminaries(constraint);
if (constraint.getElement(1).equals(rdftype)) {
Modified: trunk/src/jar/resolver-relational/java/org/mulgara/resolver/relational/RelationalTransformer.java
===================================================================
--- trunk/src/jar/resolver-relational/java/org/mulgara/resolver/relational/RelationalTransformer.java 2008-12-03 09:26:00 UTC (rev 1395)
+++ trunk/src/jar/resolver-relational/java/org/mulgara/resolver/relational/RelationalTransformer.java 2008-12-03 09:26:04 UTC (rev 1396)
@@ -52,18 +52,17 @@
import org.jrdf.graph.URIReference;
-import org.mulgara.query.ConstraintExpression;
-import org.mulgara.query.ConstraintElement;
-import org.mulgara.query.ConstraintImpl;
+import org.mulgara.query.Constraint;
import org.mulgara.query.ConstraintConjunction;
-import org.mulgara.query.ConstraintDisjunction;
+import org.mulgara.query.ConstraintElement;
+import org.mulgara.query.ConstraintExpression;
+import org.mulgara.query.ConstraintOperation;
import org.mulgara.query.QueryException;
-import org.mulgara.resolver.spi.MutableLocalQuery;
-import org.mulgara.resolver.spi.SymbolicTransformation;
+import org.mulgara.resolver.spi.AbstractSymbolicTransformer;
import org.mulgara.resolver.spi.SymbolicTransformationContext;
import org.mulgara.resolver.spi.SymbolicTransformationException;
-public class RelationalTransformer implements SymbolicTransformation {
+public class RelationalTransformer extends AbstractSymbolicTransformer {
/** Logger */
private static Logger logger = Logger.getLogger(RelationalTransformer.class);
@@ -73,32 +72,19 @@
this.modelTypeURI = modelTypeURI;
}
- public void transform(SymbolicTransformationContext context, MutableLocalQuery query)
- throws SymbolicTransformationException {
-
- ConstraintExpression expr = query.getConstraintExpression();
- ConstraintExpression trans = transformExpr(context, expr);
-
- if (expr != trans) {
- query.setConstraintExpression(trans);
- }
- }
-
- public ConstraintExpression transformExpr(SymbolicTransformationContext context, ConstraintExpression expr) throws SymbolicTransformationException {
- if (expr instanceof ConstraintImpl) {
- return transformMatch(context, (ConstraintImpl)expr);
- }
- if (expr instanceof ConstraintConjunction) {
+ @Override
+ protected ConstraintExpression transformOperation(SymbolicTransformationContext context,
+ ConstraintOperation expr)
+ throws SymbolicTransformationException {
+ if (expr instanceof ConstraintConjunction)
return transformConj(context, (ConstraintConjunction)expr);
- }
- if (expr instanceof ConstraintDisjunction) {
- return transformDisj(context, (ConstraintDisjunction)expr);
- }
-
- return expr;
+ return super.transformOperation(context, expr);
}
- public ConstraintExpression transformMatch(SymbolicTransformationContext context, ConstraintImpl c) throws SymbolicTransformationException {
+ @Override
+ protected ConstraintExpression transformConstraint(SymbolicTransformationContext context, Constraint c) throws SymbolicTransformationException {
+ if (c instanceof RelationalConstraint) return c;
+
try {
ConstraintElement ce = c.getModel();
if (ce instanceof URIReference) {
@@ -132,7 +118,7 @@
}
rcArgs.add(rc);
} else {
- ConstraintExpression trans = (ConstraintExpression)transformExpr(context, arg);
+ ConstraintExpression trans = transformExpression(context, arg);
retainedArgs.add(trans);
if (arg != trans) {
transformed = true;
@@ -164,20 +150,4 @@
return cc;
}
}
-
- public ConstraintExpression transformDisj(SymbolicTransformationContext context, ConstraintDisjunction cd) throws SymbolicTransformationException {
- List transArgs = new ArrayList();
- boolean transformed = false;
- Iterator i = cd.getElements().iterator();
- while (i.hasNext()) {
- ConstraintExpression ce = (ConstraintExpression)i.next();
- ConstraintExpression trans = transformExpr(context, ce);
- if (trans != ce) {
- transformed = true;
- }
- transArgs.add(trans);
- }
-
- return transformed ? new ConstraintDisjunction(transArgs) : cd;
- }
}
Modified: trunk/src/jar/resolver-spi/java/org/mulgara/resolver/spi/AbstractSymbolicTransformer.java
===================================================================
--- trunk/src/jar/resolver-spi/java/org/mulgara/resolver/spi/AbstractSymbolicTransformer.java 2008-12-03 09:26:00 UTC (rev 1395)
+++ trunk/src/jar/resolver-spi/java/org/mulgara/resolver/spi/AbstractSymbolicTransformer.java 2008-12-03 09:26:04 UTC (rev 1396)
@@ -45,7 +45,7 @@
if (logger.isTraceEnabled()) logger.trace("Transforming query: " + mutableLocalQuery.getConstraintExpression());
ConstraintExpression expr = mutableLocalQuery.getConstraintExpression();
- ConstraintExpression trans = transformExpr(context, expr);
+ ConstraintExpression trans = transformExpression(context, expr);
if (logger.isTraceEnabled()) logger.trace("Transform result: " + (expr != trans ? trans : "-no-change-"));
@@ -63,8 +63,8 @@
* @return a new expression is something was changed, or <var>expr</var> if nothing was changed.
* @throws SymbolicTransformationException If there is an error applying the transform
*/
- protected ConstraintExpression transformExpr(SymbolicTransformationContext context,
- ConstraintExpression expr)
+ public ConstraintExpression transformExpression(SymbolicTransformationContext context,
+ ConstraintExpression expr)
throws SymbolicTransformationException {
// explicitly handle all the recursive types
if (expr instanceof ConstraintFilter) return transformFilter(context, (ConstraintFilter)expr);
@@ -77,7 +77,7 @@
}
/**
- * Transform the filtered constraint. This invokes {@link #transformExpr} on the inner constraint.
+ * Transform the filtered constraint. This invokes {@link #transformExpression} on the inner constraint.
*
* @param context the current transformation context
* @param filter the constraint filter to transform
@@ -88,12 +88,12 @@
ConstraintFilter filter)
throws SymbolicTransformationException {
ConstraintExpression inner = filter.getUnfilteredConstraint();
- ConstraintExpression tx = transformExpr(context, inner);
+ ConstraintExpression tx = transformExpression(context, inner);
return (tx == inner) ? filter : new ConstraintFilter(tx, filter.getFilter());
}
/**
- * Transform the in constraint. This invokes {@link #transformExpr} on the inner constraint.
+ * Transform the in constraint. This invokes {@link #transformExpression} on the inner constraint.
*
* @param context the current transformation context
* @param in the in-constraint to transform
@@ -103,12 +103,12 @@
protected ConstraintExpression transformIn(SymbolicTransformationContext context, ConstraintIn in)
throws SymbolicTransformationException {
ConstraintExpression inner = in.getConstraintParam();
- ConstraintExpression tx = transformExpr(context, inner);
+ ConstraintExpression tx = transformExpression(context, inner);
return (tx == inner) ? in : new ConstraintIn(tx, in.getGraph());
}
/**
- * Transform the constraint-operation. This invokes {@link #transformExpr} on all the inner
+ * Transform the constraint-operation. This invokes {@link #transformExpression} on all the inner
* constraints.
*
* @param context the current transformation context
@@ -124,7 +124,7 @@
boolean changed = false;
for (ConstraintExpression op: ops) {
- ConstraintExpression tx = transformExpr(context, op);
+ ConstraintExpression tx = transformExpression(context, op);
newOps.add(tx);
if (tx != op) changed = true;
}
Modified: trunk/src/jar/resolver-spi/java/org/mulgara/resolver/spi/ConjunctiveTransformer.java
===================================================================
--- trunk/src/jar/resolver-spi/java/org/mulgara/resolver/spi/ConjunctiveTransformer.java 2008-12-03 09:26:00 UTC (rev 1395)
+++ trunk/src/jar/resolver-spi/java/org/mulgara/resolver/spi/ConjunctiveTransformer.java 2008-12-03 09:26:04 UTC (rev 1396)
@@ -55,7 +55,6 @@
import org.jrdf.graph.URIReference;
-import org.mulgara.query.ConstraintImpl;
import org.mulgara.query.Constraint;
import org.mulgara.query.ConstraintElement;
import org.mulgara.query.Variable;
@@ -63,9 +62,6 @@
import org.mulgara.query.ConstraintConjunction;
import org.mulgara.query.ConstraintDisjunction;
import org.mulgara.query.QueryException;
-import org.mulgara.resolver.spi.SymbolicTransformation;
-import org.mulgara.resolver.spi.SymbolicTransformationContext;
-import org.mulgara.resolver.spi.SymbolicTransformationException;
/**
* A transformer that works on the basis of combining multiple conjoined constraints
@@ -77,8 +73,7 @@
* Australian Commonwealth Government, Department of Defence</a>
* @licence <a href="{@docRoot}/../../LICENCE">Mozilla Public License v1.1</a>
*/
-public abstract class ConjunctiveTransformer implements SymbolicTransformation
-{
+public abstract class ConjunctiveTransformer extends AbstractSymbolicTransformer {
/** Logger */
private static final Logger logger = Logger.getLogger(ConjunctiveTransformer.class.getName());
@@ -90,34 +85,17 @@
public abstract ConstraintExpression constructConstraintExpression(ConstraintElement model, Map byVarSubject, Map byConstSubject) throws SymbolicTransformationException;
- public void transform(SymbolicTransformationContext context, MutableLocalQuery query)
- throws SymbolicTransformationException {
- ConstraintExpression expr = query.getConstraintExpression();
- ConstraintExpression trans = transformExpr(context, expr);
-
- if (expr != trans) {
- query.setConstraintExpression(trans);
- }
- }
-
-
- public ConstraintExpression transformExpr(SymbolicTransformationContext context, ConstraintExpression expr) throws SymbolicTransformationException {
-
+ @Override
+ public ConstraintExpression transformExpression(SymbolicTransformationContext context, ConstraintExpression expr) throws SymbolicTransformationException {
// This is the main case.
if (expr instanceof ConstraintConjunction) {
return transformConj(context, (ConstraintConjunction)expr);
}
- // In the case of a Disjunction we need to attempt to transform it's arguments
- // should the query be in sum of product form.
- if (expr instanceof ConstraintDisjunction) {
- return transformDisj(context, (ConstraintDisjunction)expr);
- }
-
// A single constraint could still be transformed as a singleton conjunction.
// Therefore pack in conjunction, attempt transform, and check to see if it was.
- if (expr instanceof ConstraintImpl) {
+ if (expr instanceof Constraint) {
ConstraintConjunction conj = new ConstraintConjunction(Arrays.asList(new ConstraintExpression[] { expr }));
ConstraintConjunction trans = transformConj(context, conj);
if (conj == trans) {
@@ -127,11 +105,18 @@
}
}
- // By default we do not recognise the constraint type, so pass it unchanged.
- return expr;
+ // all else go through the default handling
+ return super.transformExpression(context, expr);
}
+ @Override
+ protected ConstraintExpression transformConstraint(SymbolicTransformationContext context,
+ Constraint c)
+ throws SymbolicTransformationException {
+ return c;
+ }
+
public ConstraintConjunction transformConj(SymbolicTransformationContext context, ConstraintConjunction cc) throws SymbolicTransformationException {
ConjAccumulator acc = transformConj(context, cc, new ConjAccumulator(context));
@@ -168,7 +153,7 @@
if (arg instanceof ConstraintConjunction) {
acc = transformConj(context, (ConstraintConjunction)arg, acc);
} else if (arg instanceof ConstraintDisjunction) {
- ConstraintExpression expr = transformDisj(context, (ConstraintDisjunction)arg);
+ ConstraintExpression expr = transformOperation(context, (ConstraintDisjunction)arg);
acc.accumulate(expr);
} else {
acc.accumulate(arg);
@@ -179,24 +164,6 @@
}
- public ConstraintExpression transformDisj(SymbolicTransformationContext context, ConstraintDisjunction cd) throws SymbolicTransformationException {
-
- List transArgs = new ArrayList();
- boolean transformed = false;
- Iterator i = cd.getElements().iterator();
- while (i.hasNext()) {
- ConstraintExpression ce = (ConstraintExpression)i.next();
- ConstraintExpression trans = transformExpr(context, ce);
- if (trans != ce) {
- transformed = true;
- }
- transArgs.add(trans);
- }
-
- return transformed ? new ConstraintDisjunction(transArgs) : cd;
- }
-
-
private class ConjAccumulator {
private SymbolicTransformationContext context;
@@ -214,8 +181,8 @@
public void accumulate(ConstraintExpression arg) throws SymbolicTransformationException {
- if (arg instanceof ConstraintImpl) {
- accumulateConstraint((ConstraintImpl)arg);
+ if (arg instanceof Constraint) {
+ accumulateConstraint((Constraint)arg);
} else if (arg instanceof ConstraintConjunction) {
throw new IllegalStateException("ConstraintConjunction should have been handled by caller");
} else {
@@ -223,7 +190,7 @@
}
}
- private void accumulateConstraint(ConstraintImpl arg) throws SymbolicTransformationException {
+ private void accumulateConstraint(Constraint arg) throws SymbolicTransformationException {
try {
ConstraintElement model = arg.getModel();
if (model instanceof URIReference) {
@@ -248,7 +215,7 @@
}
- private void insertByModel(ConstraintElement model, Map target, ConstraintImpl arg) {
+ private void insertByModel(ConstraintElement model, Map target, Constraint arg) {
Map bySubject = (Map)target.get(model);
if (bySubject == null) {
bySubject = new HashMap();
Modified: trunk/src/jar/resolver-xsd/java/org/mulgara/resolver/xsd/IntervalTransformation.java
===================================================================
--- trunk/src/jar/resolver-xsd/java/org/mulgara/resolver/xsd/IntervalTransformation.java 2008-12-03 09:26:00 UTC (rev 1395)
+++ trunk/src/jar/resolver-xsd/java/org/mulgara/resolver/xsd/IntervalTransformation.java 2008-12-03 09:26:04 UTC (rev 1396)
@@ -51,7 +51,7 @@
import org.mulgara.query.*;
import org.mulgara.query.rdf.URIReferenceImpl;
import org.mulgara.resolver.spi.MutableLocalQuery;
-import org.mulgara.resolver.spi.SymbolicTransformation;
+import org.mulgara.resolver.spi.AbstractSymbolicTransformer;
import org.mulgara.resolver.spi.SymbolicTransformationContext;
import org.mulgara.resolver.spi.SymbolicTransformationException;
import org.mulgara.store.stringpool.StringPoolException;
@@ -69,7 +69,7 @@
* Australian Commonwealth Government, Department of Defence</a>
* @licence <a href="{@docRoot}/../../LICENCE">Mozilla Public License v1.1</a>
*/
-class IntervalTransformation implements SymbolicTransformation {
+class IntervalTransformation extends AbstractSymbolicTransformer {
/** Logger. */
private static final Logger logger = Logger.getLogger(IntervalTransformation.class);
@@ -110,55 +110,15 @@
this.lessThan = lessThan;
}
- //
- // Methods implementing Symbolic Transformation
- //
-
- public void transform(SymbolicTransformationContext context, MutableLocalQuery mutableLocalQuery)
+ @Override
+ protected ConstraintExpression transformOperation(SymbolicTransformationContext context,
+ ConstraintOperation expr)
throws SymbolicTransformationException {
- ConstraintExpression constraintExpression =
- transformExpression(context, mutableLocalQuery.getConstraintExpression());
-
- if (constraintExpression != null) {
- mutableLocalQuery.setConstraintExpression(constraintExpression);
- }
+ if (expr instanceof ConstraintConjunction)
+ return transformConjunction(context, (ConstraintConjunction)expr);
+ return super.transformOperation(context, expr);
}
- //
- // Internal methods
- //
-
- /**
- * @param constraintExpression the <code>WHERE</code> clause to transform,
- * never <code>null</code>
- * @return the transformed version of the <var>constraintExpression</var>, or
- * <code>null</code> to indicate no transformation
- * @throws IllegalArgumentException if <var>constraintExpression</var> is
- * <code>null</code>
- * @throws SymbolicTransformationException if the transformation can't be
- * returned
- */
- ConstraintExpression transformExpression(SymbolicTransformationContext context, ConstraintExpression constraintExpression)
- throws SymbolicTransformationException {
- // Validate "constraintExpression" parameter
- if (constraintExpression == null) {
- throw new IllegalArgumentException("Null \"constraintExpression\" parameter"
- );
- }
-
- if (logger.isDebugEnabled()) {
- logger.debug("Transforming ConstraintExpression: " + constraintExpression);
- }
-
- if (constraintExpression instanceof ConstraintConjunction) {
- return transformConjunction(context, (ConstraintConjunction) constraintExpression);
- } else if (constraintExpression instanceof ConstraintImpl) {
- return transformConstraint(context, (ConstraintImpl) constraintExpression);
- } else {
- return null; // don't modify constraints we don't understand
- }
- }
-
private ConstraintExpression transformConjunction(SymbolicTransformationContext context, ConstraintConjunction constraintConjunction)
throws SymbolicTransformationException {
if (logger.isDebugEnabled()) {
@@ -180,7 +140,7 @@
// Recursively transform the element
ConstraintExpression transformedElement = transformExpression(context, element);
- if (transformedElement != null) {
+ if (transformedElement != element) {
if (logger.isDebugEnabled()) {
logger.debug("Recursively transformed " + element +
" to " + transformedElement);
@@ -224,7 +184,7 @@
logger.debug("Conjunction not modified");
}
- return null;
+ return constraintConjunction;
} else {
newElements.addAll(map.values());
@@ -245,31 +205,34 @@
}
}
- private ConstraintExpression transformConstraint(SymbolicTransformationContext context, ConstraintImpl constraintImpl)
+ @Override
+ protected ConstraintExpression transformConstraint(SymbolicTransformationContext context,
+ Constraint constraint)
throws SymbolicTransformationException {
- assert constraintImpl != null;
+ assert constraint != null;
+ if (constraint instanceof IntervalConstraint) return constraint;
Variable variable;
boolean boundedBelow;
Bound bound;
if (logger.isDebugEnabled()) {
- logger.debug("Transforming ConstraintImpl: " + constraintImpl);
+ logger.debug("Transforming Constraint: " + constraint);
}
// Confirm model is of type XSDModel.
try {
- ConstraintElement modelElement = constraintImpl.getModel();
+ ConstraintElement modelElement = constraint.getModel();
if (!(modelElement instanceof URIReference)) {
- logger.debug("model not URIReference; cannot participate in transform returning null");
- return null;
+ logger.debug("model not URIReference; cannot participate in transform, returning original");
+ return constraint;
}
URI modelURI = ((URIReference)modelElement).getURI();
URI modelTypeURI = context.mapToModelTypeURI(modelURI);
if (!this.modelTypeURI.equals(modelTypeURI)) {
- logger.debug("model: " + modelURI + " is of type " + modelTypeURI + " not " + this.modelTypeURI + " ignoring constraint, returning null");
+ logger.debug("model: " + modelURI + " is of type " + modelTypeURI + " not " + this.modelTypeURI + " ignoring constraint, returning original");
- return null;
+ return constraint;
}
} catch (QueryException eq) {
throw new SymbolicTransformationException("Unable to check model on constraint", eq);
@@ -278,36 +241,36 @@
logger.debug("Model suitable for IntervalTransformation");
// Figure out the direction of bounding, assuming [$var op value] order
- if (constraintImpl.getElement(1).equals(lessThan)) {
+ if (constraint.getElement(1).equals(lessThan)) {
boundedBelow = false;
- } else if (constraintImpl.getElement(1).equals(greaterThan)) {
+ } else if (constraint.getElement(1).equals(greaterThan)) {
boundedBelow = true;
} else {
logger.debug("Predicate not recognised by IntervalTransformation");
- return null;
+ return constraint;
}
// Determine whether we have a [$var op value] or [value op $var] form
- if (constraintImpl.getElement(0) instanceof Variable) {
- if (constraintImpl.getElement(2) instanceof Variable) {
- logger.debug("Both Subject and Object are Variables, returning null");
- return null;
+ if (constraint.getElement(0) instanceof Variable) {
+ if (constraint.getElement(2) instanceof Variable) {
+ logger.debug("Both Subject and Object are Variables, returning original");
+ return constraint;
} else {
- variable = (Variable) constraintImpl.getElement(0);
+ variable = (Variable) constraint.getElement(0);
double value = Double.parseDouble(
- ((Literal) constraintImpl.getElement(2)).getLexicalForm()
+ ((Literal) constraint.getElement(2)).getLexicalForm()
);
bound = new Bound(value, false);
}
} else {
- if (constraintImpl.getElement(2) instanceof Variable) {
- logger.debug("Object is a variable returning null?");
+ if (constraint.getElement(2) instanceof Variable) {
+ logger.debug("Object is a variable, returning original");
// Is this right, surely the above should be not-instanceof !?
- return null;
+ return constraint;
} else {
- variable = (Variable) constraintImpl.getElement(2);
+ variable = (Variable) constraint.getElement(2);
double value = Double.parseDouble(
- ((Literal) constraintImpl.getElement(0)).getLexicalForm()
+ ((Literal) constraint.getElement(0)).getLexicalForm()
);
bound = new Bound(value, false);
boundedBelow = !boundedBelow; // reverse the comparison
@@ -319,7 +282,7 @@
variable,
boundedBelow ? bound : null,
boundedBelow ? null : bound,
- (URIReference)constraintImpl.getModel()
+ (URIReference)constraint.getModel()
);
}
}
Modified: trunk/src/jar/resolver-xsd/java/org/mulgara/resolver/xsd/IntervalTransformationUnitTest.java
===================================================================
--- trunk/src/jar/resolver-xsd/java/org/mulgara/resolver/xsd/IntervalTransformationUnitTest.java 2008-12-03 09:26:00 UTC (rev 1395)
+++ trunk/src/jar/resolver-xsd/java/org/mulgara/resolver/xsd/IntervalTransformationUnitTest.java 2008-12-03 09:26:04 UTC (rev 1396)
@@ -182,8 +182,7 @@
*/
public void test1Transform() throws Exception {
try {
- intervalTransformation.transformExpression(context, (ConstraintExpression) null);
- fail("Expected an IllegalArgumentException");
+ assertNull(intervalTransformation.transformExpression(context, (ConstraintExpression) null));
}
catch (IllegalArgumentException e) {
// expected
@@ -194,7 +193,7 @@
* Test #2 for the {@link IntervalTransformation#transform} method.
*/
public void test2Transform() throws Exception {
- assertNull(intervalTransformation.transformExpression(context, ConstraintTrue.INSTANCE));
+ assertSame(ConstraintTrue.INSTANCE, intervalTransformation.transformExpression(context, ConstraintTrue.INSTANCE));
}
/**
@@ -270,13 +269,11 @@
Variable x = new Variable("x");
Variable y = new Variable("y");
- assertEquals(
- intervalTransformation.transformExpression(context, new ConstraintConjunction(
+ ConstraintConjunction cc = new ConstraintConjunction(
new ConstraintImpl(x, greaterThan, new LiteralImpl(2), nonXSDModel),
new ConstraintImpl(y, lessThan, new LiteralImpl(3), nonXSDModel)
- )
- ),
- null);
+ );
+ assertSame(cc, intervalTransformation.transformExpression(context, cc));
}
/**
More information about the Mulgara-svn
mailing list