How to use

createIRI

method

in

org.eclipse.rdf4j.model.ValueFactory

/**
 * Creates a {@link org.eclipse.rdf4j.model.IRI}.
 * @param iri a base string for the {@link org.eclipse.rdf4j.model.IRI}
 * @return a valid {@link org.eclipse.rdf4j.model.IRI}
 */
public static org.eclipse.rdf4j.model.IRI iri(String iri) {
  return valueFactory.createIRI(iri);
}

/**
 * Creates a {@link org.eclipse.rdf4j.model.IRI}.
 * @param namespace a base namespace for the {@link org.eclipse.rdf4j.model.IRI}
 * @param localName a local name to associate with the namespace
 * @return a valid {@link org.eclipse.rdf4j.model.IRI}
 */
public static org.eclipse.rdf4j.model.IRI iri(String namespace, String localName) {
  return valueFactory.createIRI(namespace, localName);
}

/*******************************************************************************************************************
 *
 *
 ******************************************************************************************************************/
@Nonnull
public static IRI uriFor (final @Nonnull URL url)
 {
  return FACTORY.createIRI(url.toString());
 }

public void writeTripleUriObject(String subjectUri, IRI predicate,
    String objectUri) throws RDFHandlerException {
  writeTripleValueObject(subjectUri, predicate,
      factory.createIRI(objectUri));
}

/**
 * @return a valid sesame IRI or null if any exception occurred
 */
@Override
public IRI createIRI(String namespace, String localName) {
  if (namespace == null || localName == null)
    return null;
  return wrappedFactory.createIRI(RDFUtils.fixIRIWithException(namespace), localName);
}

private IRI readURI()
  throws IOException
{
  String uri = readString();
  return valueFactory.createIRI(uri);
}

@Nonnull
public static IRI trackIriFor (final @Nonnull Id id)
 {
  return FACTORY.createIRI("urn:bluemarine:track:" + id.stringValue());
 }

@Nonnull
public static IRI recordIriFor (final @Nonnull Id id)
 {
  return FACTORY.createIRI("urn:bluemarine:record:" + id.stringValue());
 }

 @Nonnull
 public static IRI artistIriFor (final @Nonnull Id id)
  {
   return FACTORY.createIRI("urn:bluemarine:artist:" + id.stringValue());
  }
}

public SpinMagicPropertyInterpreter(SpinParser parser, TripleSource tripleSource,
    TupleFunctionRegistry tupleFunctionRegistry, AbstractFederatedServiceResolver serviceResolver)
{
  this.parser = parser;
  this.tripleSource = tripleSource;
  this.tupleFunctionRegistry = tupleFunctionRegistry;
  this.serviceResolver = serviceResolver;
  this.spinServiceUri = tripleSource.getValueFactory().createIRI(SPIN_SERVICE);
}

private IRI readQName()
  throws IOException
{
  int nsID = in.readInt();
  String localName = readString();
  return valueFactory.createIRI(namespaceArray[nsID], localName);
}

@Override
public IRI createIRI(String iri) {
  try {
    if (!new ParsedIRI(iri).isAbsolute()) {
      throw new IllegalArgumentException("IRI must be absolute");
    }
    return delegate.createIRI(iri);
  }
  catch (URISyntaxException e) {
    throw new IllegalArgumentException(e);
  }
}

/**
 * @param iri IRI to fix
 * @return a valid sesame IRI or null if any exception occurred
 */
public IRI fixIRI(String iri) {
  try {
    return wrappedFactory.createIRI(RDFUtils.fixIRIWithException(iri));
  } catch (Exception e) {
    reportError(e);
    return null;
  }
}

private Resource getContext(String repositoryID) {
  String location;
  try {
    location = manager.getLocation().toURI().toString();
  }
  catch (MalformedURLException | URISyntaxException e) {
    assert false;
    location = "urn:" + repositoryID;
  }
  String url = Protocol.getRepositoryLocation(location, repositoryID);
  return getValueFactory().createIRI(url + "#" + repositoryID);
}

@Override
public ValueConstant visit(ASTURI node, Object data)
  throws VisitorException
{
  return new ValueConstant(valueFactory.createIRI(node.getValue()));
}

public void applyRootConcepts(KnowledgeBaseProfile aProfile)
{
  if (aProfile.getRootConcepts() == null) {
    setRootConcepts(new ArrayList<>());
  }
  else {
    ValueFactory vf = SimpleValueFactory.getInstance();
    for (String rootConcept : aProfile.getRootConcepts()) {
      rootConcepts.add(vf.createIRI(rootConcept));
    }
  }
}

  private Function getFunction(String name, TripleSource tripleSource, FunctionRegistry functionRegistry)
    throws RDF4JException
  {
    Function func = functionRegistry.get(name).orElse(null);
    if (func == null) {
      IRI funcUri = tripleSource.getValueFactory().createIRI(name);
      func = parser.parseFunction(funcUri, tripleSource);
      functionRegistry.add(func);
    }
    return func;
  }
}

public static Resource getResource(ObjectConstant obj) {
  if (obj instanceof BNode)
    return fact.createBNode(((BNode)obj).getName());
  else if (obj instanceof IRIConstant)
    return fact.createIRI(((IRIConstant) obj).getIRI().getIRIString());
  else
    return null;
    //throw new IllegalArgumentException("Invalid constant as subject!" + obj);
}

@Override
public Resource export(Model m) {
  Resource implNode = super.export(m);
  m.setNamespace("sparql", NAMESPACE);
  if (getQueryEndpointUrl() != null) {
    m.add(implNode, QUERY_ENDPOINT, vf.createIRI(getQueryEndpointUrl()));
  }
  if (getUpdateEndpointUrl() != null) {
    m.add(implNode, UPDATE_ENDPOINT, vf.createIRI(getUpdateEndpointUrl()));
  }
  return implNode;
}

@Override
public final void addNonLiteral(String subj, String pred, String obj, String graph) {
  if (graph == null) {
    addNonLiteral(subj, pred, obj);
  } else {
    addQuad(convertNonLiteral(subj), valueFactory.createIRI(pred), convertNonLiteral(obj),
        convertNonLiteral(graph));
  }
}