private boolean isObsolete(Resource ctx) throws SailException {
   CloseableIteration<? extends Statement, SailException> stmts;
   stmts = super.getStatements(null, null, null, true, ctx);
   try {
     while (stmts.hasNext()) {
       Statement st = stmts.next();
       URI pred = st.getPredicate();
       Value obj = st.getObject();
       String ns = pred.getNamespace();
       if (Audit.NAMESPACE.equals(ns) || PROV.equals(ns) || AUDIT_2012.equals(ns)) continue;
       if (RDF.SUBJECT.equals(pred) || RDF.PREDICATE.equals(pred) || RDF.OBJECT.equals(pred))
         continue;
       if (RDF.TYPE.equals(pred) && obj instanceof URI) {
         ns = ((URI) obj).getNamespace();
         if (Audit.NAMESPACE.equals(ns)
             || PROV.equals(ns)
             || AUDIT_2012.equals(ns)
             || RDF.NAMESPACE.equals(ns)) continue;
       }
       return false;
     }
   } finally {
     stmts.close();
   }
   return true;
 }
  /**
   * Constant-valued term maps can be expressed more concisely using the constant shortcut
   * properties rr:subject, rr:predicate, rr:object and rr:graph. Occurrances of these properties
   * must be treated exactly as if the following triples were present in the mapping graph instead.
   *
   * @param r2rmlMappingGraph
   */
  private static void replaceShortcuts(SesameDataSet r2rmlMappingGraph) {
    Map<URI, URI> shortcutPredicates = new HashMap<URI, URI>();
    shortcutPredicates.put(
        vf.createURI(Vocab.R2RML_NAMESPACE + R2RMLTerm.SUBJECT),
        vf.createURI(Vocab.R2RML_NAMESPACE + R2RMLTerm.SUBJECT_MAP));
    shortcutPredicates.put(
        vf.createURI(Vocab.R2RML_NAMESPACE + R2RMLTerm.PREDICATE),
        vf.createURI(Vocab.R2RML_NAMESPACE + R2RMLTerm.PREDICATE_MAP));
    shortcutPredicates.put(
        vf.createURI(Vocab.R2RML_NAMESPACE + R2RMLTerm.OBJECT),
        vf.createURI(Vocab.R2RML_NAMESPACE + R2RMLTerm.OBJECT_MAP));
    shortcutPredicates.put(
        vf.createURI(Vocab.R2RML_NAMESPACE + R2RMLTerm.GRAPH),
        vf.createURI(Vocab.R2RML_NAMESPACE + R2RMLTerm.GRAPH_MAP));
    for (URI u : shortcutPredicates.keySet()) {
      List<Statement> shortcutTriples = r2rmlMappingGraph.tuplePattern(null, u, null);
      log.debug(
          "[RMLMappingFactory:replaceShortcuts] Number of R2RML shortcuts found "
              + "for "
              + u.getLocalName()
              + " : "
              + shortcutTriples.size());
      for (Statement shortcutTriple : shortcutTriples) {
        r2rmlMappingGraph.remove(
            shortcutTriple.getSubject(), shortcutTriple.getPredicate(), shortcutTriple.getObject());
        BNode blankMap = vf.createBNode();

        URI pMap = vf.createURI(shortcutPredicates.get(u).toString());
        URI pConstant = vf.createURI(Vocab.R2RML_NAMESPACE + R2RMLTerm.CONSTANT);
        r2rmlMappingGraph.add(shortcutTriple.getSubject(), pMap, blankMap);
        r2rmlMappingGraph.add(blankMap, pConstant, shortcutTriple.getObject());
      }
    }
  }
Exemple #3
0
  private Pair toPair(Edge e, Graph graph) {
    URI predicate = e.getPredicate();
    Value object = e.getObject();
    String value = null;
    if (object instanceof Literal) {
      Literal literal = (Literal) object;
      String language = literal.getLanguage();
      URI type = literal.getDatatype();
      if (type.equals(XMLSchema.STRING)) {
        type = null;
      }
      StringBuilder builder = new StringBuilder();
      builder.append('"');
      builder.append(literal.getLabel());
      builder.append('"');
      if (language != null) {
        builder.append('@');
        builder.append(language);
      } else if (type != null) {
        builder.append('^');
        builder.append(type.stringValue());
      }
      value = builder.toString();
    } else if (object instanceof URI) {
      value = object.stringValue();
    } else {
      Resource id = (Resource) object;
      Vertex v = graph.getVertex(id);
      value = createHash(predicate, v);
    }

    return new Pair(predicate, value);
  }
Exemple #4
0
    public boolean matches(final Vertex vertex, final Value value) {
      String kind = (String) vertex.getProperty(KIND);
      String val = (String) vertex.getProperty(VALUE);
      if (value instanceof URI) {
        return kind.equals(URI) && val.equals(value.stringValue());
      } else if (value instanceof Literal) {
        if (kind.equals(LITERAL)) {
          if (!val.equals(((Literal) value).getLabel())) {
            return false;
          }

          String type = (String) vertex.getProperty(TYPE);
          String lang = (String) vertex.getProperty(LANG);

          URI vType = ((Literal) value).getDatatype();
          String vLang = ((Literal) value).getLanguage();

          return null == type && null == vType && null == lang && null == vLang
              || null != type && null != vType && type.equals(vType.stringValue())
              || null != lang && null != vLang && lang.equals(vLang);

        } else {
          return false;
        }
      } else if (value instanceof BNode) {
        return kind.equals(BNODE) && ((BNode) value).getID().equals(val);
      } else {
        throw new IllegalStateException("value of unexpected kind: " + value);
      }
    }
  private void upload(URI graphURI, Resource context) throws Exception {
    RepositoryConnection con = dataRep.getConnection();
    con.setAutoCommit(false);
    try {
      RDFFormat rdfFormat = Rio.getParserFormatForFileName(graphURI.toString(), RDFFormat.TURTLE);
      RDFParser rdfParser = Rio.createParser(rdfFormat, dataRep.getValueFactory());
      rdfParser.setVerifyData(false);
      rdfParser.setDatatypeHandling(DatatypeHandling.IGNORE);
      // rdfParser.setPreserveBNodeIDs(true);

      RDFInserter rdfInserter = new RDFInserter(con);
      rdfInserter.enforceContext(context);
      rdfParser.setRDFHandler(rdfInserter);

      URL graphURL = new URL(graphURI.toString());
      InputStream in = graphURL.openStream();
      try {
        rdfParser.parse(in, graphURI.toString());
      } finally {
        in.close();
      }

      con.setAutoCommit(true);
    } finally {
      con.close();
    }
  }
Exemple #6
0
 @Override
 public void handleStatement(Statement st) throws RDFHandlerException {
   URI predicate = st.getPredicate();
   if (!CORE.NS.equals(predicate.getNamespace()) || !predicate.getLocalName().equals("localId")) {
     super.handleStatement(st);
   }
 }
Exemple #7
0
  /**
   * Describe the vocabularies which are in use in the KB based on the predicate partition
   * statistics.
   *
   * @param predicateParitionCounts The predicate partition statistics.
   */
  protected void describeVocabularies(final IVCount[] predicatePartitionCounts) {

    // Find the distinct vocabularies in use.
    final Set<String> namespaces = new LinkedHashSet<String>();
    {

      // property partitions.
      for (IVCount tmp : predicatePartitionCounts) {

        final URI p = (URI) tmp.getValue();

        String namespace = p.getNamespace();

        if (namespace.endsWith("#")) {

          // Strip trailing '#' per VoID specification.
          namespace = namespace.substring(0, namespace.length() - 1);
        }

        namespaces.add(namespace);
      }
    }

    // Sort into dictionary order.
    final String[] a = namespaces.toArray(new String[namespaces.size()]);

    Arrays.sort(a);

    for (String namespace : a) {

      g.add(aDataset, VoidVocabularyDecl.vocabulary, f.createURI(namespace));
    }
  }
/**
 * Term constants for the DC music ontology
 *
 * @author Michael Grove
 * @since 0.1
 */
public class MusicOntology extends Vocabulary {
  public static final String ONT_URI = "http://purl.org/ontology/mo/";

  private static MusicOntology INSTANCE = null;

  private MusicOntology() {
    super(ONT_URI);
  }

  public static MusicOntology ontology() {
    if (INSTANCE == null) {
      INSTANCE = new MusicOntology();
    }

    return INSTANCE;
  }

  // properties
  public final URI track = term("track");
  public final URI release_type = term("release_type");
  public final URI release_status = term("release_status");
  public final URI track_number = term("track_number");
  public final URI length = term("length");
  public final URI made = term("made");
  public final URI musicbrainz = term("musicbrainz");
  public final URI olga = term("olga");
  public final URI genre = term("genre");
  public final URI sample_rate = term("sample_rate");
  public final URI bitsPerSample = term("bitsPerSample");

  // cp properties
  public final URI rating = term("rating");
  public final URI albumRating = term("albumRating");
  public final URI year = term("year");
  public final URI location = term("location");

  // classes
  public final URI Genre = term("Genre");
  public final URI Record = term("Record");
  public final URI Track = term("Track");
  public final URI MusicArtist = term("MusicArtist");
  public final URI MusicGroup = term("MusicGroup");

  // individuals
  public final URI Metal = FACTORY.createURI(Genre.stringValue() + "/Metal");
  public final URI Rock = FACTORY.createURI(Genre.stringValue() + "/Rock");
  public final URI Alternative = FACTORY.createURI(Genre.stringValue() + "/Alternative");
  public final URI Pop = FACTORY.createURI(Genre.stringValue() + "/Pop");
  public final URI Punk = FACTORY.createURI(Genre.stringValue() + "/Punk");
  public final URI Funk = FACTORY.createURI(Genre.stringValue() + "/Funk");
  public final URI Soundtrack = FACTORY.createURI(Genre.stringValue() + "/Soundtrack");
  public final URI Blues = FACTORY.createURI(Genre.stringValue() + "/Blues");
  public final URI Jazz = FACTORY.createURI(Genre.stringValue() + "/Jazz");
  public final URI Vocal = FACTORY.createURI(Genre.stringValue() + "/Vocal");
  public final URI Country = FACTORY.createURI(Genre.stringValue() + "/Country");

  public final URI album = term("album");
  public final URI official = term("official");
}
 private Collection<String> getEntryForUriSuffix(Map<URI, Collection<String>> map, String suffix) {
   for (URI resource : map.keySet()) {
     if (resource.stringValue().endsWith(suffix)) {
       return map.get(resource);
     }
   }
   return null;
 }
 protected String predicateToID(URI predicate, SailConnection connection) {
   if (predicate.equals(s_type)) {
     return "pub-type";
   } else if (predicate.equals(s_title)) {
     return null;
   }
   return super.predicateToID(predicate, connection);
 }
Exemple #11
0
 private Resource getContainerURI(Resource subj) {
   if (subj instanceof URI) {
     URI uri = (URI) subj;
     String ns = uri.getNamespace();
     if (ns.charAt(ns.length() - 1) == '#') return vf.createURI(ns.substring(0, ns.length() - 1));
   }
   return subj;
 }
 @Override
 public IV get(final IBindingSet bs) {
   URI datatype = null;
   String lang = null;
   boolean allSame = true;
   final StringBuilder sb = new StringBuilder();
   for (int i = 0; i < arity(); i++) {
     @SuppressWarnings("rawtypes")
     final IV v = getAndCheckLiteral(i, bs);
     String label = null;
     if (allSame) {
       final Literal lit = asLiteral(v);
       label = lit.getLabel();
       if (lit.getDatatype() != null) {
         if (lang != null) {
           allSame = false;
         } else if (datatype == null) {
           if (i == 0) {
             datatype = lit.getDatatype();
           } else {
             allSame = false;
           }
         } else if (!datatype.equals(lit.getDatatype())) {
           allSame = false;
         }
       } else if (lit.getLanguage() != null) {
         if (datatype != null) {
           allSame = false;
         } else if (lang == null) {
           if (i == 0) {
             lang = lit.getLanguage();
           } else {
             allSame = false;
           }
         } else if (!lang.equals(lit.getLanguage())) {
           allSame = false;
         }
       } else {
         allSame = false;
       }
     } else {
       label = literalLabel(v);
     }
     sb.append(label);
   }
   if (allSame) {
     if (datatype != null) {
       return super.asIV(getValueFactory().createLiteral(sb.toString(), datatype), bs);
     } else if (lang != null) {
       return super.asIV(getValueFactory().createLiteral(sb.toString(), lang), bs);
     }
   }
   return super.asIV(getValueFactory().createLiteral(sb.toString()), bs);
 }
 private static String getSuffix(URI plainURI, URI baseURI) {
   if (baseURI == null) return null;
   String b = baseURI.toString();
   String p = plainURI.toString();
   if (p.equals(b)) {
     return null;
   } else if (p.startsWith(b)) {
     return p.substring(b.length());
   } else {
     return null;
   }
 }
 private static ReferencingObjectMap extractReferencingObjectMap(
     SesameDataSet r2rmlMappingGraph,
     Resource object,
     Set<GraphMap> graphMaps,
     Map<Resource, TriplesMap> triplesMapResources)
     throws InvalidR2RMLStructureException, InvalidR2RMLSyntaxException {
   log.debug("[RMLMappingFactory:extractReferencingObjectMap] Extract referencing object map..");
   URI parentTriplesMap =
       (URI) extractValueFromTermMap(r2rmlMappingGraph, object, R2RMLTerm.PARENT_TRIPLES_MAP);
   Set<JoinCondition> joinConditions = extractJoinConditions(r2rmlMappingGraph, object);
   if (parentTriplesMap == null && !joinConditions.isEmpty()) {
     throw new InvalidR2RMLStructureException(
         "[RMLMappingFactory:extractReferencingObjectMap] "
             + object.stringValue()
             + " has no parentTriplesMap map defined whereas one or more joinConditions exist"
             + " : exactly one parentTripleMap is required.");
   }
   if (parentTriplesMap == null && joinConditions.isEmpty()) {
     log.debug(
         "[RMLMappingFactory:extractReferencingObjectMap] This object map is not a referencing object map.");
     return null;
   }
   // Extract parent
   boolean contains = false;
   TriplesMap parent = null;
   for (Resource triplesMapResource : triplesMapResources.keySet()) {
     if (triplesMapResource.stringValue().equals(parentTriplesMap.stringValue())) {
       contains = true;
       parent = triplesMapResources.get(triplesMapResource);
       log.debug(
           "[RMLMappingFactory:extractReferencingObjectMap] Parent triples map found : "
               + triplesMapResource.stringValue());
       break;
     }
   }
   if (!contains) {
     throw new InvalidR2RMLStructureException(
         "[RMLMappingFactory:extractReferencingObjectMap] "
             + object.stringValue()
             + " reference to parent triples maps is broken : "
             + parentTriplesMap.stringValue()
             + " not found.");
   }
   // Link between this reerencing object and its triplesMap parent will be
   // performed
   // at the end f treatment.
   ReferencingObjectMap refObjectMap = new StdReferencingObjectMap(null, parent, joinConditions);
   log.debug(
       "[RMLMappingFactory:extractReferencingObjectMap] Extract referencing object map done.");
   return refObjectMap;
 }
Exemple #15
0
 public boolean equals(final Object o) {
   if (this == o) return true;
   if (o instanceof FullyInlineURIIV<?>) {
     return uri.stringValue().equals(((FullyInlineURIIV<?>) o).stringValue());
   }
   return false;
 }
Exemple #16
0
 /**
  * Insert Triple/Statement into graph
  *
  * @param s subject uriref
  * @param p predicate uriref
  * @param o value object (URIref or Literal)
  * @param contexts varArgs context objects (use default graph if null)
  */
 public void add(Resource s, URI p, Value o, Resource... contexts) {
   if (log.isDebugEnabled())
     log.debug(
         "[SesameDataSet:add] Add triple ("
             + s.stringValue()
             + ", "
             + p.stringValue()
             + ", "
             + o.stringValue()
             + ").");
   try {
     RepositoryConnection con = currentRepository.getConnection();
     try {
       ValueFactory myFactory = con.getValueFactory();
       Statement st = myFactory.createStatement((Resource) s, p, (Value) o);
       con.add(st, contexts);
       con.commit();
     } catch (Exception e) {
       e.printStackTrace();
     } finally {
       con.close();
     }
   } catch (Exception e) {
     // handle exception
   }
 }
  @Test
  public void testSize() throws Exception {
    assertEquals("Size of empty repository should be 0", 0, con.size());

    // Add some data to the repository
    con.begin();
    con.addStatement(painter, RDF.TYPE, RDFS.CLASS);
    con.addStatement(painting, RDF.TYPE, RDFS.CLASS);
    con.addStatement(picasso, RDF.TYPE, painter, context1);
    con.addStatement(guernica, RDF.TYPE, painting, context1);
    con.addStatement(picasso, paints, guernica, context1);
    con.commit();

    assertEquals("Size of repository should be 5", 5, con.size());
    assertEquals("Size of named context should be 3", 3, con.size(context1));

    URI unknownContext = new URIImpl(EXAMPLE_NS + "unknown");

    assertEquals("Size of unknown context should be 0", 0, con.size(unknownContext));

    URIImpl uriImplContext1 = new URIImpl(context1.toString());

    assertEquals(
        "Size of named context (defined as URIImpl) should be 3", 3, con.size(uriImplContext1));
  }
 private static String expandBaseURI(URI baseURI) {
   String s = baseURI.toString();
   if (s.matches(".*[A-Za-z0-9\\-_]")) {
     s += ".";
   }
   return s;
 }
 public static String normalize(URI uri, String hash) {
   String s = uri.toString();
   if (s.indexOf('\n') > -1 || s.indexOf('\t') > -1) {
     throw new RuntimeException("Newline or tab character in URI: " + s);
   }
   if (hash == null) return s;
   return s.replace(hash, " ");
 }
Exemple #20
0
 private void storeStatement(Resource subj, URI pred, Value obj, Resource... contexts)
     throws SailException {
   if (subj.equals(currentTrx)) {
     subj = getTrx();
   }
   if (obj.equals(currentTrx)) {
     obj = getTrx();
   }
   if (contexts != null && contexts.length == 1) {
     if (currentTrx.equals(contexts[0])) {
       contexts[0] = getTrx();
     }
   } else if (contexts != null) {
     for (int i = 0; i < contexts.length; i++) {
       if (currentTrx.equals(contexts[i])) {
         contexts[i] = getTrx();
       }
     }
   }
   if (contexts == null || contexts.length == 0 || contexts.length == 1 && contexts[0] == null) {
     addRevision(subj);
     super.addStatement(subj, pred, obj, getTrx());
   } else if (contexts.length == 1) {
     if (contexts[0].equals(trx)) {
       addRevision(subj);
     }
     super.addStatement(subj, pred, obj, contexts);
     Resource ctx = contexts[0];
     if (isURI(ctx) && !ctx.equals(trx) && modified.add(ctx)) {
       addMetadata(currentTrx, MODIFIED, ctx, currentTrx);
     }
   } else {
     for (Resource ctx : contexts) {
       if (ctx == null || ctx.equals(trx)) {
         addRevision(subj);
         break;
       }
     }
     super.addStatement(subj, pred, obj, contexts);
     for (Resource ctx : contexts) {
       if (isURI(ctx) && !ctx.equals(trx) && modified.add(ctx)) {
         addMetadata(currentTrx, MODIFIED, ctx, currentTrx);
       }
     }
   }
 }
Exemple #21
0
  public static void setLabel(
      RepositoryConnection repCon,
      org.openrdf.model.URI concept,
      org.openrdf.model.URI labelType,
      Literal newlabel,
      PersistAndNotifyProvider persistAndNotifyProvider)
      throws RepositoryException {
    repCon.add(concept, labelType, newlabel);

    persistAndNotifyProvider.persistAndNotify(
        Helper.createChangeSetModel(
            concept.stringValue(),
            labelType.stringValue(),
            newlabel,
            ChangeTripleService.CHANGETYPE_ADD),
        true);
  }
 // TODO: MimeType detector to null forces the execution of all extractors, but extraction
 //       tests should be based on mimetype detection.
 protected void extract(String resource) throws ExtractionException, IOException {
   SingleDocumentExtraction ex =
       new SingleDocumentExtraction(
           new HTMLFixture(copyResourceToTempFile(resource)).getOpener(baseURI.toString()),
           getExtractorFactory(),
           new RepositoryWriter(conn));
   ex.setMIMETypeDetector(null);
   report = ex.run();
 }
Exemple #23
0
  private Response get(URI user) {
    if (userService.isAnonymous(user)) {
      AccountPoJo apj = new AccountPoJo(Namespaces.ANONYMOUS_LOGIN, user.stringValue());
      return Response.ok(apj, Namespaces.MIME_TYPE_JSON)
          .location(java.net.URI.create(user.stringValue()))
          .build();
    }
    try {
      RepositoryConnection conn = sesameService.getConnection();
      try {
        final UserAccount a = accountService.getAccount(user);
        if (a != null) {
          AccountPoJo apj = new AccountPoJo(a.getLogin(), a.getWebId());
          apj.setRoles(a.getRoles());

          for (Statement t :
              ResourceUtils.listOutgoing(conn, conn.getValueFactory().createURI(a.getWebId()))) {
            String prop = t.getPredicate().stringValue();
            if (prop.startsWith(Namespaces.NS_FOAF)) {
              Value object = t.getObject();
              if (object instanceof org.openrdf.model.URI) {
                apj.setFoaf(prop, String.format("<%s>", object));
              } else if (object instanceof Literal) {
                apj.setFoaf(prop, object.toString());
              }
            }
          }

          return Response.ok(apj, Namespaces.MIME_TYPE_JSON)
              .location(java.net.URI.create(user.stringValue()))
              .build();
        }
        return Response.status(Status.NOT_FOUND)
            .entity("Could not find account data of " + user)
            .build();
      } finally {
        conn.commit();
        conn.close();
      }
    } catch (RepositoryException e) {
      // This must not happen!
      return Response.serverError().entity(e).build();
    }
  }
Exemple #24
0
 private void reify(URI activity, URI entity, Resource subj, URI pred, Value obj, Resource ctx)
     throws SailException {
   String ns = activity.stringValue();
   if (ctx instanceof URI) {
     super.addStatement(activity, informedBy, ctx, activity);
   }
   if (entity == null || GENERATED_BY.equals(pred.stringValue())) return;
   URI operation = vf.createURI(ns + "#" + hash(ctx, entity));
   if (ctx instanceof URI) {
     super.addStatement(ctx, qualifiedUsage, operation, activity);
   }
   super.addStatement(activity, qualifiedUsage, operation, activity);
   super.addStatement(operation, usedEntity, entity, activity);
   Resource node = vf.createBNode();
   super.addStatement(operation, changed, node, activity);
   super.addStatement(node, subject, subj, activity);
   super.addStatement(node, predicate, pred, activity);
   super.addStatement(node, object, obj, activity);
 }
Exemple #25
0
    @Override
    public int compareTo(Pair other) {

      int result = predicate.stringValue().compareTo(other.predicate.stringValue());
      if (result == 0) {
        result = value.compareTo(other.value);
      }

      return result;
    }
Exemple #26
0
  /**
   * LDP-Style to serialize a resource.
   *
   * @param writer the writer to serialize to
   * @param subject the resource to serialize
   * @param iteration the Iteration containing the data
   * @throws RDFHandlerException
   * @throws RepositoryException
   */
  public static void exportIteration(
      RDFWriter writer, URI subject, CloseableIteration<Statement, RepositoryException> iteration)
      throws RDFHandlerException, RepositoryException {
    writer.startRDF();

    writer.handleNamespace(LDP.PREFIX, LDP.NAMESPACE);
    writer.handleNamespace(RDF.PREFIX, RDF.NAMESPACE);
    writer.handleNamespace(XSD.PREFIX, XSD.NAMESPACE);
    writer.handleNamespace(DCTERMS.PREFIX, DCTERMS.NAMESPACE);

    writer.handleNamespace("parent", subject.getNamespace());
    writer.handleNamespace("child", subject.stringValue().replaceFirst("/*$", "/"));
    writer.handleNamespace("this", subject.stringValue().replaceFirst("/*$", "#"));

    while (iteration.hasNext()) {
      writer.handleStatement(iteration.next());
    }

    writer.endRDF();
  }
Exemple #27
0
  @Override
  public int _compareTo(final IV o) {

    final FullyInlineURIIV<?> t = (FullyInlineURIIV<?>) o;

    return IVUnicode.IVUnicodeComparator.INSTANCE.compare(uri.stringValue(), t.uri.stringValue());

    //        return uri.stringValue().compareTo(id2);
    //        return id == id2 ? 0 : id < id2 ? -1 : 1;

  }
Exemple #28
0
 @SuppressWarnings("unchecked")
 public V asValue(final LexiconRelation lex) {
   V v = getValueCache();
   if (v == null) {
     final BigdataValueFactory f = lex.getValueFactory();
     v = (V) f.createURI(uri.stringValue());
     v.setIV(this);
     setValue(v);
   }
   return v;
 }
 public static URI getHashURI(
     Resource resource, URI baseURI, String hash, Map<String, Integer> blankNodeMap) {
   if (resource == null) {
     return null;
   } else if (resource instanceof URI) {
     URI plainURI = (URI) resource;
     if (plainURI.toString().matches(".*(\\n|\\t).*")) {
       throw new RuntimeException("Newline or tab character in URI: " + plainURI.toString());
     }
     String suffix = getSuffix(plainURI, baseURI);
     if (suffix == null && !plainURI.equals(baseURI)) {
       return plainURI;
     }
     return new URIImpl(getHashURIString(baseURI, hash, suffix));
   } else {
     BNode blankNode = (BNode) resource;
     int n = getBlankNodeNumber(blankNode, blankNodeMap);
     return new URIImpl(expandBaseURI(baseURI) + hash + ".." + n);
   }
 }
Exemple #30
0
 public synchronized BlobObject getBlobObject(final String uri) throws RepositoryException {
   if (blobs == null) throw new RepositoryException("No configured blob store");
   try {
     if (blobVersion == null && isAutoCommit()) {
       return blobs.open(uri);
     } else if (blobVersion == null) {
       URI version = getVersionBundle();
       if (version == null) {
         blobVersion = blobs.newVersion();
       } else {
         blobVersion = blobs.newVersion(version.stringValue());
       }
       return blobVersion.open(uri);
     } else {
       return blobVersion.open(uri);
     }
   } catch (IOException exc) {
     throw new RepositoryException(exc);
   }
 }