code to parse HTTP request parameters into triple pattern elements is now partially generic (API-independent) and has been moved to separate parser classes

Author: Olaf Hartig

src/org/linkeddatafragments/util/RDFTermParser.java

@@ -0,0 +1,75 @@
+package org.linkeddatafragments.util;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Parses strings (as obtained from HTTP request parameters) into RDF terms. 
+ *
+ * @param <TermType> type for representing RDF terms
+ *
+ * @author <a href="http://olafhartig.de">Olaf Hartig</a>
+ */
+abstract public class RDFTermParser<TermType>
+{
+    public static final Pattern STRINGPATTERN
+                  = Pattern.compile("^\"(.*)\"(?:@(.*)|\\^\\^<?([^<>]*)>?)?$");
+
+    public TermType parseIntoRDFNode( final String param )
+    {
+        if ( param == null || param.isEmpty() )
+            return handleUnparsableParameter( param );
+
+        // identify the kind of RDF term based on the first character
+        char firstChar = param.charAt(0);
+        switch ( firstChar )
+        {
+            // blank node
+            case '_':
+                return createBlankNode( param );
+
+            // angular brackets indicate a URI
+            case '<':
+                return createURI( param.substring(1, param.length()-1) );
+
+            // quotes indicate a string
+            case '"':
+                Matcher matcher = STRINGPATTERN.matcher( param );
+                if ( matcher.matches() ) {
+                    String label   = matcher.group(1);
+                    String langTag = matcher.group(2);
+                    String typeURI = matcher.group(3);
+
+                    if ( langTag != null )
+                        return createLanguageLiteral( label, langTag );
+
+                    else if ( typeURI != null )
+                        return createTypedLiteral( label, typeURI );
+
+                    else
+                        return createPlainLiteral( label );
+                }
+                else
+                    return handleUnparsableParameter( param );
+
+            // assume it is a URI without angular brackets
+            default:
+                return createURI( param );
+        }
+    }
+
+    abstract public TermType createBlankNode( final String label );
+
+    abstract public TermType createURI( final String uri );
+
+    abstract public TermType createTypedLiteral( final String label,
+                                                 final String typeURI );
+
+    abstract public TermType createLanguageLiteral( final String label,
+                                                    final String langTag );
+
+    abstract public TermType createPlainLiteral( final String label );
+
+    abstract public TermType handleUnparsableParameter( final String param );
+
+}

src/org/linkeddatafragments/util/TriplePatternElementParser.java

@@ -0,0 +1,54 @@
+package org.linkeddatafragments.util;
+
+import org.linkeddatafragments.fragments.tpf.TriplePatternElement;
+import org.linkeddatafragments.fragments.tpf.TriplePatternElementFactory;
+
+/**
+ * Parses strings (as obtained from HTTP request parameters) into
+ * {@link TriplePatternElement}s. 
+ *
+ * @param <TermType> type for representing RDF terms
+ * @param <VarType> type for representing specific variables
+ *
+ * @author <a href="http://olafhartig.de">Olaf Hartig</a>
+ * @author Ruben Verborgh
+ */
+abstract public class TriplePatternElementParser<TermType,VarType>
+    extends RDFTermParser<TermType>
+{
+    public final TriplePatternElementFactory<TermType,VarType> factory =
+            new TriplePatternElementFactory<TermType,VarType>();
+
+    public TriplePatternElement<TermType,VarType>
+                            parseIntoTriplePatternElement( final String param )
+    {
+        // nothing or empty indicates an unspecified variable
+        if ( param == null || param.isEmpty() )
+            return factory.createUnspecifiedVariable();
+
+        // identify the kind of RDF term based on the first character
+        char firstChar = param.charAt(0);
+        switch ( firstChar )
+        {
+            // specific variable
+            case '?':
+            {
+                final String varName = param.substring(1);
+                final VarType var = createSpecificVariable( varName );
+                return factory.createSpecificVariable( var );
+            }
+
+            // blank node indicates an unspecified variable
+            case '_':
+            {
+                return factory.createUnspecifiedVariable();
+            }
+
+            // assume it is an RDF term
+            default:
+                return factory.createRDFTerm( parseIntoRDFNode(param) );
+        }
+    }
+
+    abstract public VarType createSpecificVariable( final String varName );
+}

src/org/linkeddatafragments/util/TriplePatternElementParserForJena.java

@@ -0,0 +1,73 @@
+package org.linkeddatafragments.util;
+
+import com.hp.hpl.jena.datatypes.RDFDatatype;
+import com.hp.hpl.jena.datatypes.TypeMapper;
+import com.hp.hpl.jena.rdf.model.RDFNode;
+import com.hp.hpl.jena.rdf.model.ResourceFactory;
+
+/**
+ * A {@link TriplePatternElementParser} for Jena-based backends.
+ *
+ * @author <a href="http://olafhartig.de">Olaf Hartig</a>
+ */
+public class TriplePatternElementParserForJena
+    extends TriplePatternElementParser<RDFNode,String>
+{
+    private static TriplePatternElementParserForJena instance = null;
+
+    public static TriplePatternElementParserForJena getInstance()
+    {
+        if ( instance == null ) {
+            instance = new TriplePatternElementParserForJena();
+        }
+        return instance;
+    }
+
+    protected TriplePatternElementParserForJena() {}
+
+    @Override
+    public String createSpecificVariable( final String varName )
+    {
+        return varName;
+    }
+
+    @Override
+    public RDFNode createBlankNode( final String label )
+    {
+        return ResourceFactory.createResource();
+    }
+
+    @Override
+    public RDFNode createURI( final String uri )
+    {
+        return ResourceFactory.createResource( uri );
+    }
+
+    @Override
+    public RDFNode createTypedLiteral( final String label,
+                                       final String typeURI )
+    {
+        final RDFDatatype dt = TypeMapper.getInstance()
+                                         .getSafeTypeByName( typeURI );
+        return ResourceFactory.createTypedLiteral( label, dt );
+    }
+
+    @Override
+    public RDFNode createLanguageLiteral( final String label,
+                                          final String languageTag )
+    {
+        return ResourceFactory.createLangLiteral( label, languageTag );
+    }
+
+    @Override
+    public RDFNode createPlainLiteral( final String label )
+    {
+        return ResourceFactory.createPlainLiteral( label );
+    }
+
+    @Override
+    public RDFNode handleUnparsableParameter( final String parameter )
+    {
+        return CommonResources.INVALID_URI;
+    }
+}