import org.openrdf.model.impl.BNodeImpl; //导入依赖的package包/类
public ConstructProjection(Var subjectVar, Var predicateVar, Var objectVar) {
    Preconditions.checkNotNull(subjectVar);
    Preconditions.checkNotNull(predicateVar);
    Preconditions.checkNotNull(objectVar);
    subjName = subjectVar.getName();
    predName = predicateVar.getName();
    objName = objectVar.getName();
    Preconditions.checkNotNull(subjName);
    Preconditions.checkNotNull(predName);
    Preconditions.checkNotNull(objName);
    this.subjVar = subjectVar;
    this.predVar = predicateVar;
    this.objVar = objectVar;
    if((subjVar.isAnonymous() || subjName.startsWith("-anon-")) && subjectVar.getValue() == null) {
        subjValue = Optional.of(new BNodeImpl(""));
    } else {
        subjValue = Optional.ofNullable(subjectVar.getValue());
    }
    predValue = Optional.ofNullable(predicateVar.getValue());
    objValue = Optional.ofNullable(objectVar.getValue());
}
 

import org.openrdf.model.impl.BNodeImpl; //导入依赖的package包/类
/**
 * Read an instance from the stream.  The instance will have been written by the
 * {@link #writeObject(java.io.ObjectOutput, Object)} method.  Implementations are free
 * to create instances of the object read from the stream in any way that they
 * feel like. This could be via constructor, factory or reflection.
 *
 * @param in the object input to read from
 * @return the object instance
 * @throws java.io.IOException            if an I/O error occurs
 * @throws ClassNotFoundException if a class could not be found
 */
@Override
public Value readObject(ObjectInput in) throws IOException, ClassNotFoundException {
    int type = in.readInt();

    String label = DataIO.readString(in);
    switch (type) {
        case TYPE_URI:
            return new URIImpl(label);
        case TYPE_BNODE:
            return new BNodeImpl(label);
        case TYPE_LITERAL:
            String lang  = DataIO.readString(in);
            String dtype  = DataIO.readString(in);

            if(lang != null) {
                return new LiteralImpl(label,lang);
            } else if(dtype != null) {
                return new LiteralImpl(label, new URIImpl(dtype));
            } else {
                return new LiteralImpl(label);
            }
    }
    throw new ClassNotFoundException("could not find class with type "+type);
}
 

import org.openrdf.model.impl.BNodeImpl; //导入依赖的package包/类
private static BNode getBNode(String str) {
    try {
        return new BNodeImpl(str);
    } catch (IllegalArgumentException ex) {
        return null;
    }
}
 

import org.openrdf.model.impl.BNodeImpl; //导入依赖的package包/类
public static Value createValue(String resource) {
    if (isBNode(resource))
        return new BNodeImpl(resource.substring(2));
    Literal literal;
    if ((literal = makeLiteral(resource)) != null)
        return literal;
    if (resource.contains(":") || resource.contains("/") || resource.contains("#")) {
        return new URIImpl(resource);
    } else {
        throw new RuntimeException((new StringBuilder()).append(resource).append(" is not a valid URI, blank node, or literal value").toString());
    }
}
 

import org.openrdf.model.impl.BNodeImpl; //导入依赖的package包/类
private Map<String, BNode> getBNodeMap() {
    Map<String, BNode> bNodeMap = new HashMap<>();
    for(String name: bNodeNames) {
        bNodeMap.put(name, new BNodeImpl(UUID.randomUUID().toString()));
    }
    return bNodeMap;
}
 

import org.openrdf.model.impl.BNodeImpl; //导入依赖的package包/类
/**
 * Returns a unique URI with a human readable prefix that can be used to indicate what the URI
 * represents
 * 
 * @param prefix
 * @return
 */
public static Resource createUniqueBlankNodeUri(String prefix) {
	String normPrefix = prefix;
	if (normPrefix.contains("-")) {
		normPrefix = normPrefix.replaceAll("-", "");
		logger.warn("Illegal blank node prefix detected: '" + prefix
				+ "' cannot contain a hyphen. It has been removed.");
	}
	return new BNodeImpl(normPrefix + UUID.randomUUID().toString().replaceAll("-", ""));
}
 

import org.openrdf.model.impl.BNodeImpl; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Nullable
public <T> T normalize(@Nullable final T object) {
    if (object instanceof Statement) {
        if (!(object instanceof StatementImpl) && !(object instanceof ContextStatementImpl)) {
            final Statement s = (Statement) object;
            return s.getContext() == null ? (T) createStatement(s.getSubject(),
                    s.getPredicate(), s.getObject()) : (T) createStatement(s.getSubject(),
                    s.getPredicate(), s.getObject(), s.getContext());
        }
    } else if (object instanceof URI) {
        if (!(object instanceof URIImpl)) {
            return (T) createURI(((URI) object).stringValue());
        }
    } else if (object instanceof BNode) {
        if (!(object instanceof BNodeImpl)) {
            return (T) createBNode(((BNode) object).getID());
        }
    } else if (object instanceof Literal) {
        if (!(object instanceof StringLiteral) && !(object instanceof NumberLiteral)
                && !(object instanceof BooleanLiteralImpl)
                && !(object instanceof CalendarLiteralImpl)) {
            final Literal l = (Literal) object;
            return l.getLanguage() != null ? (T) createLiteral(l.getLabel(), l.getLanguage())
                    : (T) createLiteral(l.getLabel(), l.getDatatype());
        }
    }
    return object;
}
 

import org.openrdf.model.impl.BNodeImpl; //导入依赖的package包/类
/**
 * Returns a collection of Class instances representing the types that this
 * AdvancedExternalizer can marshall.  Clearly, empty sets are not allowed.
 * The externalizer framework currently requires all individual types to be
 * listed since it does not make assumptions based on super classes or
 * interfaces.
 *
 * @return A set containing the Class instances that can be marshalled.
 */
@Override
public Set<Class<? extends Value>> getTypeClasses() {
    Set<Class<? extends Value>> classes = new HashSet<>();
    classes.add(BNode.class);
    classes.add(URI.class);
    classes.add(Literal.class);
    classes.add(BNodeImpl.class);
    classes.add(URIImpl.class);
    classes.add(LiteralImpl.class);
    classes.add(Value.class);

    return classes;
}
 

import org.openrdf.model.impl.BNodeImpl; //导入依赖的package包/类
@Override
public BNode createBNode() {
    return new BNodeImpl(this.bnodePrefix
            + Long.toString(this.bnodeCounter.getAndIncrement(), 32));
}
 

import org.openrdf.model.impl.BNodeImpl; //导入依赖的package包/类
private BNode newBNode() {
	return new BNodeImpl("" + bnodeCount++);
}