How to use

createBNode

method

in

org.eclipse.rdf4j.model.ValueFactory

/**
 * Creates a {@link BNode}.
 * @param id string representation of the {@link org.eclipse.rdf4j.model.BNode}
 * @return the valid {@link org.eclipse.rdf4j.model.BNode}
 */
// TODO: replace this with all occurrences of #getBNode()
public static BNode bnode(String id) {
  return valueFactory.createBNode(id);
}

/**
 * @return a <code>bnode</code> with unique id.
 */
public static BNode bnode() {
  return valueFactory.createBNode();
}

@Override
public BNode createBNode(String id) {
  if (id == null)
    return null;
  return wrappedFactory.createBNode(id);
}

private Resource getResource(String s, ValueFactory vf) {
  // taken from org.eclipse.rdf4j.model.impl.SimpleIRI
  // explicit storage of blank nodes in the graph to be considered
  if(s.indexOf(58) >= 0){
    return vf.createIRI(s);
  } else{
    return vf.createBNode(s);
  }
}

private BNode readBnode()
  throws IOException
{
  String bnodeID = readString();
  return valueFactory.createBNode(bnodeID);
}

/**
 * Creates a new {@link BNode} object.
 */
@Deprecated
protected BNode createBNode() throws RDFParseException {
  try {
    return valueFactory.createBNode();
  } catch (Exception e) {
    reportFatalError(e);
    return null; // required by compiler
  }
}

/**
 * Creates a new {@link BNode} object.
 */
@Deprecated
protected BNode createBNode() throws RDFParseException {
  try {
    return valueFactory.createBNode();
  } catch (Exception e) {
    reportFatalError(e);
    return null; // required by compiler
  }
}

public JSONLDInternalTripleCallback(RDFHandler nextHandler, ValueFactory vf) {
  this(nextHandler, vf, new ParserConfig(), new ParseErrorLogger(), nodeID -> vf.createBNode(nodeID),
      () -> vf.createBNode());
}

@Override
public ValueConstant visit(ASTBNode node, Object data)
  throws VisitorException
{
  return new ValueConstant(valueFactory.createBNode(node.getID()));
}

@Override
public ValueConstant visit(ASTBNode node, Object data)
  throws VisitorException
{
  return new ValueConstant(valueFactory.createBNode(node.getID()));
}

  /**
   * @param node subject or object node
   * @param vf value factory
   * @return blank node
   */
  protected static BNode node(final RDFNode node, final ValueFactory vf) {
    if (node.getIRI().getNamespace().startsWith("_:")) {
      return vf.createBNode(node.getIRI().toString().substring(2));
    }
    return vf.createBNode(node.getIRI().toString());
  }
}

  /**
   * @param node subject or object node
   * @param vf value factory
   * @return blank node
   */
  protected static BNode node(final RDFNode node, final ValueFactory vf) {
    if (node.getIRI().getNamespace().startsWith("_:")) {
      return vf.createBNode(node.getIRI().toString().substring(2));
    }
    return vf.createBNode(node.getIRI().toString());
  }
}

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

private String generateIdentifier(RepositoryConnection conn, KnowledgeBase kb)
{
  ValueFactory vf = conn.getValueFactory();
  // default value of basePrefix is IriConstants.INCEPTION_NAMESPACE
  String basePrefix = kb.getBasePrefix();
  return basePrefix + vf.createBNode().getID();
}

private Set<Statement> reifyQualifier(KnowledgeBase kb, KBQualifier aQualifier)
{
  Resource statementId = vf.createBNode(aQualifier.getKbStatement().getStatementId());
  KBHandle qualifierProperty = aQualifier.getKbProperty();
  IRI qualifierPredicate = vf.createIRI(qualifierProperty.getIdentifier());
  Value qualifierValue = valueMapper.mapQualifierValue(aQualifier, vf);
  Statement qualifierStatement = vf
    .createStatement(statementId, qualifierPredicate, qualifierValue);
  Set<Statement> originalStatements = new HashSet<>();
  originalStatements.add(qualifierStatement); //id P V
  return originalStatements;
}

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);
}

private Set<Statement> reifyQualifier(KnowledgeBase kb, KBQualifier aQualifier)
{
  Resource statementId = vf.createBNode(aQualifier.getKbStatement().getStatementId());
  KBHandle qualifierProperty = aQualifier.getKbProperty();
  IRI qualifierPredicate = vf.createIRI(qualifierProperty.getIdentifier());
  Value qualifierValue = valueMapper.mapQualifierValue(aQualifier, vf);
  Statement qualifierStatement = vf
    .createStatement(statementId, qualifierPredicate, qualifierValue);
  Set<Statement> originalStatements = new HashSet<>();
  originalStatements.add(qualifierStatement); //id P V
  return originalStatements;
}

  private void addQueryNode(Model m, Resource implNode, IRI predicate, String queryText) {
    if (null != queryText) {
      ValueFactory factory = SimpleValueFactory.getInstance();
      BNode queryNode = factory.createBNode();
      m.add(implNode, predicate, queryNode);
      m.add(queryNode, RDF.TYPE, SP.CONSTRUCT_CLASS);
      m.add(queryNode, SP.TEXT_PROPERTY, factory.createLiteral(queryText));
    }
  }
}

private void visitWhere(TupleExpr where)
  throws RDFHandlerException
{
  Resource whereBNode = valueFactory.createBNode();
  handler.handleStatement(valueFactory.createStatement(subject, SP.WHERE_PROPERTY, whereBNode));
  isSubQuery = true; // further projection elements are for
            // sub-queries
  ListContext ctx = newList(whereBNode);
  where.visit(this);
  endList(ctx);
}

@Override
public void meet(InsertData node)
  throws RDFHandlerException
{
  Resource dataList = valueFactory.createBNode();
  handler.handleStatement(valueFactory.createStatement(subject, SP.DATA_PROPERTY, dataList));
  ListContext dataCtx = newList(dataList);
  renderDataBlock(node.getDataBlock());
  endList(dataCtx);
}