com.hp.hpl.jena.util.iterator.ExtendedIterator Java Examples

public static List<String> getAllClasses ()
{
   List<String>classes = new ArrayList<String>();
   DrbCortexModel model;
   try
   {
      model = DrbCortexModel.getDefaultModel();
   }
   catch (IOException e)
   {
      return classes;
   }
   ExtendedIterator it= model.getCortexModel().getOntModel().listClasses();
   while (it.hasNext())
   {
      OntClass cl = (OntClass)it.next();
      String uri = cl.getURI();
      if (uri!=null)
         classes.add(uri);
   }
   return classes;
}
 

@Override
public void setParentConcept(ObjectClass parent) {
	if (parent != null) {
		this.addProperty(RDFS.subClassOf, parent.asMDRResource());
	} else {
		ExtendedIterator<OntClass> l = this.listSuperClasses();
		OntClass found = null;
		while (l.hasNext()) {
			OntClass ontClass = l.next();
			if (ontClass.hasSuperClass(mdrDatabase.getVocabulary().Concept)) {
				found = ontClass;
			}
		}
		if (found != null) {
			this.removeProperty(RDFS.subClassOf, found);
		}
	}
}
 

public BindingQueryPlan prepareBindings(GraphQuery q, Node[] variables) {   
	this.variables = variables;
	this.indexes = new HashMap<Node,Integer>();
	for (int i = 0; i < variables.length; i++) {
		indexes.put(variables[i], new Integer(i));
	}
	BasicPattern pattern = new BasicPattern();
	for (Triple t: q.getPattern()) {
		pattern.add(t);
	}
	Plan plan = QueryEngineD2RQ.getFactory().create(new OpBGP(pattern), dataset, null, null);
	final ExtendedIterator<Domain> queryIterator = new Map1Iterator<Binding,Domain>(new BindingToDomain(), plan.iterator());
	return new BindingQueryPlan() {
		public ExtendedIterator<Domain> executeBindings() {
			return queryIterator;
		}
	};
}
 

public static List<String>getSubClass(String URI)
{
   List<String>sub_classes = new ArrayList<String>();
   DrbCortexItemClass cl = DrbCortexItemClass.getCortexItemClassByName(URI);
   ExtendedIterator it = cl.getOntClass().listSubClasses(true);
   while (it.hasNext())
   {
      String ns = ((OntClass)it.next()).getURI();
      if(ns!=null) sub_classes.add(ns);
   }
   return sub_classes;
}
 

@Override
public List<ObjectClass> getSubConcepts() {
	ExtendedIterator<OntClass> l = this.listSubClasses();
	List<ObjectClass> ocList = new ArrayList<ObjectClass>();

	while (l.hasNext()) {
		OntClass res = l.next();
		ocList.add(new ConceptImpl(res, mdrDatabase));
	}

	return ocList;
}
 

public <T extends MDRResource> List<T> createList(ExtendedIterator<? extends RDFNode> it,
		Class<T> cls) throws MDRException {

	List<T> newList = new ArrayList<T>();
	try {
		Transformer transformer = transformerMap.get(cls);
		CollectionUtils.collect(it, transformer, newList);
	} catch (Exception e) {
		throw new MDRException(e);
	}
	return newList;
}
 

@Override
public ExtendedIterator<Triple> graphBaseFind(final Triple pattern) {	
	try {
		return WrappedIterator.createNoRemove(query(pattern));
	} catch (final SyntaxError exception) {
		logger().error(MessageCatalog._00113_NWS_FAILURE, exception);
		return new NullIterator<Triple>();
	}
}
 

@Override
public ExtendedIterator<Triple> graphBaseFind(TripleMatch m) {
	checkOpen();
	Triple t = m.asTriple();
	if (log.isDebugEnabled()) {
		log.debug("Find: " + PrettyPrinter.toString(t, getPrefixMapping()));
	}
	FindQuery query = new FindQuery(t, mapping.getTripleRelations(), 
			new ExecutionContext(mapping.getContext(), this, null, null));
	ExtendedIterator<Triple> result = TripleQueryIter.create(query.iterator());
	result = result.andThen(mapping.getAdditionalTriples().find(t));
	return result;
   }
 

/**
 * Overloaded to reuse and update the cache.
 */
@Override
public ExtendedIterator<Triple> graphBaseFind(TripleMatch m) {
	List<Triple> cached = queryCache.get(m);
	if (cached != null) {
           return WrappedIterator.create(cached.iterator());
	}
	ExtendedIterator<Triple> it = super.graphBaseFind(m);
	final List<Triple> list = it.toList();
	queryCache.put(m, list);
	return WrappedIterator.create(list.iterator());
}
 

public static List<String>getSuperClass(String URI)
{
   List<String>super_classes = new ArrayList<String>();
   DrbCortexItemClass cl = DrbCortexItemClass.getCortexItemClassByName(URI);
   ExtendedIterator it = cl.getOntClass().listSuperClasses(true);
   while (it.hasNext())
   {
      String ns = ((OntClass)it.next()).getURI();
      if(ns!=null) super_classes.add(ns);
   }
   return super_classes;
}
 

/**
 * Retrieve the dhus system supported items for file scanning processing.
 * Is considered supported all classes having
 * <code>http://www.gael.fr/dhus#metadataExtractor</code> property
 * connection.
 * @return the list of supported class names.
 */
public static synchronized String[] getDefaultCortexSupport ()
{
   DrbCortexModel model;
   try
   {
      model = DrbCortexModel.getDefaultModel ();
   }
   catch (IOException e)
   {
      throw new UnsupportedOperationException (
         "Drb cortex not properly initialized.");
   }

   ExtendedIterator it=model.getCortexModel ().getOntModel ().listClasses ();
   List<String>list = new ArrayList<String> ();

   while (it.hasNext ())
   {
      OntClass cl = (OntClass)it.next ();

      OntProperty metadata_extractor_p = cl.getOntModel().getOntProperty(
            "http://www.gael.fr/dhus#support");

      StmtIterator properties = cl.listProperties (metadata_extractor_p);
      while (properties.hasNext ())
      {
         Statement stmt = properties.nextStatement ();
         LOGGER.debug ("Scanner Support Added for " +
            stmt.getSubject ().toString ());
         list.add (stmt.getSubject ().toString ());
      }
   }
   return list.toArray (new String[list.size ()]);
}
 

@Override
public ExtendedIterator<Triple> graphBaseFind(TripleMatch m) {
	checkOpen();
	Triple t = m.asTriple();
	if (log.isDebugEnabled()) {
		log.debug("Find: " + PrettyPrinter.toString(t, getPrefixMapping()));
	}
	ExecutionContext context = new ExecutionContext(mapping.getContext(), this, null, null);
	GeneralFindQuery query = new GeneralFindQuery(t, mapping.getTripleRelations(), context);
	ExtendedIterator<Triple> result = TripleQueryIter.create(query.iterator());
	result = result.andThen(mapping.getAdditionalTriples().find(t));
	return result;
   }
 

/**
 * Find the given triple(s) from the graph. 
 */
@Override
public ExtendedIterator<Triple> find(TripleMatch triple) {
	return find(triple.getMatchSubject(),triple.getMatchPredicate(), triple.getMatchObject());
}
 

public ExtendedIterator<OntClass> getClasses() {
	return model.listClasses();
}
 

@Override
public ExtendedIterator<Triple> find(Node arg0, Node arg1, Node arg2) {
	// TODO Auto-generated method stub
	return null;
}
 

@Override
public ExtendedIterator<Triple> find(TripleMatch arg0) {
	// TODO Auto-generated method stub
	return null;
}
 

@Override
public ExtendedIterator listGraphs() {
	// TODO Auto-generated method stub
	return null;
}
 

/**
 * Find the given triple(s) from the graph. 
 */
@Override
public ExtendedIterator<Triple> find(Node subject, Node predicate, Node object) {
	//System.out.println("NeoGraph#find");
	try(Transaction tx = graphdb.beginTx()) {
		StringBuffer query = new StringBuffer("MATCH triple=");
		
		query.append("(subject");
		if(subject.equals(Node.ANY)) {
			query.append(":"+ LABEL_URI);
			//System.out.println("NeoGraph#find#Any:"+subject);
		} else if(subject.isURI()){
			query.append(":"+LABEL_URI+" {uri:'");
			query.append(subject.getURI());
			query.append("'}");
			//System.out.println("NeoGraph#find#URI:"+subject+subject.getURI());
		} else {
			query.append(":" + LABEL_BNODE);
			//System.out.println("NeoGraph#find#"+subject);
		}
		query.append(")-[predicate]->(object");
		
		//query.append("]->(object");
		if(object.equals(Node.ANY)) {
			//query.append(" ");
		} else if(object.isURI()){
			query.append(":"+LABEL_URI+" {uri:'");
			query.append(object.getURI());
			query.append("'}");
		} else {
			query.append(":"+LABEL_LITERAL+" {value:'");
			query.append(object.getLiteralValue());
			query.append("'}");
		}
		query.append(")");
		
		//System.out.println("Predicate in query: " +getPrefixMapping().shortForm(predicate.getURI()));
		if(predicate.isURI()) {
			query.append("WHERE type(predicate)='");
			query.append(getPrefixMapping().shortForm(predicate.getURI()));
			query.append("'");
		}
		
		query.append("\nRETURN subject, type(predicate), object");
		//System.out.println(query.toString());
		ExecutionEngine engine = new ExecutionEngine(graphdb);
		ExecutionResult results = engine.execute(query.toString());
		//System.out.println(results.dumpToString());
		//System.out.println("NeoGraph#find#"+predicate);
		//System.out.println("NeoGraph#find#"+object);
		//System.out.println("NeoGraph#find#DONE");
		return new ExecutionResultIterator(results, graphdb);
	}
}
 

@Override
public <U> ExtendedIterator<U> mapWith(Map1<Triple, U> map1) {
	// TODO Auto-generated method stub
	return null;
}
 

@Override
public ExtendedIterator<Triple> filterDrop(Filter<Triple> f) {
	// TODO Auto-generated method stub
	return null;
}
 

@Override
public ExtendedIterator<Triple> filterKeep(Filter<Triple> f) {
	// TODO Auto-generated method stub
	return null;
}
 

@Override
public <X extends Triple> ExtendedIterator<Triple> andThen(Iterator<X> other) {
	// TODO Auto-generated method stub
	return null;
}
 

public void loadOntologyFromFile() {
   	final FileBrowserSheet fileBrowserSheet = new FileBrowserSheet();
	fileBrowserSheet.setName("Select an ontology file");
	fileBrowserSheet.setDisabledFileFilter(new Filter<File>() {                     
       @Override 
       public boolean include(File file) { 
           return (file.isFile() 
               && !file.getName().endsWith(".rdf")); 
       } 
   }); 
	fileBrowserSheet.setMode(org.apache.pivot.wtk.FileBrowserSheet.Mode.OPEN);
	fileBrowserSheet.open(GeoTriplesWindow.this, new SheetCloseListener() {
		@Override
		public void sheetClosed(Sheet sheet) {
			if (sheet.getResult()) {
				Sequence<File> selectedFiles = fileBrowserSheet
						.getSelectedFiles();

				ListView listView = new ListView();
				listView.setListData(new ArrayList<File>(selectedFiles));
				listView.setSelectMode(ListView.SelectMode.NONE);
				listView.getStyles().put("backgroundColor", null);
				
				try {
					ontologyPath = selectedFiles.get(0).getCanonicalPath();
					if(ontologyPath==null)
					{
						Alert.alert(MessageType.ERROR, "Something went wrong with the file,  please try again",GeoTriplesWindow.this);
						return;
					}
					
					OntologyLoader loader = new OntologyLoader(ontologyPath);
					loader.load();
					
					/**
		             * for properties
		             */
					List<String> preds = new ArrayList<String>();
	            	ExtendedIterator<DatatypeProperty> props = loader.getProperties();
	            	while (props.hasNext()) {
	            		preds.add(props.next().getLocalName());
	            	}
	            	
		            /**
		             * for classes
		             */
		            List<String> classes = new ArrayList<String>();
	            	ExtendedIterator<OntClass> classS = loader.getClasses();
	            	while (classS.hasNext()) {
	            		classes.add(classS.next().getLocalName());
	            	}

	            	for(SourceTable st:sourceTables)
		            {
		            	st.setClasses(classes);
		            	st.setPredicates(preds);
		            }
				} catch (IOException e) {
					System.out.println(e.getMessage());
					e.printStackTrace();
					System.exit(13);
				}
			} 	
			}
	});			
	/*
	 * ApplicationContext.scheduleRecurringCallback(new Runnable() {
	 * 
	 * @Override public void run() { refreshTable(); } }, REFRESH_INTERVAL);
	 */
}
 

public ExtendedIterator<DatatypeProperty> getProperties() {
	return model.listDatatypeProperties();
}
 

public static ExtendedIterator<Triple> create(QueryIter wrapped) {
	return new GeneralTripleQueryIter(wrapped);
}
 

public static ExtendedIterator<Triple> create(QueryIter wrapped) {
	return new TripleQueryIter(wrapped);
}
 

private TermMap createTransformationValuedTermMap(Resource r) {
	TransformationValuedTermMap result = new TransformationValuedTermMap();
	result.setFunction(ConstantIRI.create(getString(r, RRX.function)));
	
	
	List<TermMap> arguments=new ArrayList<TermMap>();
	//Resource list = getResource(r, RRX.argumentMap);
	
	RDFNode list2 = r.getProperty(RRX.argumentMap).getObject();;
	
	
	
	RDFList rdfList = list2.as( RDFList.class );
       ExtendedIterator<RDFNode> items = rdfList.iterator();
       while ( items.hasNext() ) {
           Resource item = items.next().asResource();            
           if(item.getProperty(RR.constant)!=null)
           {
   			arguments.add(createConstantValuedTermMap(item));
   		}
           if(item.getProperty(RR.column)!=null) {
			arguments.add(createColumnValuedTermMap(item));
		}
		if(item.getProperty(RRX.function)!=null) {
			arguments.add(createTransformationValuedTermMap(item));
		}
		if(item.getProperty(RR.template)!=null) {
			arguments.add(createTemplateValuedTermMap(item));
		}
           
       }
	
	
	
	
	
	
	
	
       
	result.setTermMaps(arguments);
	readColumnOrTemplateValuedTermMap(result, r);
	return result;
}