/*
* 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.rdf.rdfjson.parser;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.util.HashMap;
import java.util.Map;
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.clerezza.rdf.core.BNode;
import org.apache.clerezza.rdf.core.Language;
import org.apache.clerezza.rdf.core.MGraph;
import org.apache.clerezza.rdf.core.NonLiteral;
import org.apache.clerezza.rdf.core.UriRef;
import org.apache.clerezza.rdf.core.impl.PlainLiteralImpl;
import org.apache.clerezza.rdf.core.impl.TripleImpl;
import org.apache.clerezza.rdf.core.impl.TypedLiteralImpl;
import org.apache.clerezza.rdf.core.serializedform.ParsingProvider;
import org.apache.clerezza.rdf.core.serializedform.SupportedFormat;
import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Service;
/**
* A {@link org.apache.clerezza.rdf.core.serializedform.ParsingProvider} for rdf/json
*
* @author tio, hasan
*
*/
@Component(immediate=true)
@Service(ParsingProvider.class)
@SupportedFormat(SupportedFormat.RDF_JSON)
public class RdfJsonParsingProvider implements ParsingProvider {
private final Logger logger = LoggerFactory.getLogger(getClass());
@Override
public void parse(MGraph target, InputStream serializedGraph, String formatIdentifier, UriRef baseUri) {
BNodeManager bNodeMgr = new BNodeManager();
JSONParser parser = new JSONParser();
InputStreamReader reader;
try {
reader = new InputStreamReader(serializedGraph, "UTF-8");
} catch (UnsupportedEncodingException e) {
String msg = "Encoding 'UTF-8' is not supported by this System";
logger.error("{} (message: {})", msg, e.getMessage());
throw new IllegalStateException(msg, e);
}
try {
JSONObject root = (JSONObject) parser.parse(reader);
NonLiteral nonLiteral = null;
for (Object key : root.keySet()) {
String keyString = (String) key;
if (keyString.startsWith("_:")) {
nonLiteral = bNodeMgr.getBNode(keyString);
} else {
nonLiteral = new UriRef(keyString);
}
JSONObject predicates = (JSONObject) root.get(keyString);
addTriplesToGraph(nonLiteral, bNodeMgr, predicates, target);
}
} catch (IOException ioe) {
logger.error(ioe.getMessage());
throw new RuntimeException(ioe.getMessage());
} catch (ParseException pe) {
logger.error(pe.getMessage());
throw new RuntimeException(pe.getMessage());
}
}
private class BNodeManager {
private Map<String, BNode> bNodeMap = new HashMap<String, BNode>();
public BNode getBNode(String id) {
BNode bNode = bNodeMap.get(id);
if (bNode == null) {
bNode = new BNode();
bNodeMap.put(id, bNode);
}
return bNode;
}
}
private void addTriplesToGraph(NonLiteral subject, BNodeManager bNodeMgr, JSONObject predicates, MGraph mGraph) {
for (Object predicate : predicates.keySet()) {
JSONArray objects = (JSONArray) predicates.get(predicate);
for (Object object : objects) {
JSONObject values = (JSONObject) object;
String value = (String) values.get("value");
if (values.get("type").equals("literal")) {
Object dataType = values.get("datatype");
if (dataType != null &&
!dataType.toString().isEmpty()) {
mGraph.add(new TripleImpl(subject, new UriRef((String) predicate),
//LiteralFactory.getInstance().createTypedLiteral(value)));
new TypedLiteralImpl(value.toString(),new UriRef(dataType.toString()))));
} else if (values.containsKey("lang")
&& !values.get("lang").equals("")
&& values.get("lang") != null) {
mGraph.add(new TripleImpl(subject, new UriRef((String) predicate),
new PlainLiteralImpl(value, new Language((String) values.get("lang")))));
} else {
mGraph.add(new TripleImpl(subject, new UriRef((String) predicate), new PlainLiteralImpl(value)));
}
} else if (values.get("type").equals("uri")) {
mGraph.add(new TripleImpl(subject, new UriRef((String) predicate), new UriRef(value)));
} else if (values.get("type").equals("bnode")) {
NonLiteral bNode = bNodeMgr.getBNode(value);
mGraph.add(new TripleImpl(subject, new UriRef((String) predicate), bNode));
}
}
}
}
}