Package com.hp.hpl.jena.rdf.model

Examples of com.hp.hpl.jena.rdf.model.ResIterator

17
18
19
20
21
22
23
24
25
26
27
28
29
30
    {
    this.input = m;
    this.repair = report;
    this.output = this.input;   
               
    ResIterator it = repair.listSubjectsWithProperty( EYE.repairType, EYE.defineClass );
    while ( it.hasNext() )
      {
      Resource curr = it.nextResource();
            if ( !curr.hasProperty( EYE.noConsistentTypeFor ) )
                {
                Resource bn = repair.createResource( repair.listObjectsOfProperty( curr, EYE.statementAdded ).nextNode().asNode().getBlankNodeId() );
                Resource subj = output.createResource( repair.listObjectsOfProperty( bn, RDF.subject ).nextNode().asNode().getURI() );
                Property pred = output.createProperty( repair.listObjectsOfProperty( bn, RDF.predicate ).nextNode().asNode().getURI() );
View Full Code Here
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
  public void analyse( Report r, Model m, Model config )
  {
  this.input = m;
  this.repair = r.model();
 
  ResIterator it1 = repair.listSubjectsWithProperty( EYE.badNamespaceURI );
  while( it1.hasNext() )
    {
    Resource curr = it1.nextResource();
    repair.add( curr, EYE.repairConfidence, EYE.low )
          .add( curr, EYE.repairType, EYE.replaceNamespace )
          .add( curr, EYE.checkFix, EYE.namespacePrefix );
    }
 
  ResIterator it2 = repair.listSubjectsWithProperty( EYE.multiplePrefixesForNamespace );
  while ( it2.hasNext() )
      {
    Resource curr = it2.nextResource();
    repair.add( curr, EYE.repairConfidence, EYE.good )
            .add( curr, EYE.repairType, EYE.removeDuplicatePrefixes )
            .add( curr, EYE.checkFix, EYE.namespacePrefix );
      }
  r.setMitems( repair );
View Full Code Here
20
21
22
23
24
25
26
27
28
29
30
31
32
33
    {
    this.input = m;
    this.repair = report;
    this.output = this.input;

      ResIterator it = report.listSubjectsWithProperty( EYE.noConsistentTypeFor );
      while( it.hasNext() )
        {
        Resource curr = it.nextResource();
        RDFNode fix = report.listObjectsOfProperty( curr, EYE.repairType ).nextNode();
        if ( fix.equals( EYE.removeType ) )
          {
          NodeIterator it2 = repair.listObjectsOfProperty( curr, EYE.statementRemoved );
          while ( it2.hasNext() )
View Full Code Here
61
62
63
64
65
66
67
68
69
70
71
72
73
74
    }
 
  private Resource getSubbiestClass( Resource parent, Model in )
    {
    Resource result = parent;
    ResIterator it = in.listSubjectsWithProperty( RDFS.subClassOf, parent );
    while ( it.hasNext() )
      {
      Resource curr = it.nextResource();
      if ( !hasBeenSeen( curr ) )
        {
        addSeen( curr );
        Resource midresult = getSubbiestClass( curr, in );
        if ( midresult != null )
View Full Code Here
34
35
36
37
38
39
40
41
42
43
44
45
46
47
    if ( !types.contains( currType ) )
      types.add( currType );
    typeCounts[ types.indexOf( currType ) ]++;
    }
 
  ResIterator it2 = repair.listSubjectsWithProperty( EYE.noConsistentTypeFor );
  while( it2.hasNext() )
    {
    Resource curr = it2.nextResource();
    // Try and compare the number of usages of clashing classes; instruct to delete if one outweighs the other
    Resource from = input.createResource( repair.listObjectsOfProperty( curr, EYE.noConsistentTypeFor ).nextNode().asNode().getURI() );
   
    NodeIterator it3 = ((OntModel)input).getBaseModel().listObjectsOfProperty( from, RDF.type );
    ArrayList<String> l = new ArrayList<String>();
View Full Code Here
18
19
20
21
22
23
24
25
26
27
28
29
30
    {
    this.input = m;
    this.repair = report;
    this.output = this.input;
   
    ResIterator it = repair.listSubjectsWithProperty( EYE.hasNoType );
    while ( it.hasNext() ) {
      NodeIterator it2 = repair.listObjectsOfProperty( it.nextResource(), EYE.statementAdded );
      while ( it2.hasNext() )
        {
        Resource bnode = repair.createResource( it2.nextNode().asNode().getBlankNodeId() );
       
        Resource subj =  (Resource)repair.listObjectsOfProperty( bnode, RDF.subject ).nextNode();
View Full Code Here
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
        {  // Fall back to spellcheck if we can't find it in a known NS.
        Model wordModel = ModelFactory.createDefaultModel();
        for ( int a = 0; a < namespaces.length; a++ )
          wordModel.read("file:" + nsBase + "/" + namespaces[a]);
   
        ResIterator wordIt = wordModel.listSubjectsWithProperty( RDF.type );
        String loosewords = "";
        String fullwords = "";
       
        int size = wordModel.listSubjectsWithProperty( RDF.type ).toList().size();
        looseMappingArr = new String[size];
        fullMappingArr = new String[size];
        int i = 0;
       
        while ( wordIt.hasNext() )
          {
          Resource currWord = wordIt.nextResource();
          if ( currWord.isURIResource() )
            {
            fullwords += currWord.asNode().getURI() + '\n';
           
            loosewords += currWord.getLocalName() + '\n';
View Full Code Here
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
  private Model config;

  private String getConfigsPrefixFromUri ( String uri )
    {
    ResIterator subjects = config.listSubjectsWithProperty( EYE.nsURI, config.createLiteral( uri ) );
    if ( subjects.hasNext() )
      {
      StmtIterator prefixes = config.listStatements( subjects.nextResource(), EYE.prefix, (RDFNode)null );
      if ( prefixes.hasNext() )
        return prefixes.nextStatement().getObject().asNode().getLiteralLexicalForm();
      }
    return null; // Return null otherwise
    }
View Full Code Here
29
30
31
32
33
34
35
36
37
38
39
40
41
42
    return null; // Return null otherwise
    }

  private String getConfigsUriFromPrefix ( String pre )
    {
    ResIterator subjects = config.listSubjectsWithProperty( EYE.prefix, config.createLiteral( pre ) );
    if ( subjects.hasNext() )
      {
      StmtIterator uris = config.listStatements( subjects.nextResource(), EYE.nsURI, (RDFNode)null );
      if ( uris.hasNext() )
        return uris.nextStatement().getObject().asNode().getLiteralLexicalForm();
      }
    return null; // Return null otherwise
    }
View Full Code Here
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
    this.input = m;
    this.repair = report;
    this.output = this.input;
    this.config = config;
   
    ResIterator it = repair.listSubjectsWithProperty( EYE.repairType, EYE.replaceNamespace );
    while ( it.hasNext() )
      {
      /*
       * We are able to make one or more of the following assumptions;
       * (1)  o The Prefix is probably desired                                       \\
       * (3)  o The URI is likely misspelt                                          ===>  Work these with the precedence specified
       * (2)  o The URI is right, but the user mistakenly used a 'reserved' prefix   //
       */
      Resource curr = it.nextResource();
      String prefix = repair.listObjectsOfProperty( curr, EYE.onPrefix ).nextNode().asNode().getLiteralLexicalForm();
      String currUri = output.getNsPrefixURI( prefix );
      String configsUri = getConfigsUriFromPrefix( prefix );
      String configsPre = null;
      if ( currUri != null )
        configsPre = getConfigsPrefixFromUri( currUri );
      if ( configsUri != null ) // Change the URI to a preferred one
        changeNsUri( currUri, configsUri );
      else if ( configsPre != null ) // Use that URI, but set the prefix according to config
        changeNsPrefix( prefix, configsPre );
      else // Use the 'expected' URI
        output.setNsPrefix( prefix, repair.listObjectsOfProperty( curr, EYE.expected ).nextNode().asNode().getLiteralLexicalForm() );
      }
   
    it = repair.listSubjectsWithProperty( EYE.repairType, EYE.removeDuplicatePrefixes );
    while ( it.hasNext() )
      {
      Resource curr = it.nextResource();
      NodeIterator it2 = repair.listObjectsOfProperty( curr, EYE.onPrefix );
        String uri = repair.listObjectsOfProperty( curr, EYE.multiplePrefixesForNamespace ).nextNode().asNode().getLiteralLexicalForm();
        if (it2.hasNext())
          {
          boolean oneKept = false;
View Full Code Here
TOP

Related Classes of com.hp.hpl.jena.rdf.model.ResIterator

  • com.github.jsonldjava.jena.JenaRDFParser
  • com.hp.gloze.Restrictions
  • com.hp.hpl.jena.eyeball.repairtools.analysis.AllTypedAnalysis
  • com.hp.hpl.jena.eyeball.repairtools.analysis.CardinalityAnalysis
  • com.hp.hpl.jena.eyeball.repairtools.analysis.ConsistentTypeAnalysis
  • com.hp.hpl.jena.eyeball.repairtools.analysis.LiteralAnalysis
  • com.hp.hpl.jena.eyeball.repairtools.analysis.PrefixAnalysis
  • com.hp.hpl.jena.eyeball.repairtools.analysis.PropertyAnalysis
  • com.hp.hpl.jena.eyeball.repairtools.analysis.URIAnalysis
  • com.hp.hpl.jena.eyeball.repairtools.analysis.VocabularyAnalysis
    • Copyright © 2018 www.massapicom. All rights reserved.
    All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.