/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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 org.apache.clerezza.platform.typerendering.seedsnipe;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import org.apache.clerezza.platform.typerendering.CallbackRenderer;
import org.apache.clerezza.rdf.core.BNode;
import org.apache.clerezza.rdf.core.Language;
import org.apache.clerezza.rdf.core.Literal;
import org.apache.clerezza.rdf.core.LiteralFactory;
import org.apache.clerezza.rdf.core.NonLiteral;
import org.apache.clerezza.rdf.core.PlainLiteral;
import org.apache.clerezza.rdf.core.TripleCollection;
import org.apache.clerezza.rdf.core.TypedLiteral;
import org.apache.clerezza.rdf.core.UriRef;
import org.apache.clerezza.rdf.utils.GraphNode;
import org.apache.clerezza.templating.RenderingFunction;
import org.apache.clerezza.templating.RenderingFunctions;
/**
*
* @author rbn, mkr, dsr
*/
class WebRenderingFunctions implements RenderingFunctions {
private static final UriRef XML_DATE_LITERAL = new UriRef(
"http://www.w3.org/2001/XMLSchema#dateTime");
private final static UriRef RDF_XML_LITERAL = new UriRef(
"http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral");
private TripleCollection graph;
private GraphNode context;
private CallbackRenderer callbackRenderer;
private String mode;
WebRenderingFunctions(TripleCollection graph,
GraphNode context,
CallbackRenderer callbackRenderer, String mode) {
this.graph = graph;
this.context = context;
this.callbackRenderer = callbackRenderer;
this.mode = mode;
}
@Override
public RenderingFunction<Object, String> getDefaultFunction() {
return new RenderingFunction<Object, String>() {
@Override
public String process(Object... values) {
Object value = values[0];
if (value instanceof String) {
return (String) value;
}
String stringValue;
if (value instanceof Literal) {
if (value instanceof TypedLiteral) {
TypedLiteral typedLiteral = (TypedLiteral) value;
if (typedLiteral.getDataType().equals(RDF_XML_LITERAL)) {
return typedLiteral.getLexicalForm();
}
}
stringValue = ((Literal) value).getLexicalForm();
} else {
if (value instanceof UriRef) {
stringValue = ((UriRef) value).getUnicodeString();
} else {
stringValue = value.toString();
}
}
return escape(stringValue);
}
};
}
private String escape(String s) {
StringWriter resultWriter = new StringWriter();
for (int i = 0; i < s.length(); i++) {
char ch = s.charAt(i);
switch (ch) {
case '<':
resultWriter.write("<");
break;
case '&':
resultWriter.write("&");
break;
default:
resultWriter.write(ch);
}
}
return resultWriter.toString();
}
@Override
public Map<String, RenderingFunction> getNamedFunctions() {
Map<String, RenderingFunction> result = new HashMap<String, RenderingFunction>();
result.put("render", new RenderFunction());
result.put("mode", new ModeFunction());
result.put("language", languageFunction);
result.put("datatype", datatypeFunction);
result.put("type", typeFunction);
result.put("toString", toStringFunction);
result.put("date", dateFunction);
result.put("substring", substringFunction);
result.put("lexicalForm", lexicalFormFunction);
result.put("contains", containsFunction);
return result;
}
/**
* A functions that takes a node and optionally a templating mode as
* arguments
*/
private class RenderFunction implements RenderingFunction<Object, String> {
@Override
public String process(Object... values) throws IOException {
NonLiteral resource = (NonLiteral) values[0];
GraphNode graphNode = new GraphNode(resource, graph);
String mode = null;
if (values.length > 1) {
mode = (String) values[1];
}
ByteArrayOutputStream out = new ByteArrayOutputStream();
callbackRenderer.render(graphNode, context, mode, out);
try {
return new String(out.toByteArray(), "utf-8");
} catch (UnsupportedEncodingException ex) {
throw new RuntimeException(ex);
}
}
}
/**
* A function that returns the current rendering mode
*/
private class ModeFunction implements RenderingFunction<Object, String> {
@Override
public String process(Object... values) {
return mode;
}
}
/**
* A function that returns the Language of a PlainLiteral or null if the
* Literal has no language or if the object is not a PlainLiteral
*/
private static RenderingFunction languageFunction = new RenderingFunction<Object, Language>() {
@Override
public Language process(Object... values) {
Object value = values[0];
if (value instanceof PlainLiteral) {
return ((PlainLiteral) value).getLanguage();
}
return null;
}
};
/**
* A function that returns the Datatype of a TypedLiteral or null if the
* Literal has no language or if the object is not a TypedLiteral
*/
private static RenderingFunction datatypeFunction = new RenderingFunction<Object, UriRef>() {
@Override
public UriRef process(Object... values) {
Object value = values[0];
if (value instanceof PlainLiteral) {
return ((TypedLiteral) value).getDataType();
}
return null;
}
};
/**
* A function that returns the value returned by the toString() method of an
* object
*/
private static RenderingFunction toStringFunction = new RenderingFunction<Object, String>() {
@Override
public String process(Object... values) {
Object value = values[0];
return value.toString();
}
};
/**
* A function that returns a String representing the type of the Object.
* Either oneof - plainLiteral - typedLiteral - uriRef - bNode
*
* or, for other types the SimpleName of the class.
*
*/
private static RenderingFunction typeFunction = new RenderingFunction<Object, String>() {
@Override
public String process(Object... values) {
Object value = values[0];
if (value instanceof PlainLiteral) {
return "plainLiteral";
}
if (value instanceof TypedLiteral) {
return "typedLiteral";
}
if (value instanceof UriRef) {
return "uriRef";
}
if (value instanceof BNode) {
return "bNode";
}
return value.getClass().getSimpleName();
}
};
/**
* A function that returns String representation of an XMLLiteral of type
* date or an empty String if value[0] is not an XML Literal of type date.
* Optionally it allows the date to be formated according to a format-String
* parameter which uses the Java SimpleFormat syntax.
*/
private static RenderingFunction dateFunction = new RenderingFunction<Object, String>() {
@Override
public String process(Object... values) {
TypedLiteral typedLiteral;
if (values[0] instanceof TypedLiteral && (typedLiteral = (TypedLiteral) values[0]).getDataType().equals(XML_DATE_LITERAL)) {
String dateString = typedLiteral.getLexicalForm();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(
values.length >= 2 ? (String) values[1] : "yyyy-MM-ddHH:mm:ss.SSSZ");
Date date = LiteralFactory.getInstance().createObject(Date.class, typedLiteral);
return simpleDateFormat.format(date);
} else {
return "";
}
}
};
/**
* A function that takes an object, a beginindex and an endindex as
* arguments. It returns the substring from beginindex to endindex
* of the string representation of the first argument.
*/
private static RenderingFunction substringFunction = new RenderingFunction<Object, String>() {
@Override
public String process(Object... values) {
String str = values[0].toString();
int begin = 0;
int end = str.length();
if (values.length >= 2) {
begin = Integer.parseInt(values[1].toString());
if (!(begin >= 0)) {
begin = 0;
}
if (!(begin <= end)) {
begin = str.length();
}
}
if (values.length >= 3) {
end = Integer.parseInt(values[2].toString());
if (!(end >= begin)) {
end = begin;
}
if (!(end <= str.length())) {
end = str.length();
}
}
return str.substring(begin, end);
}
};
/**
* A function that takes an object and a string. It returns a boolean
* value that indicates if the string representation of the object
* (first argument) contains the string (second argument).
*/
private static RenderingFunction containsFunction = new RenderingFunction<Object, Boolean>() {
@Override
public Boolean process(Object... values) {
String str = values[0].toString();
String str2 = (String)values[1];
return str.contains(str2);
}
};
/**
* A function that takes a Literal as argument and returns the lexical form.
*/
private static RenderingFunction lexicalFormFunction = new RenderingFunction<Object, String>() {
@Override
public String process(Object... values) {
return ((Literal) values[0]).getLexicalForm();
}
};
}