private static Set<Resource> subjectSet( Model result, Resource S, Property P, RDFNode O ) { return result.listStatements( S, P, O ) .mapWith( Statement.Util.getSubject ).toSet(); }
public Set<Resource> implementsTypes() { return implementTypes.listStatements().mapWith( Statement.Util.getSubject ).toSet(); } }
/** Return an iterator over the unique predicate between s and o. * s and o can be wildcards (Node.ANY) * @param g Graph * @param s Subject - may be Node.ANY * @param o Object - may be Node.ANY * @return ExtendedIterator */ public static ExtendedIterator<Node> listPredicates(Graph g, Node s, Node o) { ExtendedIterator<Triple> iter = g.find(s,Node.ANY, o) ; Set<Node> nodes = iter.mapWith(mapPredicate).toSet() ; return WrappedIterator.createNoRemove(nodes.iterator()) ; }
/** Return an iterator over the unique objects with a given subject and object. * s and p can be wildcards (Node.ANY) * @param g Graph * @param s Subject - may be Node.ANY * @param p Predicate - may be Node.ANY * @return ExtendedIterator */ public static ExtendedIterator<Node> listObjects(Graph g, Node s, Node p) { ExtendedIterator<Triple> iter = g.find(s, p, Node.ANY) ; Set<Node> nodes = iter.mapWith(mapObject).toSet() ; return WrappedIterator.createNoRemove(nodes.iterator()) ; }
/** Return an iterator over the unique subjects with predciate p and object o. * p and o can be wildcards (Node.ANY) * @param g Graph * @param p Predicate - may be Node.ANY * @param o Object - may be Node.ANY * @return ExtendedIterator */ public static ExtendedIterator<Node> listSubjects(Graph g, Node p, Node o) { // Restore a minimal QueryHandler? ExtendedIterator<Triple> iter = g.find(Node.ANY, p, o) ; Set<Node> nodes = iter.mapWith(mapSubject).toSet() ; return WrappedIterator.createNoRemove(nodes.iterator()) ; }
private void addPropertyValues( Trail t, Element e, Resource x, Property p ) { Element pe = createElement(p); e.appendChild( pe ); Set<RDFNode> values = x.listProperties( p ).mapWith( Statement.Util.getObject ).toSet(); // if (values.size() > 1 || isMultiValued( p )) { for (RDFNode value: sortObjects( p, values )) { appendValueAsItem(t, pe, value); } } else if (values.size() == 1) { giveValueToElement( t, pe, values.iterator().next() ); } }
/** Filter the model m according to the view-languages rules of the LDA spec. <p> If the list of viewing languages contains some values, then the only untyped literal values of a property P for some subject S that will kept are those with a language in the list or, if there are none, those with no language. </p> */ public static void filterByLanguages( Model m, String[] split) { Set<String> allowed = new HashSet<String>( Arrays.asList( split ) ); if (allowed.contains( "none" )) allowed.add( "" ); for (Resource sub: m.listSubjects().toList()) { for (Property prop: sub.listProperties().mapWith( Statement.Util.getPredicate ).toSet()) removeUnwantedPropertyValues( allowed, sub, prop ); } }
/** * Default implementation for task {@see ReasoningService.Tasks.CLASSIFY}. Classification: 1) Perform * reasoning 2) Returns only rdf:type statements. * * This is a default implementation of task {@see ReasoningService.Tasks.CLASSIFY}. Subclasses may want to * change it. * * TODO: This method should also return rdfs:subClassOf statements * * @param data * @return */ protected Set<Statement> classify(Model data) { log.debug(" classify(Model data)"); return run(data).listStatements().filterKeep(new PropertyFilter(RDF.type)).toSet(); }
/** * Default implementation for task {@see ReasoningService.Tasks.CLASSIFY}. Classification: 1) Perform * reasoning 2) Returns only rdf:type statements. * * This is a default implementation of task {@see ReasoningService.Tasks.CLASSIFY}. Subclasses may want to * change it. * * TODO: This method should also return rdfs:subClassOf statements * * @param data * @return */ protected Set<Statement> classify(Model data) { log.debug(" classify(Model data)"); return run(data).listStatements().filterKeep(new PropertyFilter(RDF.type)).toSet(); }
/** * * Classification: 1) Perform reasoning on a reasoner customized with the given rule set 2) Returns only * rdf:type statements * * This is a default implementation of task {@see ReasoningService.Tasks.CLASSIFY}. Subclasses may want to * change it. * * TODO: This method should also return rdfs:subClassOf statements * * @param data * @param rules * @return */ protected Set<Statement> classify(Model data, List<Rule> rules) { log.debug(" classify(Model data, List<Rule> rules)"); return run(data, rules).listStatements().filterKeep(new PropertyFilter(RDF.type)).toSet(); }
/** * * Classification: 1) Perform reasoning on a reasoner customized with the given rule set 2) Returns only * rdf:type statements * * This is a default implementation of task {@see ReasoningService.Tasks.CLASSIFY}. Subclasses may want to * change it. * * TODO: This method should also return rdfs:subClassOf statements * * @param data * @param rules * @return */ protected Set<Statement> classify(Model data, List<Rule> rules) { log.debug(" classify(Model data, List<Rule> rules)"); return run(data, rules).listStatements().filterKeep(new PropertyFilter(RDF.type)).toSet(); }
public void renderMetadata(Element e, Resource x, Resource xInMetaModel) { Set<Resource> cyclic = CycleFinder.findCycles( xInMetaModel ); Set<Resource> blocked = new HashSet<Resource>(); Set<Resource> seen = new HashSet<Resource>(); Trail t = new Trail( cyclic, seen, blocked ); // blocked.add( x ); Statement emv = xInMetaModel.getProperty( API.extendedMetadataVersion ); if (emv != null) blocked.add( emv.getResource() ); // addIdentification( t, e, x ); List<Property> metaProperties = asSortedList( xInMetaModel.listProperties().mapWith( Statement.Util.getPredicate ).toSet() ); // if (suppressIPTO) properties.remove( FOAF.isPrimaryTopicOf ); for (Property p: metaProperties) addPropertyValues( t, e, xInMetaModel, p ); }
public void expandProperties(Trail t, Element pt, Resource anItem) { List<Property> properties = asSortedList( anItem.listProperties().mapWith( Statement.Util.getPredicate ).toSet() ); for (Property ip: properties) addPropertyValues( t, pt, anItem, ip ); }
for (OntClass equivalentClass : clazz.listEquivalentClasses().toSet()) { buildRestrictionTree(equivalentClass, seenClasses, node, seenProperties, ignore, exclusive); for (OntClass superClass : clazz.listSuperClasses().toSet()) { buildRestrictionTree(superClass, seenClasses, node, seenProperties, ignore, exclusive);