+ * 謖�ｮ壹＆繧後◆graphURIs縺ｮ荳ｭ縺九ｉ縲√く繝ｼ繝ｯ繝ｼ繝峨↓繝偵ャ繝医☆繧九Λ繝吶Ν繧呈戟縺､繧ｯ繝ｩ繧ｹ��dfs:Class�峨ｒ縺吶∋縺ｦ霑斐☆ + * + *
+ * 謖�ｮ壹＆繧後◆graphURIs縺ｮ荳ｭ縺九ｉ縲√く繝ｼ繝ｯ繝ｼ繝峨↓繝偵ャ繝医☆繧九Λ繝吶Ν繧呈戟縺､繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧偵☆縺ｹ縺ｦ霑斐☆ + * + * 縺薙％縺ｧ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ縺ｯ縲〉df:type縺ｮ荳ｻ隱槭→縺励※險倩ｿｰ縺輔ｌ縺ｦ縺�ｋ繧ゅ�繧偵＞縺� + * + *
+ * 蜃ｦ逅�ｯｾ雎｡繝��繧ｿ繧暖raphURIs縺ｧ謖�ｮ壹☆繧九％縺ｨ縺後〒縺阪ｋ + * + * + *
+ * 縺薙％縺ｧ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ縺ｯ縲〉df:type縺ｮ荳ｻ隱槭→縺励※險倩ｿｰ縺輔ｌ縺ｦ縺�ｋ繧ゅ�繧偵＞縺� + * + * 蜃ｦ逅�ｯｾ雎｡繝��繧ｿ繧暖raphURIs縺ｧ謖�ｮ壹☆繧九％縺ｨ縺後〒縺阪ｋ + * + *
+ * 蜷代″縺ｮ隗｣驥医�縺薙�縲Direction 縺御ｽｿ逕ｨ縺輔ｌ繧狗憾豕√↓蠢懊§縺ｦ螳壹∪繧� + * + * @author Norio KOBAYASHI + * @since 28.01.2014 + * @version 29.01.2014 + */ +public enum Direction { + /** + * 鬆�婿蜷� + */ + forward, + + /** + * 騾�婿蜷� + */ + reverse, + + /** + * 荳｡譁ｹ蜷� + */ + both; +} Index: SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/OWL/StructureCrawler.java =================================================================== --- SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/OWL/StructureCrawler.java (revision 267) +++ SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/OWL/StructureCrawler.java (revision 267) @@ -0,0 +1,117 @@ +package org.biohackathon.SPARQLBuilder.OWL; + +import java.io.File; +import java.util.HashMap; +import java.util.Map; +import java.util.Set; + +import jp.riken.accc.db.rdf.crawler.dataStructure.SchemaCategory; +import jp.riken.accc.db.rdf.crawler.dataStructure.sparql.JenaModelGenerator; +import jp.riken.accc.db.rdf.crawler.dataStructure.sparql.RDFsCrawlerImpl; + +public class StructureCrawler { + + private File dataDir = null; + + // this is just for a test + /* + public static void main(String[] args) throws Exception{ + StructureCrawler sc = new StructureCrawler(new File("c:\\cdata")); +// sc.crawl("http://dbe-rdf.biosciencedbc.jp/sparql", "biosciencedbc.ttl"); + +// System.out.println("done"); + + + Map acTable = sc.getAcquiredStructureFiles(); + Set keySet = acTable.keySet(); + for(String key: keySet){ + String val = acTable.get(key); + System.out.println("File: " + key + " --- " + val); + } + } + */ + + + public Map getAcquiredStructureFiles(){ + Map table = new HashMap(); + if( dataDir.isDirectory() ){ + // read files + File[] files = dataDir.listFiles(); + for(File file: files){ + String uri = null; + try{ + JenaModelGenerator jmGene = new JenaModelGenerator(file.getAbsolutePath()); + uri = jmGene.getEndpointURI(); +System.out.println("URI: "+ uri); + }catch(Exception ex){ + // + } + if( uri != null ){ + table.put(uri, file.getAbsolutePath()); + } + } + }else{ + if( dataDir.isFile() ){ + String uri = null; + try{ + JenaModelGenerator jmGene = new JenaModelGenerator(dataDir.getAbsolutePath()); + uri = jmGene.getEndpointURI(); + + }catch(Exception ex){ + // + } + if( uri != null ){ + table.put(uri, dataDir.getAbsolutePath()); + } + } + } + return table; + } + + + + public StructureCrawler(File dataDir) throws Exception { + this.dataDir = dataDir; + } + + public void crawl(String endPURI, String outFileName) throws Exception { + RDFsCrawlerImpl impl = new RDFsCrawlerImpl(endPURI); + // Resource[] res = impl.getRDFProperties(); + // Resource[] res = impl.getInferedRDFsClassesFromInstances(); + // Resource[] res = impl.getDomainRangeDeclaredRDFProperties(); + // Resource[] res = impl.getDeclaredRDFsClasses(); + // for(Resource r: res){ + // System.out.println(r.getURI().toString()); + // } + // Model model = impl.getProperiesFromDomainRangeDecls(); + // Model model = impl.getPropertiesFromInstanceDecls(); + // RDFWriter writer = model.getWriter("N3"); + // writer.setProperty("showXMLDeclaration","true"); + // writer.write(model,System.out,""); + // model.close(); + + SchemaCategory sc = impl.determineSchemaCategory(); + + // RDF/XML, RDF/XML-ABBREV, N-TRIPLE, N3 + File outFile = null; + if (outFileName == null) { + String tFileName = null; + if (endPURI.lastIndexOf("/", endPURI.length() - 2) > 0) { + tFileName = endPURI.substring( + endPURI.lastIndexOf("/", endPURI.length() - 2) + 1, + endPURI.length()); + } else { + tFileName = endPURI; + } + outFile = new File(dataDir, tFileName); + if (outFile.exists()) { + outFile = File.createTempFile(tFileName, "", dataDir); + } + } else { + outFile = new File(dataDir, outFileName); + } + sc.write2File(outFile.getAbsolutePath(), "Turtle"); + // System.out.println("Category:" + sc.getCategory()); + } + +} Index: SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/OWL/InstanceLink.java =================================================================== --- SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/OWL/InstanceLink.java (revision 267) +++ SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/OWL/InstanceLink.java (revision 267) @@ -0,0 +1,122 @@ +package org.biohackathon.SPARQLBuilder.OWL; + +import java.util.HashSet; + +/** + * 繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｸ縲√≠繧九＞縺ｯ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺九ｉ縺ｮ1繧ｹ繝�ャ繝励Μ繝ｳ繧ｯ繧定ｨ倩ｿｰ縺吶ｋ + * @author Norio KOBAYASHI + * @since 28.01.2014 + * @version 29.01.2014 + */ +public class InstanceLink { + + private String propertyURI = null; + private String[] linkedClassURIs = null; + private String linkedInstanceURI = null; + private Direction direction = null; + + + /** + * 繝励Ο繝代ユ繧｣URI縲√Μ繝ｳ繧ｯ蜈茨ｼ亥��峨う繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縲√Μ繝ｳ繧ｯ縺ｮ蜷代″繧剃ｸ弱∴繧区ｧ区�蟄� + * + * 繝ｪ繝ｳ繧ｯ蜈�(蜈� 繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｫ縺､縺�※縺ｯ縲√◎繧後′螻槭＠縺ｦ縺�ｋ縺吶∋縺ｦ縺ｮ繧ｯ繝ｩ繧ｹ繧ゆｸ弱∴繧� + * + * @param propertyURI縲繝励Ο繝代ユ繧｣縺ｮURI + * @param linkedInstanceURI縲繝ｪ繝ｳ繧ｯ縺ｮ荳ｻ隱槭√√≠繧九＞縺ｯ繝ｪ繝ｳ繧ｯ縺ｮ逶ｮ逧�ｪ槭→縺ｪ縺｣縺ｦ縺�ｋ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮURI + * @param linkedClassURIs縲linkedInstanceURI縺ｮ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺悟ｱ槭＠縺ｦ縺�ｋ縺吶∋縺ｦ縺ｮ繧ｯ繝ｩ繧ｹ縺ｮURI縺ｮ驟榊� + * @param direction 繝励Ο繝代ユ繧｣縺ｮ蜷代″縲〕inkedClassURI縺ｮ繧ｯ繝ｩ繧ｹ縺後Μ繝ｳ繧ｯ蜈医↓縺ｪ縺｣縺ｦ縺�ｋ縺ｨ縺阪�Direction.forward,繝ｪ繝ｳ繧ｯ蜈�↓縺ｪ縺｣縺ｦ縺�ｋ縺ｨ縺阪�Direction.reverse, 縺昴ｌ繧我ｸ｡譁ｹ縺ｮ譎ゅ�Direction.both繧呈欠螳壹☆繧� + * @throws Exception + * @since 28.01.2014 + */ + public InstanceLink(String propertyURI, String linkedInstanceURI, String[] linkedClassURIs, Direction direction){ + this.propertyURI = propertyURI; + this.linkedInstanceURI = linkedInstanceURI; + this.linkedClassURIs = linkedClassURIs; + this.direction = direction; + } + + + /** + * linkedInstanceURI縺ｮ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺悟ｱ槭＠縺ｦ縺�ｋ繧ｯ繝ｩ繧ｹ繧剃ｸ縺､霑ｽ蜉縺吶ｋ + * + * @param classURI縲霑ｽ蜉縺吶ｋlinkedInstanceURI縺ｮ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺悟ｱ槭＠縺ｦ縺�ｋ繧ｯ繝ｩ繧ｹ縺ｮURI + * @throws Exception + * @since 28.01.2014 + */ + public void addLinkedClassURI(String classURI){ + if( linkedClassURIs == null || linkedClassURIs.length == 0 ){ + linkedClassURIs = new String[]{classURI}; + }else{ + HashSet hSet = new HashSet(); + for(String clsURI: linkedClassURIs){ + hSet.add(clsURI); + } + hSet.add(classURI); + linkedClassURIs = hSet.toArray(new String[0]); + } + } + + /** + * 譁�ｭ怜�陦ｨ險倥ｒ蜿門ｾ励☆繧� + * + * @since 28.01.2014 + */ + public String toString(){ + StringBuffer sb = new StringBuffer(); + sb.append(propertyURI); + if( direction == Direction.forward ){ + sb.append(" --> "); + }else{ + if( direction == Direction.reverse ){ + sb.append(" <-- "); + }else{ + sb.append(" <-> "); + } + } + sb.append(linkedInstanceURI); + sb.append(" rdf:type ["); + if( linkedClassURIs != null ){ + for( int i = 0; i < linkedClassURIs.length; i++ ) { + if( i != 0 ) { + sb.append(", "); + } + sb.append(linkedClassURIs[i]); + } + } + sb.append("]"); + return sb.toString(); + } + + public String getPropertyURI() { + return propertyURI; + } + public void setPropertyURI(String propertyURI) { + this.propertyURI = propertyURI; + } + public String[] getLinkedClassURIs() { + return linkedClassURIs; + } + public void setLinkedClassURIs(String[] linkedClassURIs) { + this.linkedClassURIs = linkedClassURIs; + } + public Direction getDirection() { + return direction; + } + public void setDirection(Direction direction) { + this.direction = direction; + } + + public String getLinkedInstanceURI() { + return linkedInstanceURI; + } + + public void setLinkedInstanceURI(String linkedInstanceURI) { + this.linkedInstanceURI = linkedInstanceURI; + } + + // private String[] propertyDomainClassURIs = null; + // private String[] propertyRangeClassURIs = null; + + + +} Index: SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/OWL/ClassLink.java =================================================================== --- SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/OWL/ClassLink.java (revision 267) +++ SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/OWL/ClassLink.java (revision 267) @@ -0,0 +1,366 @@ +package org.biohackathon.SPARQLBuilder.OWL; + +import org.json.JSONException; +import org.json.JSONObject; + +/** + * 繧ｯ繝ｩ繧ｹ縺ｸ縲√≠繧九＞縺ｯ繧ｯ繝ｩ繧ｹ縺九ｉ縺ｮ1繧ｹ繝�ャ繝励Μ繝ｳ繧ｯ繧定ｨ倩ｿｰ縺吶ｋ + * @author Norio KOBAYASHI + * @since 28.01.2014 + * @version 29.01.2014 + */ +public class ClassLink { + + private String propertyURI = null; + private String linkedClassURI = null; + private String linkedLiteralDatatypeURI = null; + private Direction direction = null; + private int numOfLinks = 0; + private int numOfLinkedInstances = 0; + private int numOfOriginInstances = 0; + private int numOfOriginClassInstances = 0; + private int numOfLinkedClassInstances = 0; + private boolean domainClassLimitedQ = false; + private boolean rangeClassLimitedQ = false; + + + /** + * 繝励Ο繝代ユ繧｣URI縲√Μ繝ｳ繧ｯ蜈茨ｼ亥��峨け繝ｩ繧ｹ縲√Μ繝ｳ繧ｯ縺ｮ蜷代″繧剃ｸ弱∴繧区ｧ区�蟄� + * + * @param propertyURI縲繝励Ο繝代ユ繧｣縺ｮURI + * @param linkedClassURI縲繝ｪ繝ｳ繧ｯ縺ｮ荳ｻ隱槭√√≠繧九＞縺ｯ繝ｪ繝ｳ繧ｯ縺ｮ逶ｮ逧�ｪ槭→縺ｪ縺｣縺ｦ縺�ｋ繧ｯ繝ｩ繧ｹ縺ｮURI + * @param direction 繝励Ο繝代ユ繧｣縺ｮ蜷代″縲〕inkedClassURI縺ｮ繧ｯ繝ｩ繧ｹ縺後Μ繝ｳ繧ｯ蜈医↓縺ｪ縺｣縺ｦ縺�ｋ縺ｨ縺阪�Direction.forward,繝ｪ繝ｳ繧ｯ蜈�↓縺ｪ縺｣縺ｦ縺�ｋ縺ｨ縺阪�Direction.reverse, 縺昴ｌ繧我ｸ｡譁ｹ縺ｮ譎ゅ�Direction.both繧呈欠螳壹☆繧� + * @param numOfLinks 蠖楢ｩｲ繝励Ο繝代ユ繧｣縺ｧ荳｡遶ｯ繧ｯ繝ｩ繧ｹ縺ｮ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ蜷悟｣ｫ繧偵▽縺ｪ縺�〒縺�ｋ繝ｪ繝ｳ繧ｯ謨ｰ�医ヨ繝ｪ繝励Ν謨ｰ�� + * @throws Exception + * @since 28.01.2014 + */ + public ClassLink(String propertyURI, String linkedClassURI, String linkedLiteralDatatypeURI, Direction direction, + int numLinks, int numOfOriginInstances, int numOfLinkedInstances, + int numOfOriginClassInstances, int numofLinkedClassInstances, + boolean domainClassLimitedQ, boolean rangeClassLimitedQ){ + this.propertyURI = propertyURI; + this.linkedClassURI = linkedClassURI; + this.linkedLiteralDatatypeURI = linkedLiteralDatatypeURI; + this.direction = direction; + this.numOfLinks = numLinks; + this.numOfLinkedInstances = numOfLinkedInstances; + this.numOfOriginInstances = numOfOriginInstances; + this.numOfOriginClassInstances = numOfOriginClassInstances; + this.numOfLinkedClassInstances = numofLinkedClassInstances; + this.domainClassLimitedQ = domainClassLimitedQ; + this.rangeClassLimitedQ = rangeClassLimitedQ; + } + + + public JSONObject toJSON() throws JSONException{ + JSONObject obj = new JSONObject(); + if( propertyURI != null ) { + obj.put("propertyURI", propertyURI); + } + if( linkedClassURI != null ){ + obj.put("linkedClassURI", linkedClassURI); + } + if( linkedLiteralDatatypeURI != null ){ + obj.put("linkedLiteralDatatypeURI", linkedLiteralDatatypeURI); + } + if( direction != null ){ + obj.put("direction", direction); + } + //obj.put("numOfLinks", numOfLinks); + //obj.put("numOfLinkedInstances", numOfLinkedInstances); + //obj.put("numOfOriginInstances", numOfOriginInstances); + //obj.put("numOfOriginClassInstances", numOfOriginClassInstances); + //obj.put("numOfLinkedClassInstances", numOfLinkedClassInstances); + return obj; + } + // add direction and other variations + public String toJSONString2() { + String json_str ="{"; + + if( propertyURI != null ) { + json_str+="\"propertyURI\":"+"\""+propertyURI+"\","; + } + else{ + json_str+="\"propertyURI\":"+"\"propertyURI\","; + } + if( linkedClassURI != null ){ + json_str+="\"linkedClassURI\":"+"\""+linkedClassURI+"\","; + } + else{ + json_str+="\"linkedClassURI\":"+"\"linkedClassURI\","; + } + if( linkedLiteralDatatypeURI != null ){ + json_str+="\"linkedLiteralDatatypeURI\":"+"\""+linkedLiteralDatatypeURI+"\","; + } + else{ + json_str+="\"linkedLiteralDatatypeURI\":"+"\"linkedLiteralDatatypeURI\","; + } + if( direction != null ){ + json_str+="\"direction\":"+"\""+direction.toString()+"\""; + } + else{ + json_str+="\"direction\":"+"\"direction\""; + } + + // json_str+="\"numOfLinks\":"+"\""+numOfLinks+"\","; + // json_str+="\"numOfLinkedInstances\":"+"\""+numOfLinkedInstances+"\","; + // json_str+="\"numOfOriginInstances\":"+"\""+numOfOriginInstances+"\","; + // json_str+="\"numOfOriginClassInstances\":"+"\""+numOfOriginClassInstances+"\","; + // json_str+="\"numOfLinkedClassInstances\":"+"\""+numOfLinkedClassInstances+"\""; + + json_str+="}"; + + return json_str; + } + + public String toJSONString3(SClass[] classes) { + String json_str ="{"; + + if( propertyURI != null ) { + //json_str+="\"propertyURI\":"+"\""+propertyURI+"\","; + json_str+="\"predicate\":"+"\""+propertyURI+"\","; + } + else{ + json_str+="\"predicate\":"+"\"propertyURI\","; + } + if( linkedClassURI != null ){ + //json_str+="\"linkedClassURI\":"+"\""+linkedClassURI+"\","; + json_str+="\"linkedClass\":"+"\""+linkedClassURI+"\","; + } + else{ + //json_str+="\"linkedClassURI\":"+"\"linkedClassURI\","; + json_str+="\"linkedClass\":"+"\""+linkedClassURI+"\","; + } + if( linkedLiteralDatatypeURI != null ){ + json_str+="\"linkedLiteralDatatypeURI\":"+"\""+linkedLiteralDatatypeURI+"\","; + } + else{ + json_str+="\"linkedLiteralDatatypeURI\":"+"\"linkedLiteralDatatypeURI\","; + } + if( direction != null ){ + json_str+="\"direction\":"+"\""+direction.toString()+"\","; + } + else{ + json_str+="\"direction\":"+"\"direction\","; + } + if ( linkedClassURI != null ){ + String label = getLinkedClassLabel(classes); + json_str+="\"label\":"+"\""+label+"\""; + }else if ( linkedLiteralDatatypeURI != null ){ + String url[] = linkedLiteralDatatypeURI.split("/"); + String tmplabel = url[url.length-1]; + String[] tmplabel2 = tmplabel.split("#"); + String label = tmplabel2[tmplabel2.length-1]; + json_str+="\"label\":"+"\""+label+"\""; + }else{ + json_str+="\"label\":"+"\""+"\"No Label\""+"\""; + } + // json_str+="\"numOfLinks\":"+"\""+numOfLinks+"\","; + // json_str+="\"numOfLinkedInstances\":"+"\""+numOfLinkedInstances+"\","; + // json_str+="\"numOfOriginInstances\":"+"\""+numOfOriginInstances+"\","; + // json_str+="\"numOfOriginClassInstances\":"+"\""+numOfOriginClassInstances+"\","; + // json_str+="\"numOfLinkedClassInstances\":"+"\""+numOfLinkedClassInstances+"\""; + + json_str+="}"; + + return json_str; + } + + public String toJSONString4(QueryPathGenerator qpg) { + String json_str ="{"; + + if( propertyURI != null ) { + //json_str+="\"propertyURI\":"+"\""+propertyURI+"\","; + json_str+="\"predicate\":"+"\""+propertyURI+"\","; + } + else{ + json_str+="\"predicate\":"+"\"propertyURI\","; + } + if( linkedClassURI != null ){ + //json_str+="\"linkedClassURI\":"+"\""+linkedClassURI+"\","; + json_str+="\"linkedClass\":"+"\""+linkedClassURI+"\","; + } + else{ + //json_str+="\"linkedClassURI\":"+"\"linkedClassURI\","; + json_str+="\"linkedClass\":"+"\""+linkedClassURI+"\","; + } + if( linkedLiteralDatatypeURI != null ){ + json_str+="\"linkedLiteralDatatypeURI\":"+"\""+linkedLiteralDatatypeURI+"\","; + } + else{ + json_str+="\"linkedLiteralDatatypeURI\":"+"\"linkedLiteralDatatypeURI\","; + } + if( direction != null ){ + json_str+="\"direction\":"+"\""+direction.toString()+"\","; + } + else{ + json_str+="\"direction\":"+"\"direction\","; + } + if ( linkedClassURI != null ){ + String label = qpg.getClassLabel(linkedClassURI); + json_str+="\"label\":"+"\""+label+"\""; + }else if ( linkedLiteralDatatypeURI != null ){ + String url[] = linkedLiteralDatatypeURI.split("/"); + String tmplabel = url[url.length-1]; + String[] tmplabel2 = tmplabel.split("#"); + String label = tmplabel2[tmplabel2.length-1]; + json_str+="\"label\":"+"\""+label+"\""; + }else{ + json_str+="\"label\":"+"\""+"\"No Label\""+"\""; + } + json_str+="}"; + + return json_str; + } + + + public int getNumOfLinks() { + return numOfLinks; + } + + + + + public void setNumOfLinks(int numOfLinks) { + this.numOfLinks = numOfLinks; + } + + + + + /** + * 譁�ｭ怜�陦ｨ險倥ｒ蜿門ｾ励☆繧� + * + * @since 28.01.2014 + */ + public String toString(){ + StringBuffer sb = new StringBuffer(); + sb.append(propertyURI); + if( direction == Direction.forward ){ + sb.append(" --> "); + }else{ + if( direction == Direction.reverse ){ + sb.append(" <-- "); + }else{ + sb.append(" <-> "); + } + } + sb.append(linkedClassURI); + sb.append(" ["); + sb.append(numOfOriginClassInstances); + sb.append("/"); + sb.append(numOfOriginInstances); + sb.append("]縲---"); + + + sb.append(" ["); + sb.append(numOfLinks); + sb.append("] --->"); + + sb.append(" ["); + sb.append(numOfLinkedClassInstances); + sb.append("/"); + sb.append(numOfLinkedInstances); + sb.append("]"); + return sb.toString(); + } + + public String getPropertyURI() { + return propertyURI; + } + public void setPropertyURI(String propertyURI) { + this.propertyURI = propertyURI; + } + public String getLinkedClassURI() { + return linkedClassURI; + } + public void setLinkedClassURI(String linkedClassURI) { + this.linkedClassURI = linkedClassURI; + } + public Direction getDirection() { + return direction; + } + public void setDirection(Direction direction) { + this.direction = direction; + } + + public final int getNumOfLinkedInstances() { + return numOfLinkedInstances; + } + + public final void setNumOfLinkedInstances(int numOfLinkedInstances) { + this.numOfLinkedInstances = numOfLinkedInstances; + } + + + + + public final boolean isDomainClassLimitedQ() { + return domainClassLimitedQ; + } + + + public final boolean isRangeClassLimitedQ() { + return rangeClassLimitedQ; + } + + + public final int getNumOfOriginInstances() { + return numOfOriginInstances; + } + + + public final void setNumOfOriginInstances(int numOfOriginInstances) { + this.numOfOriginInstances = numOfOriginInstances; + } + + + public final int getNumOfOriginClassInstances() { + return numOfOriginClassInstances; + } + + + public final void setNumOfOriginClassInstances(int numOfOriginClassInstances) { + this.numOfOriginClassInstances = numOfOriginClassInstances; + } + + + public final int getNumOfLinkedClassInstances() { + return numOfLinkedClassInstances; + } + + + public final void setNumOfLinkedClassInstances(int numOfLinkedClassInstances) { + this.numOfLinkedClassInstances = numOfLinkedClassInstances; + } + + + public final String getLinkedLiteralDatatypeURI() { + return linkedLiteralDatatypeURI; + } + + + public final void setLinkedLiteralDatatypeURI(String linkedLiteralDatatypeURI) { + this.linkedLiteralDatatypeURI = linkedLiteralDatatypeURI; + } + + + public final void setDomainClassLimitedQ(boolean domainClassLimitedQ) { + this.domainClassLimitedQ = domainClassLimitedQ; + } + + + public final void setRangeClassLimitedQ(boolean rangeClassLimitedQ) { + this.rangeClassLimitedQ = rangeClassLimitedQ; + } + + private String getLinkedClassLabel(SClass[] classes){ + return QueryPathGenerator.getClassLabelfromList(linkedClassURI, classes); + } + + // private String[] propertyDomainClassURIs = null; + // private String[] propertyRangeClassURIs = null; + + + +} Index: SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/OWL/OWLLabelReader.java =================================================================== --- SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/OWL/OWLLabelReader.java (revision 267) +++ SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/OWL/OWLLabelReader.java (revision 267) @@ -0,0 +1,39 @@ +/* + * To change this license header, choose License Headers in Project Properties. + * To change this template file, choose Tools | Templates + * and open the template in the editor. + */ +package org.biohackathon.SPARQLBuilder.OWL; + +/** + * + * @author atsuko + */ + +import java.util.*; +import java.io.*; + +public class OWLLabelReader { + static Map readLabels(String dir){ + Map labels = new HashMap (); + File fdir = new File(dir); + if ( fdir.exists() ){ + File[] files = fdir.listFiles(); + for (int i = 0 ; i < files.length; i++ ){ + try{ + BufferedReader in = new BufferedReader(new FileReader(files[i])); + String buf; + while( (buf = in.readLine()) != null){ + String[] data1 = buf.split("[\\s]+"); + String[] data2 = buf.split("\""); + labels.put(data1[0].substring(1,data1[0].length() - 1 ), data2[1]); + } + in.close(); + }catch(IOException e){ + System.err.println(e); + } + } + } + return labels; + } +} Index: SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/OWL/AcquiredStructureAnalyzer.java =================================================================== --- SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/OWL/AcquiredStructureAnalyzer.java (revision 267) +++ SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/OWL/AcquiredStructureAnalyzer.java (revision 267) @@ -0,0 +1,433 @@ +package org.biohackathon.SPARQLBuilder.OWL; + +import java.util.*; + +import jp.riken.accc.db.rdf.crawler.dataStructure.sparql.JenaModelGenerator; +import jp.riken.accc.db.rdf.crawler.dataStructure.sparql.URICollection; + +import com.hp.hpl.jena.query.Query; +import com.hp.hpl.jena.query.QueryExecution; +import com.hp.hpl.jena.query.QueryExecutionFactory; +import com.hp.hpl.jena.query.QueryFactory; +import com.hp.hpl.jena.query.QuerySolution; +import com.hp.hpl.jena.query.ResultSet; +import com.hp.hpl.jena.rdf.model.Literal; +import com.hp.hpl.jena.rdf.model.Model; +import com.hp.hpl.jena.rdf.model.Property; +import com.hp.hpl.jena.rdf.model.Resource; + +//public class OWLQueryBuilderForCrawlerImpl implements OWLQueryBuilder { +public class AcquiredStructureAnalyzer implements RDFSchemaAnalyzer { + + private Model model = null; + private String endpointURI = null; + private String[] graphURIs = null; + + public String getEndpointURI(){ + return endpointURI; + } + + public String[] getGraphURIs(){ + return graphURIs; + } + + /* + public static void main(String[] args) throws Exception{ + + JenaModelGenerator jmGene = new JenaModelGenerator("c:\\temp\\biosamplesF11.ttl"); +// JenaModelGenerator jmGene = new JenaModelGenerator("c:\\temp\\reactomeF18s.ttl"); + AcquiredStructureAnalyzer impl + = new AcquiredStructureAnalyzer(jmGene.getEndpointURI(), jmGene.getGraphURIs(), jmGene.getModel()); + + System.out.println("--------------------------"); + SClass[] scs = impl.getOWLClasses(null, null, null, true); + System.out.println("list classes:---------------"); + for(SClass sc: scs){ + System.out.println(sc.toString()); + } + System.out.println("--------------------------"); + +// ClassLink[] cls = impl.getNextClass(null,"http://www.biopax.org/release/biopax-level3.owl#Protein",100,true ); +// for(ClassLink cl: cls){ +// System.out.println(cl.toString()); +// } +// System.out.println("--------------------------"); + + } + */ + + public AcquiredStructureAnalyzer(String endpointURI, String[] graphURIs, Model model){ + this.model = model; + this.endpointURI = endpointURI; + this.graphURIs = graphURIs; + } + + private String[] filterGraphURIs(String[] orgGraphURIs){ + // TODO + return graphURIs; + } + + + public SClass[] listClasses(String[] graphURIs, boolean countInstances) throws Exception{ + return getOWLClasses(graphURIs, null, null, countInstances); + } + + + + + public SClass[] getOWLClasses(String[] graphURIs, String[] keywords, String language, boolean countInstances) throws Exception{ + return getOWLClassList(graphURIs, keywords, language, countInstances).toArray(new SClass[0]); + } + + public List getOWLClassList(String[] graphURIs, String[] keywords, String language, boolean countInstances) throws Exception{ + String[] targetGraphURIs = filterGraphURIs(graphURIs); + + StringBuffer queryStr = new StringBuffer(); + queryStr.append("PREFIX owl: \n"); + queryStr.append("PREFIX rdfs: \n"); + queryStr.append("PREFIX rdf: \n"); + queryStr.append("SELECT DISTINCT ?c ?pLabel ?entities\n"); +// if (targetGraphURIs != null) { +// for (String graphURI : targetGraphURIs) { +// queryStr.append("FROM <"); +// queryStr.append(graphURI); +// queryStr.append(">\n"); +// } +// } + queryStr.append("WHERE{\n"); + queryStr.append(" ?cp <").append(URICollection.PROPERTY_VOID_CLASS).append("> ?c. \n"); + queryStr.append(" ?cp <"); + queryStr.append(URICollection.PROPERTY_VOID_ENTITIES); + queryStr.append("> ?entities. \n"); + queryStr.append(" OPTIONAL{ ?c <"); + queryStr.append(URICollection.PROPERTY_RDFS_LABEL); + queryStr.append("> ?pLabel. }\n"); + + if (keywords != null && keywords.length != 0) { + + queryStr.append(" ?c rdfs:label "); + queryStr.append("?keywords").append(".\n"); + queryStr.append(" filter((LANG(?keywords) = \'").append(language); + queryStr.append("\') && \n ("); + + for (int i = 0; i < keywords.length; i++) { + if (i > 0) + queryStr.append(" || \n "); + + queryStr.append("regex(str(").append("?keywords") + .append("),\""); + queryStr.append(keywords[i]); + queryStr.append("\", \"i\" )"); + + } + queryStr.append("))\n"); + + } + queryStr.append("}"); + System.out.println(queryStr.toString()); + + Query query = QueryFactory.create(queryStr.toString()); + + QueryExecution qexec = null; + ResultSet results = null; + try { +// long start = System.currentTimeMillis(); + qexec = QueryExecutionFactory.create(query, model); + results = qexec.execSelect(); +// long end = System.currentTimeMillis(); +// System.out.println("EXEC TIME: " + (end - start)); + } catch (Exception ex) { + ex.printStackTrace(); + throw ex; + } + + HashMap classMap = new HashMap(); + for (; results.hasNext();) { + QuerySolution sol = results.next(); + Resource res = sol.getResource("c"); + if (res != null && res.getURI() != null) { + String uri = res.getURI(); + int numOfInstances = 0; + if (countInstances) { + numOfInstances = sol.getLiteral("entities").getInt(); + } // + Literal labelLiteral = sol.getLiteral("pLabel"); + SClass sClass = null; + if (classMap.containsKey(uri)) { + sClass = classMap.get(uri); + } else { + sClass = new SClass(uri, null, numOfInstances); + classMap.put(uri, sClass); + } + if (labelLiteral != null) { + String label = labelLiteral.getString(); + String lang = labelLiteral.getLanguage(); + sClass.addLabel(new Label(label, lang)); + } + } + } + qexec.close(); + return new LinkedList(classMap.values()); + } + +/* + + public Instance[] getInstances(String[] graphURIs, String keyword) throws Exception; +*/ + + + public ClassLink[] getNextClass(String[] graphURIs, String originClass, int limit, boolean countLinks) throws Exception{ + String[] targetGraphURIs = filterGraphURIs(graphURIs); + + StringBuffer queryStr = new StringBuffer(); + queryStr.append("PREFIX owl: \n"); + queryStr.append("PREFIX rdfs: \n"); + queryStr.append("PREFIX rdf: \n"); + + // SELECT + queryStr.append("SELECT DISTINCT ?indPropCat ?c ?dat ?d ?p ?numLnkInsStart ?numLnkInsEnd ?numInsDom ?numInsRan ?numTriples\n"); + +// if (targetGraphURIs != null) { +// for (String graphURI : targetGraphURIs) { +// queryStr.append("FROM <"); +// queryStr.append(graphURI); +// queryStr.append(">\n"); +// } +// } + + queryStr.append("WHERE{\n"); + queryStr.append(" ?cr <").append(URICollection.PROPERTY_RDF_TYPE).append("> <").append(URICollection.RESOURCE_SB_CLASS_RELATION).append(">. \n"); + queryStr.append(" ?propPart <").append(URICollection.PROPERTY_SB_CLASS_RELATION).append("> ?cr. \n"); + queryStr.append(" ?propPart <").append(URICollection.PROPERTY_VOID_PROPERTY).append("> ?p. \n"); + + queryStr.append(" {"); + queryStr.append(" ?cr <").append(URICollection.PROPERTY_SB_SUBJECT_CLASS).append("> <" + originClass + ">. \n"); + queryStr.append(" ?cr <").append(URICollection.PROPERTY_SB_OBJECT_CLASS).append("> ?d. \n"); + queryStr.append(" ?cr <").append(URICollection.PROPERTY_VOID_DISTINCT_SUBJECTS).append("> ?numLnkInsStart. \n"); + queryStr.append(" ?cr <").append(URICollection.PROPERTY_VOID_DISTINCT_OBJECTS).append("> ?numLnkInsEnd. \n"); + queryStr.append(" ?cr <").append(URICollection.PROPERTY_VOID_TRIPLES).append("> ?numTriples. \n"); +// queryStr.append(" ?cr ?isStartClsLim. \n"); +// queryStr.append(" ?cr ?isEndClsLim. \n"); + queryStr.append("}\n"); + queryStr.append(" UNION\n"); + queryStr.append(" {"); + queryStr.append(" ?cr <").append(URICollection.PROPERTY_SB_SUBJECT_CLASS).append("> <" + originClass + ">. \n"); + queryStr.append(" ?cr <").append(URICollection.PROPERTY_SB_OBJECT_DATATYPE).append("> ?dat. \n"); + queryStr.append(" ?cr <").append(URICollection.PROPERTY_VOID_DISTINCT_SUBJECTS).append("> ?numLnkInsStart. \n"); + queryStr.append(" ?cr <").append(URICollection.PROPERTY_VOID_DISTINCT_OBJECTS).append("> ?numLnkInsEnd. \n"); + queryStr.append(" ?cr <").append(URICollection.PROPERTY_VOID_TRIPLES).append("> ?numTriples. \n"); +// queryStr.append(" ?cr ?isStartClsLim. \n"); +// queryStr.append(" ?cr ?isEndClsLim. \n"); + queryStr.append("}\n"); + queryStr.append(" UNION\n"); + queryStr.append(" {"); + queryStr.append(" ?cr <").append(URICollection.PROPERTY_SB_OBJECT_CLASS).append("> <" + originClass + ">. \n"); + queryStr.append(" ?cr <").append(URICollection.PROPERTY_SB_SUBJECT_CLASS).append("> ?c. \n"); + queryStr.append(" ?cr <").append(URICollection.PROPERTY_VOID_DISTINCT_SUBJECTS).append("> ?numLnkInsEnd. \n"); + queryStr.append(" ?cr <").append(URICollection.PROPERTY_VOID_DISTINCT_OBJECTS).append("> ?numLnkInsStart. \n"); + queryStr.append(" ?cr <").append(URICollection.PROPERTY_VOID_TRIPLES).append("> ?numTriples. \n"); +// queryStr.append(" ?cr ?isEndClsLim. \n"); +// queryStr.append(" ?cr ?isStartClsLim. \n"); + queryStr.append("}\n"); + +// queryStr.append(" ?propPart <").append(URICollection.PROPERTY_RDF_TYPE).append("> <").append(URICollection.PROPERTY_VOID_PROPERTY_PARTITION).append(">. \n"); + queryStr.append(" ?propPart <").append(URICollection.PROPERTY_SB_PROPERTY_CATEGORY).append("> ?indPropCat. \n"); + + queryStr.append(" ?propPart <").append(URICollection.PROPERTY_VOID_DISTINCT_SUBJECTS).append("> ?numInsDom. \n"); + queryStr.append(" ?propPart <").append(URICollection.PROPERTY_VOID_DISTINCT_OBJECTS).append("> ?numInsRan. \n"); + + queryStr.append("}\n"); + + + if (limit > 0) { + queryStr.append("limit "); + queryStr.append(limit); + queryStr.append("\n"); + } + +// System.out.println("getNextClasses SPARQL Query: "); +// System.out.println(queryStr.toString()); + + Query query = QueryFactory.create(queryStr.toString()); + QueryExecution qexec = null; + ResultSet results = null; + try { + long start = System.currentTimeMillis(); + qexec = QueryExecutionFactory.create(query, model); + results = qexec.execSelect(); + long end = System.currentTimeMillis(); + System.out.println("EXEC TIME: " + (end - start)); + } catch (Exception ex) { + ex.printStackTrace(); + throw ex; + } + + ArrayList solCLs = new ArrayList(); + for (; results.hasNext();) { + QuerySolution sol = results.next(); + Resource pro = sol.getResource("p"); + String clsURI = null; + String datURI = null; + if (pro != null) { + int indPropCat = 4; + Literal indPropCatLit = sol.getLiteral("indPropCat"); + if( indPropCatLit != null ){ + indPropCat = indPropCatLit.getInt(); + } + if( indPropCat < 4 ) { + String proURI = pro.getURI(); + Resource ccls = sol.getResource("c"); + Resource dcls = sol.getResource("d"); + Resource dat = sol.getResource("dat"); + Direction direction = null; + if(ccls != null && dcls == null ){ + // direction forward + direction = Direction.reverse; + clsURI = ccls.getURI(); + }else{ + if( ccls == null && dcls != null ){ + direction = Direction.forward; + clsURI = dcls.getURI(); + }else{ + if( ccls == null && dat != null && dcls == null ){ + clsURI = null; + direction = Direction.forward; + datURI = dat.getURI(); + } + } + } + + + int numTriples = 0; + Literal numTriplesLit = sol.getLiteral("numTriples"); + if( numTriplesLit != null ){ + numTriples = numTriplesLit.getInt(); + } + + int numLnkInsStart = 0; + Literal numInsStartLit = sol.getLiteral("numLnkInsStart"); + if( numInsStartLit != null ){ + numLnkInsStart = numInsStartLit.getInt(); + } + int numLnkInsEnd = 0; + Literal numInsEndLit = sol.getLiteral("numLnkInsEnd"); + if( numInsEndLit != null ){ + numLnkInsEnd = numInsEndLit.getInt(); + } + + int numInsDom = 0; + Literal numInsDomLit = sol.getLiteral("numInsDom"); + if( numInsDomLit != null ){ + numInsDom = numInsDomLit.getInt(); + } + int numInsRan = 0; + Literal numInsRanLit = sol.getLiteral("numInsRan"); + if( numInsRanLit != null ){ + numInsRan = numInsRanLit.getInt(); + } + + boolean isStartClsLim = false; + Literal isStartClsLimLit = sol.getLiteral("isStartClsLim"); + if( isStartClsLimLit != null ){ + isStartClsLim = isStartClsLimLit.getBoolean(); + } + boolean isEndClsLim = false; + Literal isEndClsLimLit = sol.getLiteral("isEndClsLim"); + if( isEndClsLimLit != null ){ + isEndClsLim = isEndClsLimLit.getBoolean(); + } + + ClassLink cl = new ClassLink(proURI, clsURI, datURI, direction, + numTriples, numInsDom, numInsRan, numLnkInsStart, numLnkInsEnd, isStartClsLim, isEndClsLim); + solCLs.add(cl); + + } + } + } + qexec.close(); + return solCLs.toArray(new ClassLink[0]); + } + + + + /* + + public ClassLink[] getNextClassViaInstanceLink(String[] graphURIs, String originClass, int limit) throws Exception; + + public Path[] getPaths(String startClass, String endClass, int mode, boolean countLinks) throws Exception; + + public String createSPARQL(Path path) throws Exception; + + InstanceLink[] getNextInstancesViaInstanceLink(String[] graphURIs, String originInstance, + int limit) throws Exception; +*/ + + public LabelMap[] getLabels(String[] graphURIs, String[] resourceURIs, + String language) throws Exception { + if (resourceURIs == null || resourceURIs.length == 0) { + return new LabelMap[0]; + } + StringBuffer queryStr = new StringBuffer(); + queryStr.append("PREFIX owl: \n"); + queryStr.append("PREFIX rdfs: \n"); + queryStr.append("PREFIX rdf: \n"); + queryStr.append("SELECT DISTINCT ?res ?label \n"); + if (graphURIs != null) { + for (String graphURI : graphURIs) { + queryStr.append("FROM <"); + queryStr.append(graphURI); + queryStr.append(">\n"); + } + } + queryStr.append("WHERE{\n"); + queryStr.append(" ?res rdfs:label ?label.\n"); + queryStr.append(" FILTER(?res IN ("); + boolean f = false; + for (String resourceURI : resourceURIs) { + if (f) { + queryStr.append(", "); + } + f = true; + queryStr.append("<"); + queryStr.append(resourceURI); + queryStr.append(">"); + } + queryStr.append("))\n"); + queryStr.append("}"); + +// System.out.println(queryStr.toString()); + + Query query = QueryFactory.create(queryStr.toString()); + QueryExecution qexec = QueryExecutionFactory.create(query, model); + + ResultSet results = qexec.execSelect(); + HashMap lMap = new HashMap(); + for (; results.hasNext();) { + QuerySolution sol = results.next(); + String uri = sol.getResource("res").getURI(); + Literal literal = sol.getLiteral("label"); + if (literal != null) { + String label = literal.getString(); + String lang = literal.getLanguage(); + if (language != null && language.equals(lang)) { + Label lbl = new Label(label, lang); + if (lMap.containsKey(uri)) { + LabelMap lm = lMap.get(uri); + lm.addLabel(lbl); + } else { + LabelMap lm = new LabelMap(uri, new Label[] { lbl }); + lMap.put(uri, lm); + } + } + } + } + return lMap.values().toArray(new LabelMap[0]); + } + +/* + public ClassLink[] countLinks(String[] graphURIs, String startClassURI, ClassLink[] classLinks) throws Exception; + public SClass[] countInstances(String[] graphURIs, SClass[] classes) throws Exception; + +*/ + +} Index: SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/OWL/OWLClassSearcherImpl.java =================================================================== --- SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/OWL/OWLClassSearcherImpl.java (revision 267) +++ SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/OWL/OWLClassSearcherImpl.java (revision 267) @@ -0,0 +1,14 @@ +package org.biohackathon.SPARQLBuilder.OWL; + +public class OWLClassSearcherImpl implements OWLClassSearcher { + + public SClass[] keywordSearch(String[] keywords) throws Exception{ + return null; + } + + public SClass[] listClasses() throws Exception{ + return null; + } + + +} Index: SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/OWL/EndpointAnalyzer.java =================================================================== --- SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/OWL/EndpointAnalyzer.java (revision 267) +++ SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/OWL/EndpointAnalyzer.java (revision 267) @@ -0,0 +1,1165 @@ +package org.biohackathon.SPARQLBuilder.OWL; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Set; + +import com.hp.hpl.jena.query.Query; +import com.hp.hpl.jena.query.QueryExecution; +import com.hp.hpl.jena.query.QueryExecutionFactory; +import com.hp.hpl.jena.query.QueryFactory; +import com.hp.hpl.jena.query.QuerySolution; +import com.hp.hpl.jena.query.ResultSet; +import com.hp.hpl.jena.rdf.model.Literal; +import com.hp.hpl.jena.rdf.model.Resource; + +/** + * 繧ｯ繧ｨ繝ｪ繧堤函謌舌☆繧九◆繧√�讖溯�繧呈署萓帙☆繧区ｸ繧ｯ繝ｩ繧ｹ + * + * @author Norio KOBAYASHI + * @since 28.01.2014 + * @version 29.01.2014 + */ +public class EndpointAnalyzer implements RDFSchemaAnalyzer { + + // private Model model = null; + private String endpointURI = null; + + /** + * 繧｢繧ｯ繧ｻ繧ｹ縺吶ｋSPARQL endpoint縺ｮURI繧呈欠螳壹☆繧区ｧ区�蟄� + * + * @param endpointURI + * 縲繧｢繧ｯ繧ｻ繧ｹ縺吶ｋSPARQL endpoint縺ｮURI + * @throws Exception + * @since 28.01.2014 + */ + public EndpointAnalyzer(String endpointURI) { + this.endpointURI = endpointURI; + } + + /** + * 繝�せ繝医↓菴ｿ逕ｨ縺吶ｋmain繝｡繧ｽ繝�ラ + * + * 繧ｯ繧ｨ繝ｪ繝薙Ν繝繝ｼ縺ｮ譛ｬ逡ｪ繝励Ο繧ｰ繝ｩ繝縺ｧ縺ｯ縺薙�繝｡繧ｽ繝�ラ縺ｯ菴ｿ逕ｨ縺励↑縺� + * + * + * @param args + * 菴ｿ逕ｨ縺励↑縺� + * @throws Exception + * @since 28.01.2014 + */ + public static void main(String[] args) throws Exception { + // String sparqlEndpoint = "http://dbpedia.org/sparql"; + String sparqlEndpoint = "http://lsd.dbcls.jp/sparql"; + // String keyword = "artiste"; + String[] keyword = { "Frequency", "Class" }; + String[] graphURIs = new String[0]; + + // keyword = null; + + EndpointAnalyzer builder = new EndpointAnalyzer(sparqlEndpoint); + + SClass[] clz = builder.getOWLClasses(null, keyword, "en", false); + if (clz != null) { + + for (SClass cls : clz) { + System.out.println(cls); + } + clz = builder.countInstances(null, clz); + for (SClass cls : clz) { + System.out.println(cls); + } + } + + /* + * clz = builder.listClasses(null, false); + * System.out.println(clz.length); for (SClass cls : clz) { + * System.out.println(cls); } + */ + + /* + * SClass[] clz = builder.getOWLClasses(graphURIs, keyword, false); for + * (SClass cls : clz) { System.out.println(cls); } clz = + * builder.countInstances(null, clz); for (SClass cls : clz) { + * System.out.println(cls); } + */ + + // builder.getOWLClasses(null, keyword, "en", false); + /* + * SClass[] clz = builder.getOWLClasses(graphURIs, keyword, false); for + * (SClass cls : clz) { System.out.println(cls); } clz = + * builder.countInstances(null, clz); for (SClass cls : clz) { + * System.out.println(cls); } + */ + + /* + * System.out.println("CLS"); + * + * String uri = + * "http://purl.jp/bio/10/lsd/ontology/201209#EnglishEntry"; + * + * ClassLink[] cls = null; try{ cls = builder.getNextClass(null, uri, + * 100, false); }catch(Exception ex) { ex.printStackTrace(); } + * + * System.out.println("Solutions: "); if (cls != null) { for (ClassLink + * cl : cls) { System.out.println(cl.toString()); } cls = + * builder.countLinks(null, uri, cls); for (ClassLink cl : cls) { + * System.out.println(cl.toString()); } } + */ + /* + * + * String uri = + * "http://purl.jp/bio/10/lsd/ontology/201209#EnglishEntry"; + * + * ClassLink[] cls = null; + * + * System.out.println("CLS-INS"); cls = null; try{ cls = + * builder.getNextClassViaInstanceLink(null, uri, 100); }catch(Exception + * ex){ ex.printStackTrace(); } if (cls != null) { for (ClassLink cl : + * cls) { System.out.println(cl.toString()); } } + */ + /* + * System.out.println("Instances"); Instance[] ins = + * builder.getInstances(null, "\"A.C. Reed\"@en"); if (ins != null) { + * for (Instance in : ins) { System.out.println(in.toString()); } } + */ + /* + * System.out.println("INS-INS"); ins = builder.getInstances(null, + * "\"A.C. Reed\"@en"); InstanceLink[] iLinks = + * builder.getNextInstancesViaInstanceLink(null, + * ins[0].getInstanceURI(), 100); + * + * if (iLinks != null) { for (InstanceLink in : iLinks) { + * System.out.println(in.toString()); } } + */ + } + + /** + * 譏守､ｺ逧�↓RDF縺ｧ譖ｸ縺九ｌ縺ｦ縺�ｋ繧ｯ繝ｩ繧ｹ繧貞叙蠕励☆繧� + * + * 謖�ｮ壹＆繧後◆graphURIs縺ｮ荳ｭ縺九ｉ縲√く繝ｼ繝ｯ繝ｼ繝峨↓繝偵ャ繝医☆繧九Λ繝吶Ν繧呈戟縺､繧ｯ繝ｩ繧ｹ��dfs:Class�峨ｒ縺吶∋縺ｦ霑斐☆ + * + * + * @param graphURIs + * 縲讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� (null繧�聞縺�縺ｮ驟榊�繧ょ庄) + * @param keyword + * ��ull繧�ｩｺ譁�ｭ励�荳榊庄�� + * @return 繧ｯ繝ｩ繧ｹURI縺ｮ驟榊� + * @throws Exception + * @since 28.01.2014 + */ + +// public List + + public SClass[] getOWLClasses(String[] graphURIs, String[] keywords, + String language, + + boolean countInstances) throws Exception { + StringBuffer queryStr = new StringBuffer(); + queryStr.append("PREFIX owl: \n"); + queryStr.append("PREFIX rdfs: \n"); + queryStr.append("PREFIX rdf: \n"); + if (countInstances) { + queryStr.append("SELECT DISTINCT ?c ?pLabel (COUNT(?i) AS ?numOfInstances)\n"); + } else { + queryStr.append("SELECT DISTINCT ?c ?pLabel \n"); + } + if (graphURIs != null) { + for (String graphURI : graphURIs) { + queryStr.append("FROM <"); + queryStr.append(graphURI); + queryStr.append(">\n"); + } + } + queryStr.append("WHERE{\n"); + + // + queryStr.append(" {?c rdf:type rdfs:Class} UNION {?c rdf:type owl:Class}\n"); + // queryStr.append(" ?i rdf:type ?c.\n"); + + if (countInstances) { + queryStr.append(" ?c rdfs:label ?label.\n"); + } + queryStr.append(" ?c rdfs:label ?pLabel.\n"); + if (countInstances) { + queryStr.append(" ?i rdf:type ?c.\n"); + } + // queryStr.append(" ?c rdfs:label "); + // queryStr.append(keyword); + // queryStr.append("."); + + // TODO OR relationship between keywords + if (keywords != null && keywords.length != 0) { + + queryStr.append(" ?c rdfs:label "); + queryStr.append("?keywords").append(".\n"); + queryStr.append(" filter((LANG(?keywords) = \'").append(language); + queryStr.append("\') && \n ("); + + // (LANG(?keywords) = 'en') && + + for (int i = 0; i < keywords.length; i++) { + if (i > 0) + queryStr.append(" || \n "); + + queryStr.append("regex(str(").append("?keywords") + .append("),\""); + queryStr.append(keywords[i]); + queryStr.append("\", \"i\" )"); + + } + queryStr.append("))\n"); + + } + + if (countInstances) { + queryStr.append("} GROUP BY ?c ?pLabel"); + } else { + queryStr.append("}"); + } + System.out.println(queryStr.toString()); + + Query query = QueryFactory.create(queryStr.toString()); + + QueryExecution qexec = null; + ResultSet results = null; + try { + long start = System.currentTimeMillis(); + qexec = QueryExecutionFactory.sparqlService(endpointURI, query); + results = qexec.execSelect(); + long end = System.currentTimeMillis(); + System.out.println("EXEC TIME: " + (end - start)); + } catch (Exception ex) { + ex.printStackTrace(); + throw ex; + } + + HashMap classMap = new HashMap(); + for (; results.hasNext();) { + QuerySolution sol = results.next(); + Resource res = sol.getResource("c"); + if (res != null) { + String uri = res.getURI(); + int numOfInstances = 0; + if (countInstances) { + numOfInstances = sol.getLiteral("numOfInstances").getInt(); + } // + System.out.println(numOfInstances); + Literal labelLiteral = sol.getLiteral("pLabel"); + SClass sClass = null; + if (classMap.containsKey(uri)) { + sClass = classMap.get(uri); + } else { + sClass = new SClass(uri, null, numOfInstances); + classMap.put(uri, sClass); + } + if (labelLiteral != null) { + String label = labelLiteral.getString(); + String lang = labelLiteral.getLanguage(); + sClass.addLabel(new Label(label, lang)); + } + } + } + qexec.close(); + return classMap.values().toArray(new SClass[0]); + + } + + public SClass[] listClasses(String[] graphURIs, boolean countInstances) + throws Exception { + StringBuffer queryStr = new StringBuffer(); + queryStr.append("PREFIX owl: \n"); + queryStr.append("PREFIX rdfs: \n"); + queryStr.append("PREFIX rdf: \n"); + if (countInstances) { + queryStr.append("SELECT DISTINCT ?cls ?pLabel (COUNT(?i) AS ?numOfInstances)\n"); + } else { + queryStr.append("SELECT DISTINCT ?cls ?pLabel \n"); + } + + if (graphURIs != null) { + for (String graphURI : graphURIs) { + queryStr.append("FROM <"); + queryStr.append(graphURI); + queryStr.append(">\n"); + } + } + queryStr.append("WHERE{\n"); + queryStr.append("\t{ ?cls rdf:type rdfs:Class. }\n"); + queryStr.append("\tUNION\n"); + queryStr.append("\t{ ?cls rdf:type owl:Class. }\n"); + queryStr.append("\tUNION\n"); + queryStr.append("\t{ [] rdfs:type ?cls. }\n"); + queryStr.append("\tUNION\n"); + queryStr.append("\t{ [] rdfs:domain ?cls. }\n"); + queryStr.append("\tUNION\n"); + queryStr.append("\t{ [] rdfs:range ?cls. }\n"); + queryStr.append("\tUNION\n"); + queryStr.append("\t{ ?cls rdfs:subclassOf []. }\n"); + queryStr.append("\t?cls rdfs:label ?pLabel.\n"); + if (countInstances) { + queryStr.append("\t?i rdf:type ?c.\n"); + } + if (countInstances) { + queryStr.append("} GROUP BY ?c ?pLabel"); + } else { + queryStr.append("}"); + } + System.out.println(queryStr.toString()); + + Query query = QueryFactory.create(queryStr.toString()); + + QueryExecution qexec = null; + ResultSet results = null; + try { + long start = System.currentTimeMillis(); + qexec = QueryExecutionFactory.sparqlService(endpointURI, query); + results = qexec.execSelect(); + long end = System.currentTimeMillis(); + System.out.println("EXEC TIME: " + (end - start)); + } catch (Exception ex) { + ex.printStackTrace(); + throw ex; + } + + HashMap classMap = new HashMap(); + for (; results.hasNext();) { + QuerySolution sol = results.next(); + Resource res = sol.getResource("cls"); + if (res != null) { + String uri = res.getURI(); + int numOfInstances = 0; + if (countInstances) { + numOfInstances = sol.getLiteral("numOfInstances").getInt(); + } + // System.out.println(numOfInstances); + Literal labelLiteral = sol.getLiteral("pLabel"); + SClass sClass = null; + if (classMap.containsKey(uri)) { + sClass = classMap.get(uri); + } else { + sClass = new SClass(uri, null, numOfInstances); + classMap.put(uri, sClass); + } + if (labelLiteral != null) { + String label = labelLiteral.getString(); + String lang = labelLiteral.getLanguage(); + sClass.addLabel(new Label(label, lang)); + } + } + } + qexec.close(); + return classMap.values().toArray(new SClass[0]); + + } + + /** + * 縲繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧貞叙蠕励☆繧� + * + * 謖�ｮ壹＆繧後◆graphURIs縺ｮ荳ｭ縺九ｉ縲√く繝ｼ繝ｯ繝ｼ繝峨↓繝偵ャ繝医☆繧九Λ繝吶Ν繧呈戟縺､繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧偵☆縺ｹ縺ｦ霑斐☆ + * 縺薙％縺ｧ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ縺ｯ縲〉df:type縺ｮ荳ｻ隱槭→縺励※險倩ｿｰ縺輔ｌ縺ｦ縺�ｋ繧ゅ�繧偵＞縺� + * + * + * @param graphURIs + * 縲讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� (null繧�聞縺�縺ｮ驟榊�繧ょ庄) + * @param keyword + * ��ull繧�ｩｺ譁�ｭ励�荳榊庄�� + * @return 繧ｯ繝ｩ繧ｹURI縺ｮ驟榊� + * @throws Exception + * @since 28.01.2014 + */ + public Instance[] getInstances(String[] graphURIs, String keyword) + throws Exception { + StringBuffer queryStr = new StringBuffer(); + queryStr.append("PREFIX owl: \n"); + queryStr.append("PREFIX rdfs: \n"); + queryStr.append("PREFIX rdf: \n"); + queryStr.append("SELECT DISTINCT ?ins ?c \n"); + if (graphURIs != null) { + for (String graphURI : graphURIs) { + queryStr.append("FROM <"); + queryStr.append(graphURI); + queryStr.append(">\n"); + } + } + queryStr.append("WHERE{\n"); + // queryStr.append(" {?c rdf:type rdfs:Class} UNION {?c rdf:type owl:Class}\n"); + + queryStr.append(" ?ins rdf:type ?c.\n"); + queryStr.append(" ?ins rdfs:label "); + queryStr.append(keyword); + queryStr.append(".\n"); + queryStr.append(" FILTER (?c != rdf:Property)"); + queryStr.append("}"); + + // System.out.println(queryStr.toString()); + + Query query = QueryFactory.create(queryStr.toString()); + QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI, + query); + + ResultSet results = qexec.execSelect(); + HashMap> instanceMap = new HashMap>(); + for (; results.hasNext();) { + QuerySolution sol = results.next(); + Resource cls = sol.getResource("c"); + Resource ins = sol.getResource("ins"); + String clsURI = cls.getURI(); + String insURI = ins.getURI(); + if (instanceMap.containsKey(insURI)) { + HashSet classes = instanceMap.get(insURI); + classes.add(clsURI); + } else { + HashSet classes = new HashSet(); + instanceMap.put(insURI, classes); + classes.add(clsURI); + } + } + qexec.close(); + Set keySet = instanceMap.keySet(); + ArrayList instanceList = new ArrayList(); + for (String key : keySet) { + Instance ins = new Instance(key, instanceMap.get(key).toArray( + new String[0])); + instanceList.add(ins); + } + return instanceList.toArray(new Instance[0]); + } + + /** + * 縲謖�ｮ壹＆繧後◆繧ｯ繝ｩ繧ｹ繧定ｵｷ轤ｹ縺ｨ縺励∵�遉ｺ逧�↓險倩ｿｰ縺輔ｌ縺ｦ縺�ｋOWL縺ｮproperty蛻ｶ邏�ｒ隱ｿ縺ｹ縲√◎縺ｮproperty蛻ｶ邏�〒 + * 髢｢騾｣縺･縺代ｉ繧後※縺�ｋ繧ｯ繝ｩ繧ｹ繧堤ｶｲ鄒�噪縺ｫ蜿門ｾ励☆繧� + * + * 蜃ｦ逅�ｯｾ雎｡繝��繧ｿ繧暖raphURIs縺ｧ謖�ｮ壹☆繧九％縺ｨ縺後〒縺阪ｋ + * + * + * + * @param graphURIs + * 縲讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� 縲(null繧�聞縺�縺ｮ驟榊�繧ょ庄) + * @param originClass + * 襍ｷ轤ｹ縺ｨ縺ｪ繧九け繝ｩ繧ｹ縺ｮURI縲��ull荳榊庄�� + * @param limit + * 隗｣縺ｨ縺励※霑斐＆繧後ｋClassLink驟榊�縺ｮ髟ｷ縺輔�荳企剞蛟､繧呈欠螳壹☆繧九�荳企剞蛟､繧定ｨｭ螳壹＠縺ｪ縺�ｴ蜷医�0莉･荳九�蛟､繧呈欠螳壹☆繧� + * @return ClassLink縺ｮ驟榊�縲ゅ％縺薙↓縺ｯ縲∝叙蠕励＆繧後◆繧ｯ繝ｩ繧ｹ縺ｨ髢｢菫ゅ▼縺代ｉ繧後※縺�ｋ繝励Ο繝代ユ繧｣縲�未菫ゅ�蜷代″縺悟性縺ｾ繧後ｋ縲� + * @throws Exception + * @since 28.01.2014 + */ + public ClassLink[] getNextClass(String[] graphURIs, String originClass, + int limit, boolean countLinks) throws Exception { + ClassLink[] cLinks = getNextClassSub(graphURIs, originClass, limit, + false); + if (countLinks) { + cLinks = countLinks(graphURIs, originClass, cLinks); + } + return cLinks; + } + + private ClassLink[] getNextClassSub(String[] graphURIs, String originClass, + int limit, boolean countLinks) throws Exception { + StringBuffer queryStr = new StringBuffer(); + queryStr.append("PREFIX owl: \n"); + queryStr.append("PREFIX rdfs: \n"); + queryStr.append("PREFIX rdf: \n"); + + // SELECT + if (countLinks) { + queryStr.append("SELECT DISTINCT ?p ?pDirection ?c (COUNT(?oci) AS ?numOfOriginalClassInstances) (COUNT(?lci) AS ?numOfLinkedClassInstances) (COUNT(?s) AS ?numOfLinks) (COUNT(DISTINCT(?s)) AS ?numOfLinkedInstances) \n"); + } else { + queryStr.append("SELECT DISTINCT ?p ?pDirection ?c \n"); + } + + if (graphURIs != null) { + for (String graphURI : graphURIs) { + queryStr.append("FROM <"); + queryStr.append(graphURI); + queryStr.append(">\n"); + } + } + queryStr.append("WHERE{\n"); + // queryStr.append(" { ?c rdf:type rdfs:Class. }\n UNION\n { ?c rdf:type owl:Class. }\n"); + queryStr.append(" { ?p rdfs:domain <"); + queryStr.append(originClass); + queryStr.append(">.\n ?p rdfs:range ?c.\n"); + + if (countLinks) { + queryStr.append(" ?o ?p ?s."); + } else { + queryStr.append("filter(exists{\n"); + queryStr.append(" ?o rdf:type ?c.\n"); + queryStr.append(" ?s rdf:type <"); + queryStr.append(originClass); + queryStr.append(">.\n"); + queryStr.append(" ?s ?p ?o.})\n"); + } + + queryStr.append("}\n UNION\n"); + queryStr.append(" { ?p rdfs:range <"); + queryStr.append(originClass); + queryStr.append(">.\n"); + queryStr.append(" ?p rdfs:domain ?c.\n"); + + if (countLinks) { + queryStr.append(" ?s ?p ?o."); + } else { + queryStr.append("filter(exists{\n"); + queryStr.append(" ?s rdf:type ?c.\n"); + queryStr.append(" ?o rdf:type <"); + queryStr.append(originClass); + queryStr.append(">.\n"); + queryStr.append(" ?s ?p ?o.})\n"); + } + + queryStr.append("}\n"); + + queryStr.append(" ?p ?pDirection ?c.\n"); + + // queryStr.append(" ?s rdf:type ?c.\n"); + + if (countLinks) { + queryStr.append("}\nGROUP BY ?p ?pDirection ?c\n"); + } else { + queryStr.append("}\n"); + } + if (limit > 0) { + queryStr.append("limit "); + queryStr.append(limit); + queryStr.append("\n"); + } + + System.out.println("getNextClasses SPARQL Query: "); + System.out.println(queryStr.toString()); + + Query query = QueryFactory.create(queryStr.toString()); + QueryExecution qexec = null; + try { + qexec = QueryExecutionFactory.sparqlService(endpointURI, query); + } catch (Exception ex) { + ex.printStackTrace(); + throw ex; + } + + ResultSet results = null; + try { + long start = System.currentTimeMillis(); + results = qexec.execSelect(); + long end = System.currentTimeMillis(); + System.out.println("EXEC TIME: " + (end - start)); + } catch (Exception ex) { + ex.printStackTrace(); + throw ex; + } + + ArrayList solCLs = new ArrayList(); + for (; results.hasNext();) { + QuerySolution sol = results.next(); + Resource pro = sol.getResource("p"); + if (pro != null) { + Resource cls = sol.getResource("c"); + Resource dir = sol.getResource("pDirection"); + String proURI = pro.getURI(); + String clsURI = cls.getURI(); + String dirURI = dir.getURI(); + + // System.out.println(pro.getURI() + " " + cls.getURI() + " " + + // dir.getURI()); + + Direction direction = null; + if (dirURI + .equals("http://www.w3.org/2000/01/rdf-schema#domain") + || dirURI.equals("rdfs:domain")) { + direction = Direction.reverse; + } + if (dirURI.equals("http://www.w3.org/2000/01/rdf-schema#range") + || dirURI.equals("rdfs:range")) { + if (direction != null) { + direction = Direction.both; + } else { + direction = Direction.forward; + } + } + // System.out.println(direction); + int numOfLinks = 0; + if (countLinks) { + numOfLinks = sol.getLiteral("numOfLinks").getInt(); + } + ClassLink cl = new ClassLink(proURI, clsURI, null,direction, + numOfLinks, 0, 0, 0, 0, true, true); + solCLs.add(cl); + } + } + qexec.close(); + return solCLs.toArray(new ClassLink[0]); + } + + /** + * 縲謖�ｮ壹＆繧後◆繧ｯ繝ｩ繧ｹ繧定ｵｷ轤ｹ縺ｨ縺励√◎縺ｮ繧ｯ繝ｩ繧ｹ縺ｫ螻槭＠縺ｦ縺�ｋ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ繝ｪ繝ｳ繧ｯ縺悟ｼｵ繧峨ｌ縺ｦ縺�ｋ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮ髮�粋繧貞叙蠕励＠縲� + * 蜿門ｾ励＠縺溘う繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮ繧ｯ繝ｩ繧ｹ繧堤ｶｲ鄒�噪縺ｫ蜿門ｾ励☆繧� + * + * 縺薙％縺ｧ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ縺ｯ縲〉df:type縺ｮ荳ｻ隱槭→縺励※險倩ｿｰ縺輔ｌ縺ｦ縺�ｋ繧ゅ�繧偵＞縺� + * 蜃ｦ逅�ｯｾ雎｡繝��繧ｿ繧暖raphURIs縺ｧ謖�ｮ壹☆繧九％縺ｨ縺後〒縺阪ｋ + * + * + * @param graphURIs + * 縲讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� 縲(null繧�聞縺�縺ｮ驟榊�繧ょ庄) + * @param originClass + * 襍ｷ轤ｹ縺ｨ縺ｪ繧九け繝ｩ繧ｹ縺ｮURI縲��ull荳榊庄�� + * @param limit + * 隗｣縺ｨ縺励※霑斐＆繧後ｋClassLink驟榊�縺ｮ髟ｷ縺輔�荳企剞蛟､繧呈欠螳壹☆繧九�荳企剞蛟､繧定ｨｭ螳壹＠縺ｪ縺�ｴ蜷医�0莉･荳九�蛟､繧呈欠螳壹☆繧� + * @return ClassLink縺ｮ驟榊�縲ゅ％縺薙↓縺ｯ縲∝叙蠕励＆繧後◆繧ｯ繝ｩ繧ｹ縺ｨ髢｢菫ゅ▼縺代ｉ繧後※縺�ｋ繝励Ο繝代ユ繧｣縲�未菫ゅ�蜷代″縺悟性縺ｾ繧後ｋ縲� + * @throws Exception + * @since 28.01.2014 + */ + public ClassLink[] getNextClassViaInstanceLink(String[] graphURIs, + String originClass, int limit) throws Exception { + StringBuffer queryStr = new StringBuffer(); + queryStr.append("PREFIX owl: \n"); + queryStr.append("PREFIX rdfs: \n"); + queryStr.append("PREFIX rdf: \n"); + queryStr.append("SELECT DISTINCT ?pf ?pr (COUNT(?pf) AS ?numOfForwardLinks) (COUNT(?pr) AS ?numOfReverseLinks) (COUNT(DISTINCT(?insOrg)) AS ?numOfOriginInstances) (COUNT(DISTINCT(?ins)) AS ?numOfLinkedInstances) ?c \n"); + if (graphURIs != null) { + for (String graphURI : graphURIs) { + queryStr.append("FROM <"); + queryStr.append(graphURI); + queryStr.append(">\n"); + } + } + queryStr.append("WHERE{\n"); + queryStr.append(" ?ins rdf:type ?c.\n"); + queryStr.append(" ?insOrg rdf:type <"); + queryStr.append(originClass); + queryStr.append(">.\n"); + queryStr.append(" { ?ins ?pr ?insOrg. }\n UNION { ?insOrg ?pf ?ins. }\n"); + queryStr.append("}\n"); + queryStr.append("GROUP BY ?pf ?pr ?c\n"); + if (limit > 0) { + queryStr.append("limit "); + queryStr.append(limit); + queryStr.append("\n"); + } + + System.out.println(queryStr.toString()); + + Query query = QueryFactory.create(queryStr.toString()); + QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI, + query); + + ResultSet results = null; + try { + long start = System.currentTimeMillis(); + results = qexec.execSelect(); + long end = System.currentTimeMillis(); + System.out.println("EXEC TIME: " + (end - start)); + } catch (Exception ex) { + ex.printStackTrace(); + throw ex; + } + + ArrayList solCLs = new ArrayList(); + for (; results.hasNext();) { + QuerySolution sol = results.next(); + Resource proForward = sol.getResource("pf"); + Resource proReverse = sol.getResource("pr"); + Resource cls = sol.getResource("c"); + Direction direction = null; + String propURI = null; + int numOfLinks = 0; + int numOfLinkedInstances = 0; + int numOfOriginInstances = 0; + if (proForward != null) { + if (proReverse != null) { + numOfLinks = sol.getLiteral("numOfForwardLinks").getInt(); + numOfLinks += sol.getLiteral("numOfReverseLinks").getInt(); + numOfLinkedInstances = sol.getLiteral( + "numOfLinkedInstances").getInt(); + numOfOriginInstances = sol.getLiteral( + "numOfOriginInstances").getInt(); + direction = Direction.both; + } else { + numOfLinkedInstances = sol.getLiteral( + "numOfLinkedInstances").getInt(); + numOfOriginInstances = sol.getLiteral( + "numOfOriginInstances").getInt(); + numOfLinks = sol.getLiteral("numOfForwardLinks").getInt(); + direction = Direction.forward; + } + propURI = proForward.getURI(); + } else { + direction = Direction.reverse; + propURI = proReverse.getURI(); + numOfLinkedInstances = sol.getLiteral("numOfOriginInstances") + .getInt(); + numOfOriginInstances = sol.getLiteral("numOfLinkedInstances") + .getInt(); + numOfLinks = sol.getLiteral("numOfReverseLinks").getInt(); + } + String clsURI = cls.getURI(); + // System.out.println(propURI + " " + clsURI + " " + direction); + + ClassLink cl = new ClassLink(propURI, clsURI, null, direction, + numOfLinks, numOfOriginInstances, numOfLinkedInstances, 0, + 0, true, true); + solCLs.add(cl); + } + qexec.close(); + return solCLs.toArray(new ClassLink[0]); + } + +/* + public Path[] getPaths(String startClass, String endClass, int mode, + boolean countLinks) throws Exception { + OWLClassGraph graph = new OWLClassGraph(startClass, endClass); + // mode = 2 & countLinks = true are recommended + return graph.getPaths(this, mode, countLinks); + } + + public String createSPARQL(Path path) throws Exception { + return null; + } +*/ + + /* + * private String executeSelect(String sparqlQuery) throws Exception { + * HttpClient client = HttpClientBuilder.create().build(); HttpPost httppost + * = new HttpPost(endpointURI); httppost.setHeader("Content-Type", + * "application/x-www-form-urlencoded"); httppost.setHeader("Accept", + * "application/sparql-results+xml"); List nvpList = new + * ArrayList(); nvpList.add(new BasicNameValuePair("query", + * sparqlQuery)); // nvpList.add(new BasicNameValuePair("format", // + * outputFormat.getMime())); httppost.setEntity(new + * UrlEncodedFormEntity(nvpList, Charset .forName("UTF-8"))); HttpResponse + * response = client.execute(httppost); // + * System.out.println("[StatusLine] " + response.getStatusLine()); + * HttpEntity entity = response.getEntity(); String entityString = + * EntityUtils.toString(entity, "UTF-8"); return entityString; } + */ + + /** + * 縲謖�ｮ壹＆繧後◆繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧定ｵｷ轤ｹ縺ｨ縺励√◎縺ｮ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｫ繝ｪ繝ｳ繧ｯ縺悟ｼｵ繧峨ｌ縺ｦ縺�ｋ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮ髮�粋繧貞叙蠕励☆繧九� + * 縲蜿門ｾ励＆繧後◆蜷�う繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮ繧ｯ繝ｩ繧ｹ繧らｶｲ鄒�噪縺ｫ蜿門ｾ励☆繧� + * + * 縺薙％縺ｧ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ縺ｯ縲〉df:type縺ｮ荳ｻ隱槭→縺励※險倩ｿｰ縺輔ｌ縺ｦ縺�ｋ繧ゅ�繧偵＞縺� + * 蜃ｦ逅�ｯｾ雎｡繝��繧ｿ繧暖raphURIs縺ｧ謖�ｮ壹☆繧九％縺ｨ縺後〒縺阪ｋ + * + * + * @param graphURIs + * 縲讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� 縲(null繧�聞縺�縺ｮ驟榊�繧ょ庄) + * @param originInstance + * 襍ｷ轤ｹ縺ｨ縺ｪ繧九う繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮURI縲��ull荳榊庄�� + * @param limit + * 隗｣縺ｨ縺励※霑斐＆繧後ｋInstanceLink驟榊�縺ｮ髟ｷ縺輔�荳企剞蛟､繧呈欠螳壹☆繧九�荳企剞蛟､繧定ｨｭ螳壹＠縺ｪ縺�ｴ蜷医�0莉･荳九�蛟､繧呈欠螳壹☆繧� + * @return InstanceLink縺ｮ驟榊�縲ゅ％縺薙↓縺ｯ縲∝叙蠕励＆繧後◆繧ｯ繝ｩ繧ｹ縺ｨ髢｢菫ゅ▼縺代ｉ繧後※縺�ｋ繝励Ο繝代ユ繧｣縲�未菫ゅ�蜷代″縺悟性縺ｾ繧後ｋ縲� + * @throws Exception + * @since 28.01.2014 + */ + public InstanceLink[] getNextInstancesViaInstanceLink(String[] graphURIs, + String originInstance, int limit) throws Exception { + StringBuffer queryStr = new StringBuffer(); + queryStr.append("PREFIX owl: \n"); + queryStr.append("PREFIX rdfs: \n"); + queryStr.append("PREFIX rdf: \n"); + queryStr.append("SELECT DISTINCT ?pf ?pr ?ins ?c \n"); + if (graphURIs != null) { + for (String graphURI : graphURIs) { + queryStr.append("FROM <"); + queryStr.append(graphURI); + queryStr.append(">\n"); + } + } + queryStr.append("WHERE{\n"); + // queryStr.append(" { ?c rdf:type rdfs:Class. }\n UNION\n { ?c rdf:type owl:Class. }\n"); + queryStr.append(" ?ins rdf:type ?c.\n"); + queryStr.append(" { ?ins ?pr <"); + queryStr.append(originInstance); + queryStr.append(">. }\n UNION { <"); + queryStr.append(originInstance); + queryStr.append("> ?pf ?ins. }\n"); + + queryStr.append(" FILTER (?c != rdf:Property)"); + + queryStr.append("}\n"); + if (limit > 0) { + queryStr.append("limit "); + queryStr.append(limit); + queryStr.append("\n"); + } + + // System.out.println(queryStr.toString()); + + Query query = QueryFactory.create(queryStr.toString()); + QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI, + query); + + ResultSet results = qexec.execSelect(); + HashMap insLinkMap = new HashMap(); + for (; results.hasNext();) { + QuerySolution sol = results.next(); + Resource proForward = sol.getResource("pf"); + Resource proReverse = sol.getResource("pr"); + Resource ins = sol.getResource("ins"); + Resource cls = sol.getResource("c"); + Direction direction = null; + String propURI = null; + if (proForward != null) { + if (proReverse != null) { + direction = Direction.both; + } else { + direction = Direction.forward; + } + propURI = proForward.getURI(); + } else { + direction = Direction.reverse; + propURI = proReverse.getURI(); + } + String clsURI = cls.getURI(); + String insURI = ins.getURI(); + String key = propURI + "\t" + insURI + "\t" + direction; + if (insLinkMap.containsKey(key)) { + InstanceLink insLink = insLinkMap.get(key); + insLink.addLinkedClassURI(clsURI); + } else { + InstanceLink insLink = new InstanceLink(propURI, insURI, + new String[] { clsURI }, direction); + insLinkMap.put(key, insLink); + } + } + qexec.close(); + Collection values = insLinkMap.values(); + return values.toArray(new InstanceLink[0]); + } + + public LabelMap[] getLabels(String[] graphURIs, String[] resourceURIs, + String language) throws Exception { + if (resourceURIs == null || resourceURIs.length == 0) { + return new LabelMap[0]; + } + StringBuffer queryStr = new StringBuffer(); + queryStr.append("PREFIX owl: \n"); + queryStr.append("PREFIX rdfs: \n"); + queryStr.append("PREFIX rdf: \n"); + queryStr.append("SELECT DISTINCT ?res ?label \n"); + if (graphURIs != null) { + for (String graphURI : graphURIs) { + queryStr.append("FROM <"); + queryStr.append(graphURI); + queryStr.append(">\n"); + } + } + queryStr.append("WHERE{\n"); + queryStr.append(" ?res rdfs:label ?label.\n"); + queryStr.append(" FILTER(?res IN ("); + boolean f = false; + for (String resourceURI : resourceURIs) { + if (f) { + queryStr.append(", "); + } + f = true; + queryStr.append("<"); + queryStr.append(resourceURI); + queryStr.append(">"); + } + queryStr.append("))\n"); + queryStr.append("}"); + + System.out.println(queryStr.toString()); + + Query query = QueryFactory.create(queryStr.toString()); + QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI, + query); + + ResultSet results = qexec.execSelect(); + HashMap lMap = new HashMap(); + for (; results.hasNext();) { + QuerySolution sol = results.next(); + String uri = sol.getResource("res").getURI(); + Literal literal = sol.getLiteral("label"); + if (literal != null) { + String label = literal.getString(); + String lang = literal.getLanguage(); + if (language != null && language.equals(lang)) { + Label lbl = new Label(label, lang); + if (lMap.containsKey(uri)) { + LabelMap lm = lMap.get(uri); + lm.addLabel(lbl); + } else { + LabelMap lm = new LabelMap(uri, new Label[] { lbl }); + lMap.put(uri, lm); + } + } + } + } + return lMap.values().toArray(new LabelMap[0]); + } + + public ClassLink[] countLinks(String[] graphURIs, String startClassURI, + ClassLink[] classLinks) throws Exception { + if (classLinks == null || classLinks.length == 0) { + return new ClassLink[0]; + } + for (ClassLink classLink : classLinks) { + StringBuffer queryStr = new StringBuffer(); + queryStr.append("PREFIX owl: \n"); + queryStr.append("PREFIX rdfs: \n"); + queryStr.append("PREFIX rdf: \n"); + + queryStr.append("SELECT (COUNT(?os) AS ?numOfLinks) (COUNT(DISTINCT(?is)) AS ?numOfOriginInstances) (COUNT(DISTINCT(?os)) AS ?numOfLinkedInstances) \n"); + if (graphURIs != null) { + for (String graphURI : graphURIs) { + queryStr.append("FROM <"); + queryStr.append(graphURI); + queryStr.append(">\n"); + } + } + + queryStr.append("WHERE{\n"); + if (classLink.getDirection() == Direction.forward) { + queryStr.append("?is rdf:type <"); + queryStr.append(startClassURI); + queryStr.append(">.\n"); + queryStr.append("?os rdf:type <"); + queryStr.append(classLink.getLinkedClassURI()); + queryStr.append(">.\n"); + queryStr.append("?is <"); + queryStr.append(classLink.getPropertyURI()); + queryStr.append("> ?os.\n"); + queryStr.append("}"); + } else { + if (classLink.getDirection() == Direction.forward) { + queryStr.append("?os rdf:type <"); + queryStr.append(startClassURI); + queryStr.append(">.\n"); + queryStr.append("?is rdf:type <"); + queryStr.append(classLink.getLinkedClassURI()); + queryStr.append(">.\n"); + queryStr.append("?is <"); + queryStr.append(classLink.getPropertyURI()); + queryStr.append("> ?os.\n"); + queryStr.append("}"); + } else { + queryStr.append("?os rdf:type <"); + queryStr.append(startClassURI); + queryStr.append(">.\n"); + queryStr.append("?is rdf:type <"); + queryStr.append(classLink.getLinkedClassURI()); + queryStr.append(">.\n"); + queryStr.append("{?is <"); + queryStr.append(classLink.getPropertyURI()); + queryStr.append("> ?os.}\n"); + queryStr.append("UNION\n"); + queryStr.append("{?os <"); + queryStr.append(classLink.getPropertyURI()); + queryStr.append("> ?is.}\n"); + queryStr.append("}"); + } + } + System.out.println(queryStr.toString()); + + Query query = QueryFactory.create(queryStr.toString()); + QueryExecution qexec = QueryExecutionFactory.sparqlService( + endpointURI, query); + + ResultSet results = qexec.execSelect(); + if (results.hasNext()) { + QuerySolution sol = results.next(); + Literal lit = sol.getLiteral("numOfLinks"); + if (lit != null) { + int numOfLinks = lit.getInt(); + classLink.setNumOfLinks(numOfLinks); + } + lit = sol.getLiteral("numOfLinkedInstances"); + if (lit != null) { + int numOfLinkedInstances = lit.getInt(); + classLink.setNumOfLinkedInstances(numOfLinkedInstances); + } + lit = sol.getLiteral("numOfOriginInstances"); + if (lit != null) { + int numOfOriginInstances = lit.getInt(); + classLink.setNumOfOriginInstances(numOfOriginInstances); + } + lit = sol.getLiteral("numOfOriginClassInstances"); + if (lit != null) { + int numOfOriginClassInstances = lit.getInt(); + classLink + .setNumOfOriginClassInstances(numOfOriginClassInstances); + } + lit = sol.getLiteral("numOfLinkedClassInstances"); + if (lit != null) { + int numOfLinkedClassInstances = lit.getInt(); + classLink + .setNumOfLinkedClassInstances(numOfLinkedClassInstances); + } + } + qexec.close(); + + // count instances + queryStr = new StringBuffer(); + queryStr.append("PREFIX owl: \n"); + queryStr.append("PREFIX rdfs: \n"); + queryStr.append("PREFIX rdf: \n"); + + queryStr.append("SELECT (COUNT(?ics) AS ?numOfOriginClassInstances) \n"); + if (graphURIs != null) { + for (String graphURI : graphURIs) { + queryStr.append("FROM <"); + queryStr.append(graphURI); + queryStr.append(">\n"); + } + } + + queryStr.append("WHERE{\n"); + if (classLink.getDirection() == Direction.forward) { + queryStr.append("?ics rdf:type <"); + queryStr.append(startClassURI); + queryStr.append(">.\n"); + queryStr.append("}"); + } else { + if (classLink.getDirection() == Direction.forward) { + queryStr.append("?ics rdf:type <"); + queryStr.append(classLink.getLinkedClassURI()); + queryStr.append(">.\n"); + queryStr.append("}"); + } else { + queryStr.append("?ics rdf:type <"); + queryStr.append(classLink.getLinkedClassURI()); + queryStr.append(">.\n"); + queryStr.append("}"); + } + } + + System.out.println(queryStr.toString()); + + query = QueryFactory.create(queryStr.toString()); + qexec = QueryExecutionFactory.sparqlService(endpointURI, query); + + results = qexec.execSelect(); + if (results.hasNext()) { + QuerySolution sol = results.next(); + Literal lit = null; + lit = sol.getLiteral("numOfOriginClassInstances"); + if (lit != null) { + int numOfOriginClassInstances = lit.getInt(); + classLink + .setNumOfOriginClassInstances(numOfOriginClassInstances); + } + } + qexec.close(); + + // count instances + queryStr = new StringBuffer(); + queryStr.append("PREFIX owl: \n"); + queryStr.append("PREFIX rdfs: \n"); + queryStr.append("PREFIX rdf: \n"); + + queryStr.append("SELECT (COUNT(?ocs) AS ?numOfLinkedClassInstances) \n"); + if (graphURIs != null) { + for (String graphURI : graphURIs) { + queryStr.append("FROM <"); + queryStr.append(graphURI); + queryStr.append(">\n"); + } + } + + queryStr.append("WHERE{\n"); + if (classLink.getDirection() == Direction.forward) { + queryStr.append("?ocs rdf:type <"); + queryStr.append(classLink.getLinkedClassURI()); + queryStr.append(">.\n"); + queryStr.append("}"); + } else { + if (classLink.getDirection() == Direction.forward) { + queryStr.append("?ocs rdf:type <"); + queryStr.append(startClassURI); + queryStr.append(">.\n"); + queryStr.append("}"); + } else { + queryStr.append("?ocs rdf:type <"); + queryStr.append(startClassURI); + queryStr.append(">.\n"); + queryStr.append("}"); + } + } + + System.out.println(queryStr.toString()); + + query = QueryFactory.create(queryStr.toString()); + qexec = QueryExecutionFactory.sparqlService(endpointURI, query); + + results = qexec.execSelect(); + if (results.hasNext()) { + QuerySolution sol = results.next(); + Literal lit = null; + lit = sol.getLiteral("numOfLinkedClassInstances"); + if (lit != null) { + int numOfLinkedClassInstances = lit.getInt(); + classLink + .setNumOfLinkedClassInstances(numOfLinkedClassInstances); + } + } + qexec.close(); + + } + return classLinks; + } + + public SClass[] countInstances(String[] graphURIs, SClass[] classes) + throws Exception { + if (classes == null || classes.length == 0) { + return new SClass[0]; + } + HashMap classMap = new HashMap(); + for (SClass sc : classes) { + classMap.put(sc.getClassURI(), sc); + } + StringBuffer queryStr = new StringBuffer(); + queryStr.append("PREFIX owl: \n"); + queryStr.append("PREFIX rdfs: \n"); + queryStr.append("PREFIX rdf: \n"); + queryStr.append("SELECT DISTINCT ?cls (COUNT(?is) AS ?numOfInstances)\n"); + if (graphURIs != null) { + for (String graphURI : graphURIs) { + queryStr.append("FROM <"); + queryStr.append(graphURI); + queryStr.append(">\n"); + } + } + queryStr.append("WHERE{\n"); + queryStr.append(" ?is rdf:type ?cls.\n"); + queryStr.append(" FILTER(?cls IN ("); + boolean f = false; + Set clsSet = classMap.keySet(); + for (String clsURI : clsSet) { + if (f) { + queryStr.append(", "); + } + f = true; + queryStr.append("<"); + queryStr.append(clsURI); + queryStr.append(">"); + } + queryStr.append("))\n"); + queryStr.append("} GROUP BY ?cls"); + + System.out.println(queryStr.toString()); + + Query query = QueryFactory.create(queryStr.toString()); + QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI, + query); + + ResultSet results = qexec.execSelect(); + for (; results.hasNext();) { + QuerySolution sol = results.next(); + String uri = sol.getResource("cls").getURI(); + SClass sc = classMap.get(uri); + Literal lit = sol.getLiteral("numOfInstances"); + if (lit != null) { + int numOfInstances = lit.getInt(); + sc.setNumOfInstances(numOfInstances); + } + } + qexec.close(); + + return classes; + } + +} Index: SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/OWL/SClass.java =================================================================== --- SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/OWL/SClass.java (revision 267) +++ SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/OWL/SClass.java (revision 267) @@ -0,0 +1,84 @@ +package org.biohackathon.SPARQLBuilder.OWL; + +import java.util.HashSet; + +public class SClass { + + private String classURI; + private int numOfInstances; + private HashSet labels; + + /** + * 繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮURI縺ｨ縺昴�繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺悟ｱ槭＠縺ｦ縺�ｋ縺吶∋縺ｦ縺ｮ繧ｯ繝ｩ繧ｹ繧剃ｸ弱∴繧区ｧ区�蟄� + * + * @param instanceURI + * 縲繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮURI + * @param classURIs + * 縲蠖楢ｩｲ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺悟ｱ槭＠縺ｦ縺�ｋ縺吶∋縺ｦ縺ｮ繧ｯ繝ｩ繧ｹ縺ｮURI縺ｮ驟榊� + * @throws Exception + * @since 28.01.2014 + */ + public SClass(String classURI, Label[] labels, int numOfInstances) { + this.classURI = classURI; + this.numOfInstances = numOfInstances; + setLabels(labels); + } + + /** + * 譁�ｭ怜�陦ｨ險倥ｒ蜿門ｾ励☆繧� + * + * @since 28.01.2014 + */ + public String toString() { + StringBuffer sb = new StringBuffer(); + sb.append(classURI); + sb.append("["); + boolean f = false; + if (labels != null) { + for (Label label : labels) { + if (f) { + sb.append(", "); + } + f = true; + sb.append(label.toString()); + } + } + sb.append("], "); + sb.append(numOfInstances); + return sb.toString(); + } + + public final String getClassURI() { + return classURI; + } + + public final void setClassURI(String classURI) { + this.classURI = classURI; + } + + public final int getNumOfInstances() { + return numOfInstances; + } + + public final void setNumOfInstances(int numOfInstances) { + this.numOfInstances = numOfInstances; + } + + public final Label[] getLabels() { + return labels.toArray(new Label[0]); + } + + public final void setLabels(Label[] labelArrays) { + labels = new HashSet(); + if (labelArrays != null) { + for (Label label : labelArrays) { + labels.add(label); + } + } + } + + public void addLabel(Label label) { + labels.add(label); + } + +} Index: SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/OWL/QueryPathGenerator.java =================================================================== --- SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/OWL/QueryPathGenerator.java (revision 267) +++ SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/OWL/QueryPathGenerator.java (revision 267) @@ -0,0 +1,223 @@ +/* + * To change this license header, choose License Headers in Project Properties. + * To change this template file, choose Tools | Templates + * and open the template in the editor. + */ + +package org.biohackathon.SPARQLBuilder.OWL; + +import java.io.*; +import java.util.*; + +/** + * + * @author atsuko + */ + +public class QueryPathGenerator { + //private String sparqlEndpoint = null; + private RDFSchemaAnalyzerFactory factory = null; + //private RDFSchemaAnalyzer analyzer = null; + private HashMap analyzers = null; + private OWLClassGraph graph; + + private Map clabels; + + private static final String CDIR = "cdata"; + private static final String ODIR = "owldata"; + + public QueryPathGenerator(){ + factory = new RDFSchemaAnalyzerFactory(CDIR); + } + + /* + public QueryPathGenerator(String sparqlEndpoint){ + factory = new RDFSchemaAnalyzerFactory(CDIR); + setSPARQLendpoint(sparqlEndpoint); + } + */ + + /*public void setOWLClassGraph(String startClass){ + graph = new OWLClassGraph(analyzer, sparqlEndpoint, startClass); + }*/ + + public SClass[] getClassesByEndpoint(String ep){ + RDFSchemaAnalyzer analyzer = analyzers.get(ep); + try { + return analyzer.getOWLClasses(null, null, null, true); + }catch(Exception e){ + System.err.println(e); + return null; + } + } + + public SClass[] getClasses(String keyword){ + return getClassList(keyword).toArray(new SClass[0]); + } + + public List getClassList(String keyword){ + Iterator ait = analyzers.values().iterator(); + List cl = new LinkedList(); + try { + while ( ait.hasNext() ){ + RDFSchemaAnalyzer analyzer = ait.next(); + cl.addAll(analyzer.getOWLClassList(null, null, null, true)); + } + }catch(Exception e){ + System.err.println(e); + return null; + } + return cl; + } + + public Path[] getPaths(String startClass, String endClass){ + if (startClass == null || endClass == null){ + return null; + } + if ( graph == null ){ + //setOWLClassGraph(startClass); + } + return graph.getPaths(startClass, endClass); + } + + /* + public void setSPARQLendpoint(String sparqlEndpoint){ + this.sparqlEndpoint = sparqlEndpoint; + setAnalyzer(); + } + */ + + public RDFSchemaAnalyzerFactory getFactory(){ + return factory; + } + + /* + private void setAnalyzer(){ + try { + analyzer = factory.create(sparqlEndpoint); + } catch (Exception e) { + System.err.println(e); + } + } + */ + + public String getClassLabel(String classURI){ + return clabels.get(classURI); + } + + public void setClassLabels(SClass[] classes){ + clabels = new HashMap(); + Map extLabels = getClassLabelsFromExternal(); + + for ( int i = 0 ; i < classes.length; i++ ){ + String classURI = classes[i].getClassURI(); + + Label[] labels = classes[i].getLabels(); + String label = null; + for ( int j = 0 ; j < labels.length; j++ ){ + if ( labels[j].getLanguage() == null ){ + label = labels[j].getLabel(); + break; + }else if ( labels[j].getLanguage().equals("en") || labels[j].getLanguage().equals("") ){ + label = labels[j].getLabel(); + break; + } + } + if ( label == null ){ + label = extLabels.get(classURI); + } + if ( label == null ){ + String[] uris = classURI.split("/"); + String tmplabel = uris[uris.length-1]; + String[] tmplabel2 = tmplabel.split("#"); + label = tmplabel2[tmplabel2.length-1]; + } + clabels.put(classURI, label); + } + } + + public static String getClassLabelfromList(String classURI, SClass[] classes){ + if ( classURI == null ){ + return ""; + } + SClass sclass = null; + for ( int i = 0 ; i < classes.length; i++ ){ + if ( classURI.equals(classes[i].getClassURI()) ){ + return getClassLabelfromClass(classes[i]); + } + } + return ""; + } + + public static String getClassLabelfromClass(SClass sclass){ + Label[] labels = sclass.getLabels(); + for ( int i = 0 ; i < labels.length; i++ ){ + if ( labels[i].getLanguage() == null ){ + return labels[i].getLabel(); + }else if ( labels[i].getLanguage().equals("en") ){ + return labels[i].getLabel(); + } + } + String[] url = sclass.getClassURI().split("/"); + String tmplabel = url[url.length-1]; + String[] tmplabel2 = tmplabel.split("#"); + String label = tmplabel2[tmplabel2.length-1]; + return label; + } + + public Map getClassLabelsFromExternal(){ + return OWLLabelReader.readLabels(ODIR); + } + + public OWLClassGraph getOWLClassGraph(){ + /*if ( graph == null ){ + graph = new OWLClassGraph(analyzer); + }*/ + return graph; + } + + /* + public SClass[] getReachableClasses(){ + List clURIs = graph.getReachableClasses(); + SClass[] orgclasses = null; + try { + orgclasses = analyzer.getOWLClasses(null, null, null, true); + }catch( Exception e ){ + System.err.println(e); + return null; + } + HashMap orgmap = new HashMap(); + for (int i = 0; i < orgclasses.length; i++ ){ + orgmap.put(orgclasses[i].getClassURI(), orgclasses[i]); + } + + SClass[] classes = new SClass[clURIs.size()]; + int j = 0; + ListIterator uit = clURIs.listIterator(); + while(uit.hasNext()){ + String u = uit.next(); + SClass cl = orgmap.get(u); + classes[j] = cl; + j++; + } + return classes; + } + */ + + public SortedSet getSortedClasses(SClass[] classes){ + setClassLabels(classes); + SortedSet sortedClasses = new TreeSet(); + for (int i = 0 ; i < classes.length; i++ ){ + String uri = classes[i].getClassURI(); + String label = getClassLabel(uri); + StringBuilder classbuilder = new StringBuilder(label); + classbuilder.append(" "); + classbuilder.append(classes[i].getNumOfInstances()); + classbuilder.append(" "); + classbuilder.append(uri); + sortedClasses.add(classbuilder.toString()); + } + + return sortedClasses; + } +} Index: SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/OWL/RDFSchemaAnalyzerFactory.java =================================================================== --- SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/OWL/RDFSchemaAnalyzerFactory.java (revision 267) +++ SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/OWL/RDFSchemaAnalyzerFactory.java (revision 267) @@ -0,0 +1,63 @@ +package org.biohackathon.SPARQLBuilder.OWL; + +import java.io.File; +import java.util.HashMap; +import java.util.Map; + +import org.biohackathon.SPARQLBuilder.endpointMetadata.MetadataFile; +import org.biohackathon.SPARQLBuilder.endpointMetadata.MetadataManager; + +import jp.riken.accc.db.rdf.crawler.dataStructure.sparql.JenaModelGenerator; + +public class RDFSchemaAnalyzerFactory { + + private MetadataManager metadataManager = null; +// private Map acquiredRDFFiles = null; + private static final String FILENAME = "C:\\cdata"; + + public RDFSchemaAnalyzerFactory(String fileName){ + try{ + metadataManager = new MetadataManager(fileName); +// setAcqiredRDFFiles(new File(fileName)); + }catch(Exception e){ + System.err.println(e); + } + } + + public RDFSchemaAnalyzerFactory(){ + try{ + metadataManager = new MetadataManager(FILENAME); +// setAcqiredRDFFiles(new File(FILENAME)); + }catch(Exception e){ + System.err.println(e); + } + } + +// private void setAcqiredRDFFiles(String dirFile) throws Exception{ +// setAcqiredRDFFiles(new File(dirFile)); +// } + +// private void setAcqiredRDFFiles(File data) throws Exception{ +// StructureCrawler sc = new StructureCrawler(data); +// acquiredRDFFiles = sc.getAcquiredStructureFiles(); +// } + + public String[] getEndpointURIList(){ + return metadataManager.getURIList(); + } + + public MetadataFile[] getMetadataFiles(){ + return metadataManager.getMetadataFiles(); + } + + + public RDFSchemaAnalyzer create(String uri) throws Exception{ + MetadataFile mFile = metadataManager.getMetadataFile(uri); + if( mFile == null ){ + return new EndpointAnalyzer(uri); + }else{ + JenaModelGenerator jmGene = new JenaModelGenerator(mFile.getFilePath()); + return new AcquiredStructureAnalyzer(jmGene.getEndpointURI(), jmGene.getGraphURIs(), jmGene.getModel()); + } + } +} Index: SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/OWL/Path.java =================================================================== --- SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/OWL/Path.java (revision 267) +++ SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/OWL/Path.java (revision 267) @@ -0,0 +1,164 @@ +package org.biohackathon.SPARQLBuilder.OWL; + +import java.util.*; + +import org.json.JSONArray; +import org.json.JSONException; +import org.json.JSONObject; + +/** + * 襍ｷ轤ｹ縺ｨ縺ｪ繧九Μ繧ｽ繝ｼ繧ｹ縺九ｉ騾先ｬ｡逧�↓隍�焚繝ｪ繝ｳ繧ｯ縺ｧ邨らせ繝ｪ繧ｽ繝ｼ繧ｹ縺ｾ縺ｧ謗･邯壹＆繧後ｋ荳縺､縺ｮ繝代せ繧定ｨ倩ｿｰ縺吶ｋ + * + * @author Yamaguchi + * @since 28.01.2014 + * @version 29.01.2014 + */ +public class Path implements Comparable{ + + /** + * 繝代せ縺ｮ襍ｷ轤ｹ縺ｨ縺ｪ繧九け繝ｩ繧ｹ縺ｮURI + */ + private String startClass; + private int width; + + /** + * 繝代せ縺ｮ襍ｷ轤ｹ縺九ｉ邨らせ縺ｫ蜷代°縺｣縺ｦ騾先ｬ｡逧�↓縺､縺ｪ縺後ｋ繧ｯ繝ｩ繧ｹ髢薙Μ繝ｳ繧ｯ縺ｮ繝ｪ繧ｹ繝� + */ + private List classLinks; + + public JSONObject toJSON() { + JSONObject obj = new JSONObject(); + try { + obj.put("startClassURI", startClass); + obj.put("width", width); + if (classLinks != null && classLinks.size() != 0) { + JSONArray array = new JSONArray(); + for (int i = 0; i < classLinks.size(); i++) { + array.put(classLinks.get(i).toJSON()); + } + obj.put("classLinks", array); + } + } catch (JSONException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + System.out.println(e.toString()); + } + return obj; + } + + public String toJSONString(){ + return toJSON().toString(); + } + + public String toJSONString2(){ + String json_str=""; + json_str+="{\"startClassURI\":\""+ startClass+"\","; + //json_str+="\"width\":"+width+","; + + if (classLinks != null && classLinks.size() != 0) { + json_str+="\"classLinks\":["; + + JSONObject[] classLinkObjs = new JSONObject[classLinks.size()]; + for (int i = 0; i < classLinks.size(); i++) { + if(i>0){json_str += "," ;} + json_str+= classLinks.get(i).toJSONString2(); + } + json_str+="]"; + } + json_str+="}"; + + return json_str; + } + + public String toJSONString3(SClass[] classes){ + String json_str=""; + //json_str+="{\"startClassURI\":\""+ startClass+"\","; + //json_str+="\"startClassLabel\":\""+QueryPathGenerator.getClassLabelfromList(startClass, classes)+"\","; + json_str+="{\"startClass\":\""+ startClass+"\","; + // label + json_str+="\"label\":\""+QueryPathGenerator.getClassLabelfromList(startClass, classes)+"\","; + if (classLinks != null && classLinks.size() != 0) { + json_str+="\"classLinks\":["; + + JSONObject[] classLinkObjs = new JSONObject[classLinks.size()]; + for (int i = 0; i < classLinks.size(); i++) { + if(i>0){json_str += "," ;} + json_str+= classLinks.get(i).toJSONString3(classes); + } + json_str+="]"; + } + json_str += ","; + json_str +="\"score\":\""+width+"\""; + json_str +="}"; + + return json_str; + } + + public String toJSONString4(QueryPathGenerator qpg){ + String json_str=""; + json_str+="{\"startClass\":\""+ startClass+"\","; + // label + json_str+="\"label\":\""+qpg.getClassLabel(startClass)+"\","; + if (classLinks != null && classLinks.size() != 0) { + json_str+="\"classLinks\":["; + + JSONObject[] classLinkObjs = new JSONObject[classLinks.size()]; + for (int i = 0; i < classLinks.size(); i++) { + if(i>0){json_str += "," ;} + json_str+= classLinks.get(i).toJSONString4(qpg); + } + json_str+="]"; + } + json_str += ","; + json_str +="\"score\":\""+width+"\""; + json_str +="}"; + + return json_str; + } + + public String getStartClass() { + return startClass; + } + + /* + * public String[] getProperties(){ return properties; } + * + * public String[] getObjectClasses(){ return objectClasses; } + * + * public Direction[] getDirections(){ return directions; } + */ + public List getClassLinks() { + return classLinks; + } + + public int getWidth() { + return width; + } + + public Path() { + } + + public Path(String startClass, List classLinks, int width) { + this.startClass = startClass; + this.classLinks = classLinks; + this.width = width; + } + + public void setStartClass(String startClass) { + this.startClass = startClass; + } + + public void setClassLinks(List classLinks) { + this.classLinks = classLinks; + } + + public void setWidth(int width) { + this.width = width; + } + + @Override + public int compareTo(Path path) { + return this.width - path.getWidth() ; + //throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates. + } +} Index: SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/endpointMetadata/MetadataFile.java =================================================================== --- SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/endpointMetadata/MetadataFile.java (revision 267) +++ SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/endpointMetadata/MetadataFile.java (revision 267) @@ -0,0 +1,393 @@ +package org.biohackathon.SPARQLBuilder.endpointMetadata; + +import java.io.File; +import java.util.ArrayList; +import java.util.Calendar; + +import jp.riken.accc.db.rdf.crawler.dataStructure.sparql.URICollection; + +import org.apache.jena.riot.RDFDataMgr; + +import com.hp.hpl.jena.rdf.model.Literal; +import com.hp.hpl.jena.rdf.model.Model; +import com.hp.hpl.jena.rdf.model.NodeIterator; +import com.hp.hpl.jena.rdf.model.Property; +import com.hp.hpl.jena.rdf.model.RDFNode; +import com.hp.hpl.jena.rdf.model.ResIterator; +import com.hp.hpl.jena.rdf.model.Resource; + +public class MetadataFile { + + Model model = null; + File path = null; + String endpointURI = null; + Calendar startDateTime = null; + Calendar endDateTime = null; + long numTriples = 0; + long numClasses = 0; + + + public long getNumTriples(){ + return numTriples; + } + + public long getNumClasses(){ + return numClasses; + } + + public MetadataFile(File file) throws Exception{ + readFile(file); + this.path = file; + } + + public String getFilePath(){ + return path.getAbsolutePath(); + } + + public String getEndpointURI(){ + return endpointURI; + } + + public Calendar getStartDateTime(){ + return startDateTime; + } + + public Calendar getEndDateTime(){ + return endDateTime; + } + + + //TODO + public static boolean validate(File file) throws Exception{ + Model tmpModel = RDFDataMgr.loadModel(file.getAbsolutePath()); + String endpointURI = getEndpointURI(tmpModel); + + //TODO + return true; + } + + + public static Resource getDefaultDataset(Model model) throws Exception{ + Property sd_default_dataset = model.getProperty(URICollection.PROPERTY_SD_DEFAULT_DATA_SET); + NodeIterator nit = model.listObjectsOfProperty(sd_default_dataset); + Resource defaultDataSet = null; + if( nit.hasNext() ){ + RDFNode node = nit.next(); + defaultDataSet = node.asResource(); + } + return defaultDataSet; + } + + + public static long getTriples(Resource defaultDataset) throws Exception{ + // numTriples + Model model = defaultDataset.getModel(); + Property void_triples = model.getProperty(URICollection.PROPERTY_VOID_TRIPLES); + NodeIterator nit = model.listObjectsOfProperty(defaultDataset, void_triples); + long numTriples = 0; + if( nit.hasNext()){ + Literal numTriplesLit = nit.next().asLiteral(); + numTriples = numTriplesLit.getLong(); + } + return numTriples; + } + + + public static long getProperties(Resource defaultDataset) throws Exception{ + Model model = defaultDataset.getModel(); + Property void_properties = model.getProperty(URICollection.PROPERTY_VOID_PROPERTIES); + NodeIterator nit = model.listObjectsOfProperty(defaultDataset, void_properties); + long numProperties = 0; + if( nit.hasNext()){ + Literal numPropertiesLit = nit.next().asLiteral(); + numProperties = numPropertiesLit.getLong(); + } + return numProperties; + } + + + public static long getClasses(Resource defaultDataset) throws Exception{ + Model model = defaultDataset.getModel(); + Property void_classes = model.getProperty(URICollection.PROPERTY_VOID_CLASSES); + NodeIterator nit = model.listObjectsOfProperty(defaultDataset, void_classes); + long numClasses = 0; + if( nit.hasNext()){ + Literal numClassesLit = nit.next().asLiteral(); + numClasses = numClassesLit.getLong(); + } + return numClasses; + } + + + public static long getDatatypes(Resource defaultDataset) throws Exception{ + Model model = defaultDataset.getModel(); + Property sbm_datatypes = model.getProperty(URICollection.PROPERTY_SB_DATATYPES); + NodeIterator nit = model.listObjectsOfProperty(defaultDataset, sbm_datatypes); + long numDatatypes = 0; + if( nit.hasNext()){ + Literal numDatatypesLit = nit.next().asLiteral(); + numDatatypes = numDatatypesLit.getLong(); + } + return numDatatypes; + } + + + public static long getEndpointCategory(Resource defaultDataset) throws Exception{ + Model model = defaultDataset.getModel(); + Property sbm_endpointCategory = model.getProperty(URICollection.PROPERTY_SB_ENDPOINT_CATEGORY); + NodeIterator nit = model.listObjectsOfProperty(defaultDataset, sbm_endpointCategory); + long endpointCategory = 0; + if( nit.hasNext()){ + Literal endpointCategoryLit = nit.next().asLiteral(); + endpointCategory = endpointCategoryLit.getLong(); + } + return endpointCategory; + } + + public static long getPropertyategory(Resource defaultDataset) throws Exception{ + Model model = defaultDataset.getModel(); + Property sbm_propertyCategory = model.getProperty(URICollection.PROPERTY_SB_PROPERTY_CATEGORY); + NodeIterator nit = model.listObjectsOfProperty(defaultDataset, sbm_propertyCategory); + long propertyCategory = 0; + if( nit.hasNext()){ + Literal propertyCategoryLit = nit.next().asLiteral(); + propertyCategory = propertyCategoryLit.getLong(); + } + return propertyCategory; + } + + + public static long getClassCategory(Resource defaultDataset) throws Exception{ + Model model = defaultDataset.getModel(); + Property sbm_classCategory = model.getProperty(URICollection.PROPERTY_SB_CLASS_CATEGORY); + NodeIterator nit = model.listObjectsOfProperty(defaultDataset, sbm_classCategory); + long classCategory = 0; + if( nit.hasNext()){ + Literal classCategoryLit = nit.next().asLiteral(); + classCategory = classCategoryLit.getLong(); + } + return classCategory; + } + + + public static Resource[] getPropertyPartitions(Resource defaultDataset) throws Exception{ + Model model = defaultDataset.getModel(); + Property void_propertyPartition = model.getProperty(URICollection.PROPERTY_VOID_PROPERTY_PARTITION); + NodeIterator nit = model.listObjectsOfProperty(defaultDataset, void_propertyPartition); + ArrayList propertyPartitions = new ArrayList(); + if( nit.hasNext()){ + Resource propertyPartition = nit.next().asResource(); + propertyPartitions.add(propertyPartition); + } + return propertyPartitions.toArray(new Resource[0]); + } + + public static Resource[] getClassPartitions(Resource defaultDataset) throws Exception{ + Model model = defaultDataset.getModel(); + Property void_classPartition = model.getProperty(URICollection.PROPERTY_VOID_CLASS_PARTITION); + NodeIterator nit = model.listObjectsOfProperty(defaultDataset, void_classPartition); + ArrayList classPartitions = new ArrayList(); + if( nit.hasNext()){ + Resource classPartition = nit.next().asResource(); + classPartitions.add(classPartition); + } + return classPartitions.toArray(new Resource[0]); + } + + public static Resource[] getNamedGraphs(Resource defaultDataset) throws Exception{ + Model model = defaultDataset.getModel(); + Property sd_namedGraph = model.getProperty(URICollection.PROPERTY_SD_NAMED_GRAPH); + NodeIterator nit = model.listObjectsOfProperty(defaultDataset, sd_namedGraph); + ArrayList namedGraphs = new ArrayList(); + if( nit.hasNext()){ + Resource namedGraph = nit.next().asResource(); + namedGraphs.add(namedGraph); + } + return namedGraphs.toArray(new Resource[0]); + } + + public static String getName(Resource namedGraph) throws Exception{ + Model model = namedGraph.getModel(); + Property sd_name = model.getProperty(URICollection.PROPERTY_SD_NAME); + NodeIterator nit = model.listObjectsOfProperty(namedGraph, sd_name); + String name = null; + if( nit.hasNext()){ + Literal nameLit = nit.next().asLiteral(); + name = nameLit.getString(); + } + return name; + } + + public static Resource[] getPropertyCategorySubsets(Resource defaultDataset) throws Exception{ + Model model = defaultDataset.getModel(); + Property void_propertyCategorySubset = model.getProperty(URICollection.PROPERTY_SB_PROPERTY_CATEGORY_SUBSET); + NodeIterator nit = model.listObjectsOfProperty(defaultDataset, void_propertyCategorySubset); + ArrayList propertyCategorySubsets = new ArrayList(); + if( nit.hasNext()){ + Resource propertyCategorySubset = nit.next().asResource(); + propertyCategorySubsets.add(propertyCategorySubset); + } + return propertyCategorySubsets.toArray(new Resource[0]); + } + + public static Property[] getProperties(Model model) throws Exception{ + Resource rdf_property = model.getResource(URICollection.CLASS_RDF_PROPERTY); + Property rdf_type = model.getProperty(URICollection.PROPERTY_RDF_TYPE); + ResIterator rit = model.listSubjectsWithProperty(rdf_type, rdf_property); + ArrayList properties = new ArrayList(); + if( rit.hasNext()){ + String propertyURI = rit.next().getURI(); + Property property = model.getProperty(propertyURI); + properties.add(property); + } + return properties.toArray(new Property[0]); + } + + + public static Resource[] getClasses(Model model) throws Exception{ + Resource rdfs_class = model.getResource(URICollection.RESOURCE_RDFS_CLASS); + Property rdf_type = model.getProperty(URICollection.PROPERTY_RDF_TYPE); + ResIterator rit = model.listSubjectsWithProperty(rdf_type, rdfs_class); + ArrayList classes = new ArrayList(); + if( rit.hasNext()){ + Resource classRes = rit.next(); + classes.add(classRes); + } + return classes.toArray(new Resource[0]); + } + + public static Resource[] getClassRelations(Resource propertyPartition) throws Exception{ + Model model = propertyPartition.getModel(); + Property sbm_classRelation = model.getProperty(URICollection.PROPERTY_SB_CLASS_RELATION); + NodeIterator nit = model.listObjectsOfProperty(propertyPartition, sbm_classRelation); + ArrayList classRelations = new ArrayList(); + if( nit.hasNext()){ + Resource classRelation = nit.next().asResource(); + classRelations.add(classRelation); + } + return classRelations.toArray(new Resource[0]); + } + + public static String getEndpointURI(Model model) throws Exception{ + Property sd_endpoint = model.getProperty(URICollection.PROPERTY_SD_ENDPOINT); + NodeIterator nit = model.listObjectsOfProperty(sd_endpoint); + Resource endPointRes = null; + String endpointURI = null; + if( nit.hasNext() ){ + RDFNode endPointNode = nit.next(); + endPointRes = endPointNode.asResource(); + endpointURI = endPointRes.getURI(); + } + return endpointURI; + } + + + private Resource getCrawlLogBlankNode(Resource defaultDataset) throws Exception { + Model model = defaultDataset.getModel(); + // log + Property sbm_crawlLog = model.getProperty(URICollection.PROPERTY_SB_CRAWL_LOG); + NodeIterator nit = model.listObjectsOfProperty(sbm_crawlLog); + Resource crawlLogBlankNode = null; + if( nit.hasNext() ){ + RDFNode node = nit.next(); + crawlLogBlankNode = node.asResource(); + } + return crawlLogBlankNode; + } + + private Calendar getStartTime(Resource crawlLogBlankNode) throws Exception{ + Model model = crawlLogBlankNode.getModel(); + Property sbm_startTime = model.getProperty(URICollection.PROPERTY_SB_CRAWL_START_TIME); + NodeIterator nit = model.listObjectsOfProperty(sbm_startTime); + Calendar startCal = null; + if( nit.hasNext() ){ + Literal startTimeLit = null; + RDFNode node = nit.next(); + startTimeLit = node.asLiteral(); + startCal = ((com.hp.hpl.jena.datatypes.xsd.XSDDateTime)(startTimeLit.getValue())).asCalendar(); + } + return startCal; + } + + private Calendar getEndTime(Resource crawlLogBlankNode) throws Exception{ + Model model = crawlLogBlankNode.getModel(); + Property sbm_endTime = model.getProperty(URICollection.PROPERTY_SB_CRAWL_END_TIME); + NodeIterator nit = model.listObjectsOfProperty(sbm_endTime); + Calendar endCal = null; + if( nit.hasNext() ){ + Literal endTimeLit = null; + RDFNode node = nit.next(); + endTimeLit = node.asLiteral(); + endCal = ((com.hp.hpl.jena.datatypes.xsd.XSDDateTime)(endTimeLit.getValue())).asCalendar(); + } + return endCal; + } + + + + + private void readFile(File file) throws Exception{ + System.out.println("readfile: " + file.getAbsolutePath()); + model = RDFDataMgr.loadModel(file.getAbsolutePath()); + Property sd_endpoint = model.getProperty(URICollection.PROPERTY_SD_ENDPOINT); + NodeIterator nit = model.listObjectsOfProperty(sd_endpoint); + Resource endPointRes = null; + endpointURI = null; + if( nit.hasNext() ){ + RDFNode endPointNode = nit.next(); + endPointRes = endPointNode.asResource(); + endpointURI = endPointRes.getURI(); + } + + Property sd_default_dataset = model.getProperty(URICollection.PROPERTY_SD_DEFAULT_DATA_SET); + nit = model.listObjectsOfProperty(sd_default_dataset); + Resource defaultDataSet = null; + if( nit.hasNext() ){ + RDFNode node = nit.next(); + defaultDataSet = node.asResource(); + } + // log + Property sbm_crawlLog = model.getProperty(URICollection.PROPERTY_SB_CRAWL_LOG); + nit = model.listObjectsOfProperty(sbm_crawlLog); + Resource crawlLogBlankNode = null; + if( nit.hasNext() ){ + RDFNode node = nit.next(); + crawlLogBlankNode = node.asResource(); + } + // start + Property sbm_startTime = model.getProperty(URICollection.PROPERTY_SB_CRAWL_START_TIME); + nit = model.listObjectsOfProperty(sbm_startTime); + startDateTime = null; + if( nit.hasNext() ){ + Literal startTimeLit = null; + RDFNode node = nit.next(); + startTimeLit = node.asLiteral(); + startDateTime = ((com.hp.hpl.jena.datatypes.xsd.XSDDateTime)(startTimeLit.getValue())).asCalendar(); + } + // end + Property sbm_endTime = model.getProperty(URICollection.PROPERTY_SB_CRAWL_END_TIME); + nit = model.listObjectsOfProperty(sbm_endTime); + endDateTime = null; + if( nit.hasNext() ){ + Literal endTimeLit = null; + RDFNode node = nit.next(); + endTimeLit = node.asLiteral(); + endDateTime = ((com.hp.hpl.jena.datatypes.xsd.XSDDateTime)(endTimeLit.getValue())).asCalendar(); + } + // numTriples + Property void_triples = model.getProperty(URICollection.PROPERTY_VOID_TRIPLES); + nit = model.listObjectsOfProperty(defaultDataSet, void_triples); + if( nit.hasNext()){ + Literal numTriplesLit = nit.next().asLiteral(); + numTriples = numTriplesLit.getLong(); + } + // numClasses + Property void_classes = model.getProperty(URICollection.PROPERTY_VOID_CLASSES); + nit = model.listObjectsOfProperty(defaultDataSet, void_classes); + if( nit.hasNext()){ + Literal numClassesLit = nit.next().asLiteral(); + numClasses = numClassesLit.getLong(); + } + } + +} Index: SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/endpointMetadata/MetadataManager.java =================================================================== --- SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/endpointMetadata/MetadataManager.java (revision 267) +++ SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/endpointMetadata/MetadataManager.java (revision 267) @@ -0,0 +1,82 @@ +package org.biohackathon.SPARQLBuilder.endpointMetadata; + +import java.io.File; +import java.util.HashMap; +import java.util.Set; + +public class MetadataManager { + + HashMap metadataTable = null; + + /* + public static void main(String[] args) throws Exception{ + String dirStr = "c:\\temp\\crawl"; + MetadataManager manager = new MetadataManager(dirStr); + String[] uris = manager.getURIList(); + for(String uri: uris){ + System.out.println(uri); + MetadataFile mFile = manager.getMetadataFile(uri); + System.out.println(mFile.getStartDateTime().getTime().toString()); + System.out.println(mFile.getEndDateTime().getTime().toString()); + } + }*/ + + public MetadataFile[] getMetadataFiles(){ + return metadataTable.values().toArray(new MetadataFile[0]); + } + public MetadataFile getMetadataFile(String uri){ + return metadataTable.get(uri); + } + + public String[] getURIList(){ + Set keySet = metadataTable.keySet(); + return keySet.toArray(new String[0]); + } + + + public MetadataManager(String metadataDirStr) throws Exception { + init(metadataDirStr); + } + + + public void init(String metadataDirStr) throws Exception{ + metadataTable = new HashMap(); + File metadataDir = new File(metadataDirStr); + File[] files = null; + if( metadataDir.exists() ){ + if( metadataDir.isFile()){ + files = new File[]{metadataDir}; + }else{ + if( metadataDir.isDirectory()){ + files = metadataDir.listFiles(); + }else{ + throw new Exception("Inernal File/Directory error: " + metadataDirStr); + } + } + }else{ + throw new Exception("File/Directory not found: " + metadataDirStr); + } + for(File file: files){ + MetadataFile metadataFile = null; + try{ + metadataFile = new MetadataFile(file); + String uri = metadataFile.getEndpointURI(); + if( uri != null ){ + if( metadataTable.containsKey(uri)){ + MetadataFile tempMF = metadataTable.get(uri); + if(tempMF.getEndDateTime().before(metadataFile.getEndDateTime()) ){ + metadataTable.remove(uri); + metadataTable.put(uri, metadataFile); + } + }else{ + metadataTable.put(uri, metadataFile); + } + } + }catch(Exception ex){ + // WARNING + System.out.println("Invalid metadata file: " + file.getAbsolutePath()); + ex.printStackTrace(); + } + } + } +} Index: SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/www/PLServlet.java =================================================================== --- SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/www/PLServlet.java (revision 267) +++ SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/www/PLServlet.java (revision 267) @@ -0,0 +1,139 @@ +/* + * To change this license header, choose License Headers in Project Properties. + * To change this template file, choose Tools | Templates + * and open the template in the editor. + */ + +package org.biohackathon.SPARQLBuilder.www; + +import java.io.IOException; +import java.io.PrintWriter; +import javax.servlet.ServletException; +import javax.servlet.annotation.WebServlet; +import javax.servlet.http.HttpServlet; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import javax.servlet.http.HttpSession; +import org.biohackathon.SPARQLBuilder.OWL.*; + +/** + * + * @author atsuko + */ +@WebServlet(name = "PLServlet", urlPatterns = {"/plist"}) +public class PLServlet extends HttpServlet { + + private static final String FILENAME = "cdata/"; + + /** + * Processes requests for both HTTP GET and POST + * methods. + * + * @param request servlet request + * @param response servlet response + * @throws ServletException if a servlet-specific error occurs + * @throws IOException if an I/O error occurs + */ + protected void processRequest(HttpServletRequest request, HttpServletResponse response) + throws ServletException, IOException { + response.setContentType("text/html;charset=UTF-8"); + try (PrintWriter out = response.getWriter()) { + /* TODO output your page here. You may use following sample code. */ + out.println(""); + out.println(""); + out.println(""); + out.println("Servlet PLServlet"); + out.println(""); + out.println(""); + out.println("Servlet PLServlet at " + request.getContextPath() + ""); + out.println(""); + out.println(""); + } + } + + // + /** + * Handles the HTTP GET method. + * + * @param request servlet request + * @param response servlet response + * @throws ServletException if a servlet-specific error occurs + * @throws IOException if an I/O error occurs + */ + @Override + protected void doGet(HttpServletRequest request, HttpServletResponse response) + throws ServletException, IOException { + //processRequest(request, response); + response.setContentType("application/json;charset=UTF-8"); + response.setHeader("Access-Control-Allow-Origin", "*"); + response.setHeader("Access-Control-Allow-Methods", "GET"); + response.setHeader("Access-Control-Allow-Headers", request.getHeader("Access-Control-Request-Headers")); + response.setHeader("Access-Control-Max-Age", "-1"); + PrintWriter out = response.getWriter(); + String ep = request.getParameter("ep"); + String st = request.getParameter("startclass"); + String en = request.getParameter("endclass"); + //String ask = request.getParameter("ask"); + + // String + String uri = request.getQueryString(); + System.out.println(uri); + + HttpSession session = request.getSession(); + //QueryPathGenerator qpg = (QueryPathGenerator)session.getAttribute("qpg"); + //if ( qpg == null ){ + QueryPathGenerator qpg = new QueryPathGenerator(ep); + //} + SClass[] classes = qpg.getClasses(null); + qpg.setClassLabels(classes); + + Path[] paths = null; + paths = qpg.getPaths(st, en); + if ( paths == null ){ + out.print(" "); + }else{ + String jsonstr = "["; + for(int i = 0; i< paths.length; i++){ + if (i > 0 && paths[i] != null){ + jsonstr += ","; + } + if ( paths[i] == null ){ + continue; + } + jsonstr += paths[i].toJSONString4(qpg); + } + jsonstr += "]"; + // For debug + /* + System.out.println("JSON:"); + System.out.println(jsonstr); + */ + out.print(jsonstr); + } + } + + /** + * Handles the HTTP POST method. + * + * @param request servlet request + * @param response servlet response + * @throws ServletException if a servlet-specific error occurs + * @throws IOException if an I/O error occurs + */ + @Override + protected void doPost(HttpServletRequest request, HttpServletResponse response) + throws ServletException, IOException { + processRequest(request, response); + } + + /** + * Returns a short description of the servlet. + * + * @return a String containing servlet description + */ + @Override + public String getServletInfo() { + return "Short description"; + }// + +} Index: SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/www/CLServlet.java =================================================================== --- SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/www/CLServlet.java (revision 267) +++ SPARQLBuilderWWW2016/src/java/org/biohackathon/SPARQLBuilder/www/CLServlet.java (revision 267) @@ -0,0 +1,180 @@ +/* + * To change this license header, choose License Headers in Project Properties. + * To change this template file, choose Tools | Templates + * and open the template in the editor. + */ + +package org.biohackathon.SPARQLBuilder.www; + +import java.io.IOException; +import java.io.PrintWriter; +import java.math.BigDecimal; +import java.util.*; +import javax.json.*; +import javax.servlet.ServletException; +import javax.servlet.annotation.WebServlet; +import javax.servlet.http.HttpServlet; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import javax.servlet.http.HttpSession; +import org.biohackathon.SPARQLBuilder.OWL.*; + +/** + * + * @author atsuko + */ +@WebServlet(name = "CLServlet", urlPatterns = {"/clist"}) +public class CLServlet extends HttpServlet { + + private static final String FILENAME = "cdata/"; + + /** + * Processes requests for both HTTP GET and POST + * methods. + * + * @param request servlet request + * @param response servlet response + * @throws ServletException if a servlet-specific error occurs + * @throws IOException if an I/O error occurs + */ + protected void processRequest(HttpServletRequest request, HttpServletResponse response) + throws ServletException, IOException { + response.setContentType("text/html;charset=UTF-8"); + try (PrintWriter out = response.getWriter()) { + /* TODO output your page here. You may use following sample code. */ + out.println(""); + out.println(""); + out.println(""); + out.println("Servlet CLServlet"); + out.println(""); + out.println(""); + out.println("Servlet CLServlet at " + request.getContextPath() + ""); + out.println(""); + out.println(""); + } + } + + // + /** + * Handles the HTTP GET method. + * + * @param request servlet request + * @param response servlet response + * @throws ServletException if a servlet-specific error occurs + * @throws IOException if an I/O error occurs + */ + @Override + protected void doGet(HttpServletRequest request, HttpServletResponse response) + throws ServletException, IOException { + //processRequest(request, response); + response.setContentType("application/json;charset=UTF-8"); + response.setHeader("Access-Control-Allow-Origin", "*"); + response.setHeader("Access-Control-Allow-Methods", "GET"); + response.setHeader("Access-Control-Allow-Headers", request.getHeader("Access-Control-Request-Headers")); + response.setHeader("Access-Control-Max-Age", "-1"); + PrintWriter out = response.getWriter(); + String ep = request.getParameter("ep"); + + HttpSession session = request.getSession(); + QueryPathGenerator qpg = (QueryPathGenerator)session.getAttribute("qpg"); + SortedSet sortedClasses = null; + + if ( qpg == null ){ + qpg = new QueryPathGenerator(); + } + if ( ep == null ){ + JsonBuilderFactory jbfactory = Json.createBuilderFactory(null); + JsonObjectBuilder job = jbfactory.createObjectBuilder(); + + String[] eplist = qpg.getFactory().getEndpointURIList(); + for ( int i = 0; i < eplist.length; i++ ){ + try{ + qpg.setSPARQLendpoint(eplist[i]); + SClass[] classes = qpg.getClasses(null); + sortedClasses = qpg.getSortedClasses(classes); + JsonArray ja = getJsonArrayFromSortedClasses(jbfactory, sortedClasses); + job.add(eplist[i], ja); + }catch(Exception e){ + System.err.println(e); + } + } + JsonObject jo = job.build(); + out.print(jo); + return; + } + String classURI = request.getParameter("class"); + qpg.setSPARQLendpoint(ep); + SClass[] classes = null; + if ( classURI != null ){ + qpg.setOWLClassGraph(classURI); + classes = qpg.getReachableClasses(); + }else{ + classes = qpg.getClasses(null); + } + sortedClasses = qpg.getSortedClasses(classes); + + JsonBuilderFactory jbfactory = Json.createBuilderFactory(null); + JsonArray ja = getJsonArrayFromSortedClasses(jbfactory, sortedClasses); + out.print(ja); + } + + /** + * Handles the HTTP
+ * 繧ｯ繧ｨ繝ｪ繝薙Ν繝繝ｼ縺ｮ譛ｬ逡ｪ繝励Ο繧ｰ繝ｩ繝縺ｧ縺ｯ縺薙�繝｡繧ｽ繝�ラ縺ｯ菴ｿ逕ｨ縺励↑縺� + *
+ * 謖�ｮ壹＆繧後◆graphURIs縺ｮ荳ｭ縺九ｉ縲√く繝ｼ繝ｯ繝ｼ繝峨↓繝偵ャ繝医☆繧九Λ繝吶Ν繧呈戟縺､繧ｯ繝ｩ繧ｹ��dfs:Class�峨ｒ縺吶∋縺ｦ霑斐☆ + *
+ * 謖�ｮ壹＆繧後◆graphURIs縺ｮ荳ｭ縺九ｉ縲√く繝ｼ繝ｯ繝ｼ繝峨↓繝偵ャ繝医☆繧九Λ繝吶Ν繧呈戟縺､繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧偵☆縺ｹ縺ｦ霑斐☆ + * 縺薙％縺ｧ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ縺ｯ縲〉df:type縺ｮ荳ｻ隱槭→縺励※險倩ｿｰ縺輔ｌ縺ｦ縺�ｋ繧ゅ�繧偵＞縺� + *
+ * 蜃ｦ逅�ｯｾ雎｡繝��繧ｿ繧暖raphURIs縺ｧ謖�ｮ壹☆繧九％縺ｨ縺後〒縺阪ｋ + * + *
+ * 縺薙％縺ｧ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ縺ｯ縲〉df:type縺ｮ荳ｻ隱槭→縺励※險倩ｿｰ縺輔ｌ縺ｦ縺�ｋ繧ゅ�繧偵＞縺� + * 蜃ｦ逅�ｯｾ雎｡繝��繧ｿ繧暖raphURIs縺ｧ謖�ｮ壹☆繧九％縺ｨ縺後〒縺阪ｋ + *
GET
POST