[Mulgara-svn] r820 - branches/mgr-61-sparql/src/jar/sparql-interpreter/java/org/mulgara/sparql
pag at mulgara.org
pag at mulgara.org
Wed Apr 23 06:38:30 UTC 2008
Author: pag
Date: 2008-04-22 23:38:29 -0700 (Tue, 22 Apr 2008)
New Revision: 820
Modified:
branches/mgr-61-sparql/src/jar/sparql-interpreter/java/org/mulgara/sparql/PatternMapper.java
Log:
Mappings are now all static, and are initialized statically. The outer class is now passed around explicitly to provide context when needed.
Modified: branches/mgr-61-sparql/src/jar/sparql-interpreter/java/org/mulgara/sparql/PatternMapper.java
===================================================================
--- branches/mgr-61-sparql/src/jar/sparql-interpreter/java/org/mulgara/sparql/PatternMapper.java 2008-04-23 06:36:34 UTC (rev 819)
+++ branches/mgr-61-sparql/src/jar/sparql-interpreter/java/org/mulgara/sparql/PatternMapper.java 2008-04-23 06:38:29 UTC (rev 820)
@@ -35,11 +35,13 @@
import org.mulgara.sparql.parser.cst.RDFLiteral;
import org.mulgara.sparql.parser.cst.Triple;
import org.mulgara.sparql.parser.cst.TripleList;
+import org.mulgara.parser.MulgaraParserException;
import org.mulgara.query.ConstraintConjunction;
import org.mulgara.query.ConstraintDisjunction;
import org.mulgara.query.ConstraintElement;
import org.mulgara.query.ConstraintExpression;
import org.mulgara.query.ConstraintFalse;
+import org.mulgara.query.ConstraintFilter;
import org.mulgara.query.ConstraintImpl;
import org.mulgara.query.ConstraintIn;
import org.mulgara.query.ConstraintOptionalJoin;
@@ -73,7 +75,6 @@
*/
PatternMapper(GroupGraphPattern pattern) {
startPattern = pattern;
- initMapping();
}
/**
@@ -88,8 +89,8 @@
* Perform the mapping of the graph pattern and return the results as a {@link ConstraintExpression}.
* @return The mapped constraint expression.
*/
- ConstraintExpression mapToConstraints() {
- return map(startPattern);
+ ConstraintExpression mapToConstraints() throws MulgaraParserException {
+ return mapPattern(startPattern);
}
/**
@@ -97,10 +98,10 @@
* @param pattern The pattern to convert.
* @return The new ConstraintExpression which matches the pattern.
*/
- private ConstraintExpression map(GroupGraphPattern pattern) {
+ private ConstraintExpression mapPattern(GroupGraphPattern pattern) throws MulgaraParserException {
PatternToConstraintMapper<? extends GroupGraphPattern> cons = constructors.get(pattern.getClass());
if (cons == null) throw new UnsupportedOperationException("Unknown SPARQL pattern: " + pattern.getClass().getSimpleName());
- ConstraintExpression result = cons.map(pattern);
+ ConstraintExpression result = cons.map(pattern, this);
result = applyFilter(result, pattern.getFilter());
result = applyGraph(result, pattern.getGraph());
return result;
@@ -112,10 +113,10 @@
* @param filter The filter to be wrapped around this constraint.
* @return The filtered version of the constraint.
*/
- private ConstraintExpression applyFilter(ConstraintExpression constraint, Expression filter) {
+ private ConstraintExpression applyFilter(ConstraintExpression constraint, Expression filter) throws MulgaraParserException {
if (filter == null) return constraint;
- // TODO create a filter builder and wrap the constraint witha FilteredConstraint
- return constraint;
+ FilterMapper filterMapper = new FilterMapper(filter);
+ return new ConstraintFilter(constraint, filterMapper.getFilter());
}
/**
@@ -149,7 +150,7 @@
* @param n The {@link Node} to convert to a ConstraintElement.
* @return A new constraint element that matches the node n.
*/
- private ConstraintElement convertElement(Node n) {
+ private static ConstraintElement convertElement(Node n) {
if (n instanceof org.mulgara.sparql.parser.cst.Variable) {
return new Variable(((org.mulgara.sparql.parser.cst.Variable)n).getName());
}
@@ -175,7 +176,7 @@
* @param t The triple to convert.
* @return The new constraint.
*/
- private ConstraintImpl newConstraintImpl(Triple t) {
+ private static ConstraintImpl newConstraintImpl(Triple t) {
ConstraintElement s = convertElement(t.getSubject());
ConstraintElement p = convertElement(t.getPredicate());
ConstraintElement o = convertElement(t.getObject());
@@ -183,7 +184,7 @@
}
/** A mapping of pattern types to constructors for the objects they map to. */
- private Map<Class<? extends GroupGraphPattern>,PatternToConstraintMapper<? extends GroupGraphPattern>> constructors = new HashMap<Class<? extends GroupGraphPattern>,PatternToConstraintMapper<? extends GroupGraphPattern>>();
+ private static Map<Class<? extends GroupGraphPattern>,PatternToConstraintMapper<? extends GroupGraphPattern>> constructors = new HashMap<Class<? extends GroupGraphPattern>,PatternToConstraintMapper<? extends GroupGraphPattern>>();
/**
* The class for the mapping of {@link GroupGraphPattern}s to {@link ConstraintExpression}s.
@@ -193,15 +194,16 @@
* to accept the general GroupGraphPattern and do the cast. This was not possible outside
* of the context of the generic type T.
*/
- private abstract class PatternToConstraintMapper<T extends GroupGraphPattern> {
+ private static abstract class PatternToConstraintMapper<T extends GroupGraphPattern> {
+ /** An entry point for the map operation. This method handles casting to be compatible with the generic template. */
@SuppressWarnings("unchecked")
- public ConstraintExpression map(GroupGraphPattern pattern) { return typedMap((T)pattern); }
+ public ConstraintExpression map(GroupGraphPattern pattern, PatternMapper mapper) throws MulgaraParserException { return typedMap((T)pattern, mapper); }
/**
* Convert a GroupGraphPattern to a ConstraintExpression for Mulgara.
* @param pattern The pattern to convert. Should be specific to the mapper.
* @return The constraint expression relevant to the mapper.
*/
- abstract ConstraintExpression typedMap(T pattern);
+ abstract ConstraintExpression typedMap(T pattern, PatternMapper mapper) throws MulgaraParserException;
/** Identify the class to be mapped by the extension. */
public abstract Class<T> getMapType();
}
@@ -210,7 +212,7 @@
* Utility method to add a pattern mapper to the map, keyed on the class it maps.
* @param mapper The mapper to add to the map.
*/
- void addToMap(PatternToConstraintMapper<? extends GroupGraphPattern> mapper) {
+ static void addToMap(PatternToConstraintMapper<? extends GroupGraphPattern> mapper) {
constructors.put(mapper.getMapType(), mapper);
}
@@ -219,7 +221,7 @@
* This is not static in order to avoid passing "this" through to the methods
* on each of the implementing mapper classes.
*/
- private void initMapping() {
+ static {
addToMap(new EmptyGraphPatternToConstraint());
addToMap(new GraphPatternConjunctionToConstraint());
addToMap(new GraphPatternDisjunctionToConstraint());
@@ -229,56 +231,56 @@
}
/** Map the empty graph pattern to a constraint that always resolves to nothing. */
- private class EmptyGraphPatternToConstraint extends PatternToConstraintMapper<EmptyGraphPattern> {
+ private static class EmptyGraphPatternToConstraint extends PatternToConstraintMapper<EmptyGraphPattern> {
public Class<EmptyGraphPattern> getMapType() { return EmptyGraphPattern.class; }
- ConstraintExpression typedMap(EmptyGraphPattern pattern) {
+ ConstraintExpression typedMap(EmptyGraphPattern pattern, PatternMapper mapper) {
return ConstraintFalse.INSTANCE;
}
}
/** Map the conjunctions to ConstraintConjunction. */
- private class GraphPatternConjunctionToConstraint extends PatternToConstraintMapper<GraphPatternConjunction> {
+ private static class GraphPatternConjunctionToConstraint extends PatternToConstraintMapper<GraphPatternConjunction> {
public Class<GraphPatternConjunction> getMapType() { return GraphPatternConjunction.class; }
- ConstraintExpression typedMap(GraphPatternConjunction pattern) {
+ ConstraintExpression typedMap(GraphPatternConjunction pattern, PatternMapper mapper) throws MulgaraParserException {
List<GroupGraphPattern> list = pattern.getElements();
List<ConstraintExpression> newList = new ArrayList<ConstraintExpression>(list.size());
- for (GroupGraphPattern p: list) newList.add(map(p));
+ for (GroupGraphPattern p: list) newList.add(mapper.mapPattern(p));
return new ConstraintConjunction(newList);
}
}
/** Map the disjunctions to ConstraintConjunction. */
- private class GraphPatternDisjunctionToConstraint extends PatternToConstraintMapper<GraphPatternDisjunction> {
+ private static class GraphPatternDisjunctionToConstraint extends PatternToConstraintMapper<GraphPatternDisjunction> {
public Class<GraphPatternDisjunction> getMapType() { return GraphPatternDisjunction.class; }
- ConstraintExpression typedMap(GraphPatternDisjunction pattern) {
+ ConstraintExpression typedMap(GraphPatternDisjunction pattern, PatternMapper mapper) throws MulgaraParserException {
List<GroupGraphPattern> list = pattern.getElements();
List<ConstraintExpression> newList = new ArrayList<ConstraintExpression>(list.size());
- for (GroupGraphPattern p: list) newList.add(map(p));
+ for (GroupGraphPattern p: list) newList.add(mapper.mapPattern(p));
return new ConstraintDisjunction(newList);
}
}
/** Map the optional patterns to ConstraintOptional. */
- private class GraphPatternOptionalToConstraint extends PatternToConstraintMapper<GraphPatternOptional> {
+ private static class GraphPatternOptionalToConstraint extends PatternToConstraintMapper<GraphPatternOptional> {
public Class<GraphPatternOptional> getMapType() { return GraphPatternOptional.class; }
- ConstraintExpression typedMap(GraphPatternOptional pattern) {
- return new ConstraintOptionalJoin(map(pattern.getMain()), map(pattern.getOptional()));
+ ConstraintExpression typedMap(GraphPatternOptional pattern, PatternMapper mapper) throws MulgaraParserException {
+ return new ConstraintOptionalJoin(mapper.mapPattern(pattern.getMain()), mapper.mapPattern(pattern.getOptional()));
}
}
/** Map the triple patterns to ConstraintImpl. */
- private class TripleToConstraint extends PatternToConstraintMapper<Triple> {
+ private static class TripleToConstraint extends PatternToConstraintMapper<Triple> {
public Class<Triple> getMapType() { return Triple.class; }
- ConstraintExpression typedMap(Triple pattern) {
+ ConstraintExpression typedMap(Triple pattern, PatternMapper mapper) {
return newConstraintImpl(pattern);
}
}
/** Map the lists of triple patterns to ConstraintConjunctions on ConstraintImpl. */
- private class TripleListToConstraint extends PatternToConstraintMapper<TripleList> {
+ private static class TripleListToConstraint extends PatternToConstraintMapper<TripleList> {
public Class<TripleList> getMapType() { return TripleList.class; }
@SuppressWarnings("unchecked")
- ConstraintExpression typedMap(TripleList pattern) {
+ ConstraintExpression typedMap(TripleList pattern, PatternMapper mapper) {
List<Triple> triples = (List<Triple>)pattern.getElements();
List<ConstraintExpression> constraints = new ArrayList<ConstraintExpression>(triples.size());
for (Triple t: triples) constraints.add(newConstraintImpl(t));
More information about the Mulgara-svn
mailing list