import org.openrdf.model.impl.TreeModel; //导入依赖的package包/类
@Test
public void shouldProperlyConvertGraphToGraphVizModel() throws Exception {
    ValueFactory v = new ValueFactoryImpl();

    Graph graph = new TreeModel();
    graph.add(v.createStatement(
            v.createURI("http://test.urn"),
            v.createURI("http://predicate"),
            v.createLiteral("Test label")
    ));

    graph.add(v.createStatement(
            v.createURI("http://test.urn1"),
            v.createURI("http://predicate1"),
            v.createLiteral("Test label1")
    ));

    String stringForm = new GraphConverter().getStringForm(graph);

    Approvals.verify(stringForm, Paths.get("src/test/resources/approvals/shouldProperlyConvertGraphToGraphVizModel.dot"));
}
 

import org.openrdf.model.impl.TreeModel; //导入依赖的package包/类
@Test
public void shouldProperlyConvertTheDotFormatAndThenReportItInConfigredApplication() throws Exception {
    ValueFactory v = new ValueFactoryImpl();

    Graph graph = new TreeModel();
    graph.add(v.createStatement(
            v.createURI("http://test.urn"),
            v.createURI("http://predicate"),
            v.createLiteral("Test label")
    ));

    graph.add(v.createStatement(
            v.createURI("http://test.urn1"),
            v.createURI("http://predicate1"),
            v.createLiteral("Test label1")
    ));

    Approval<Graph> approval = Approval.of(Graph.class)
            .withConveter(new GraphConverter())
            .withReporter(GraphReporter.getInstance())
            .build();
    approval.verify(graph, Paths.get("src/test/resources/approvals/shouldProperlyConvertTheDotFormatAndThenReportItInConfigredApplication.dot"));
}
 

import org.openrdf.model.impl.TreeModel; //导入依赖的package包/类
/**
 * Write the object reference to the stream.
 *
 * @param output the object output to write to
 * @param object the object reference to write
 * @throws java.io.IOException if an I/O error occurs
 */
@Override
public void writeObject(ObjectOutput output, TreeModel object) throws IOException {
    output.writeInt(object.size());
    for(Statement statement : object) {
        output.writeObject(statement.getSubject());
        output.writeObject(statement.getPredicate());
        output.writeObject(statement.getContext());
        if(statement.getContext() != null) {
            output.writeBoolean(true);
            output.writeObject(statement.getContext());
        } else {
            output.writeBoolean(false);
        }

    }
}
 

import org.openrdf.model.impl.TreeModel; //导入依赖的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 input 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 TreeModel readObject(ObjectInput input) throws IOException, ClassNotFoundException {
    TreeModel model = new TreeModel();

    int size = input.readInt();
    for(int i=0; i<size; i++) {
        Resource subject = (Resource) input.readObject();
        URI predicate = (URI) input.readObject();
        Value object = (Value) input.readObject();

        boolean hasContext = input.readBoolean();
        if(hasContext) {
            Resource context = (Resource) input.readObject();

            model.add(new ContextStatementImpl(subject,predicate,object,context));
        } else {
            model.add(new StatementImpl(subject,predicate,object));
        }
    }

    return null;
}
 

import org.openrdf.model.impl.TreeModel; //导入依赖的package包/类
/**
 * Copy the contents of the given repository over to a newly created model, optionally applying the filters given
 * as variable argument.
 *
 * @param repository
 * @return
 * @throws RepositoryException
 */
public static Model asModel(Repository repository, Predicate<Statement>... filters) throws RepositoryException {
    Model model = new TreeModel();

    RepositoryConnection con = repository.getConnection();
    try {
        con.begin();

        add(model,con.getStatements(null,null,null,true), filters);

        con.commit();
    } catch(RepositoryException ex) {
        con.rollback();
    } finally {
        con.close();
    }

    return model;
}
 

import org.openrdf.model.impl.TreeModel; //导入依赖的package包/类
@RequestMapping(value = "/register", method = RequestMethod.POST)
@ResponseBody
public void register(@RequestHeader("content-type") String contentType,
                     @RequestBody String rdfRegistration,
                     HttpServletResponse response) throws IOException {
    try {
        RDFFormat format = Rio.getParserFormatForMIMEType(contentType);
        RDFParser parser = Rio.createParser(format);
        Model model = new TreeModel();
        StatementCollector handler = new StatementCollector(model);
        parser.setRDFHandler(handler);
        parser.parse(new StringReader(rdfRegistration), "");
        registrationService.register(model);
        response.setStatus(HttpServletResponse.SC_CREATED);
    }
    catch (OpenRDFException ex) {
        response.sendError(HttpServletResponse.SC_BAD_REQUEST, "Could not parse provided registration document");
    }
}
 

import org.openrdf.model.impl.TreeModel; //导入依赖的package包/类
@Override
public Model getMetadata() throws LDFusionToolException {
    if (metadataInput == null) {
        return new EmptyMetadataModel();
    }
    Model metadata = new TreeModel();
    RepositoryResult<Statement> metadataResult;
    try (CloseableRepositoryConnection connection = new CloseableRepositoryConnection(metadataInput.getConnection())) {
        metadataResult = connection.get().getStatements(null, null, null, false);
        while (metadataResult.hasNext()) {
            metadata.add(metadataResult.next());
        }
        return metadata;
    } catch (RepositoryException | DataUnitException e) {
        throw new LDFusionToolException("Error when loading metadata from input", e);
    }
}
 

import org.openrdf.model.impl.TreeModel; //导入依赖的package包/类
/**
 * Creates a model from all the statements in this engine
 * @return
 * @throws RepositoryException
 */
public Model toModel() throws RepositoryException {
	TreeModel model = new TreeModel();

	RepositoryResult<Statement> stmts
			= rc.getStatements( null, null, null, false );
	while ( stmts.hasNext() ) {
		model.add( stmts.next() );
	}

	return model;
}
 

import org.openrdf.model.impl.TreeModel; //导入依赖的package包/类
/**
 * Creates a new File object in the <code>targetDir</code> folder.
 * 
 * @param filename
 * @return
 * @throws StoreConfigException
 * @throws RepositoryException
 */
protected File createJar(String filename) throws Exception {
	Model schema = new TreeModel();
	OntologyLoader ontologies = new OntologyLoader(schema);
	ontologies.loadOntologies(imports);
	OWLCompiler compiler = new OWLCompiler();
	compiler.setModel(schema);
	compiler.setPrefixNamespaces(ontologies.getNamespaces());
	File concepts = getConceptJar(targetDir, filename);
	compiler.createJar(concepts);
	return concepts;
}
 

import org.openrdf.model.impl.TreeModel; //导入依赖的package包/类
@Test
public void graphVerificationExample() {

    Graph graph = new TreeModel();
    // populate our graph with statements(maybe from GraphQueryResult?

    // Note: this is still thread safe...
    Approval<Graph> graphApproval = Approval.of(Graph.class)
            .withConveter(new GraphConverter())
            .withReporter(GraphReporter.getInstance())
            .build();

    // Verify the graph, change the path accordingly
    graphApproval.verify(graph, Paths.get("graph-result.dot"));
}
 

import org.openrdf.model.impl.TreeModel; //导入依赖的package包/类
@Deprecated
public ClientResponse(int httpStatus, Repository triples) {
    this.expires = DateUtils.addDays(new Date(), DEFAULT_EXPIRATION_IN_DAYS);
    this.httpStatus = httpStatus;

    try {
    this.data = ModelCommons.asModel(triples);
    } catch (RepositoryException e) {
        this.data = new TreeModel();
    }
}
 

import org.openrdf.model.impl.TreeModel; //导入依赖的package包/类
@Override
public ClientResponse retrieveResource(String resource, LDClientService client, Endpoint endpoint) throws DataRetrievalException {
    String account = java.net.URI.create(resource.replaceAll(" ", "%20")).getPath().substring(1);
    String prefix = getEndpointSuffix(endpoint);
    try {
        final LdapConnection ldap = openLdapConnection(endpoint);

        Model model = new TreeModel();
        ValueFactory vf = ValueFactoryImpl.getInstance();
        String userDN = buildDN(prefix, account, ldap);

        Map<String, java.util.List<String>> accountData = getAccountData(userDN, ldap);

        final URI subject = vf.createURI(resource);
        for (String attr : MAPPING.keySet()) {
            if (!accountData.containsKey(attr)) {
                continue;
            }

            final PredicateObjectFactory factory = MAPPING.get(attr);
            final URI predicate = factory.createPredicate(vf);

            for (String val : accountData.get(attr)) {
                for (Value object : factory.createObjects(val, vf)) {
                    model.add(vf.createStatement(subject, predicate, object));
                }
            }

        }

        final ClientResponse resp = new ClientResponse(200, model);
        resp.setExpires(new Date());
        return resp;

    } catch (LdapException | CursorException | IOException e) {
        log.warn("could not access LDAP repository: {}", e.getMessage());
        throw new DataRetrievalException(e);
    }
}
 

import org.openrdf.model.impl.TreeModel; //导入依赖的package包/类
/**
 * Refresh and return the resource passed as argument. If the resource is not yet cached or the cache entry is
 * expired or refreshing is forced, the remote resource is retrieved using LDClient and the result stored
 * in the cache. Otherwise the method returns the cached entry. In case a cached entry does not exist, the method
 * returns an empty Model.
 *
 * @param resource the resource to retrieve
 * @param options  options for refreshing
 * @return a Sesame Model holding the triples representing the resource
 */
@Override
public Model get(URI resource, RefreshOpts... options) {
    refresh(resource, options);

    CacheEntry entry =  backend.getEntry(resource);

    if(entry != null) {
        return entry.getTriples();
    } else {
        return new TreeModel();
    }
}
 

import org.openrdf.model.impl.TreeModel; //导入依赖的package包/类
/**
 * Return the cache entry for the given resource, or null if this entry does not exist.
 *
 *
 * @param resource the resource to retrieve the cache entry for
 * @return
 */
@Override
public CacheEntry getEntry(URI resource) {
    try {
        // load metadata from disk
        final File dataFile = FileBackendUtils.getMetaFile(resource, storageDir);
        if (!(dataFile.exists())) return null;
        final CacheEntry ce = FileBackendUtils.readCacheEntry(dataFile, getValueFactory());
        if (FileBackendUtils.isExpired(ce)) return null;

        // read triples for this entry from cache repository
        RepositoryConnection con = cacheRepository.getConnection();
        try {
            con.begin();

            Model triples = new TreeModel();
            ModelCommons.add(triples, con.getStatements(resource,null,null,true));
            ce.setTriples(triples);

            con.commit();
        } catch(RepositoryException ex) {
            con.rollback();
        } finally {
            con.close();
        }

        return ce;
    } catch (IOException | RepositoryException e) {
        log.error("error while loading cache entry from file system:",e);

        return null;
    }
}
 

import org.openrdf.model.impl.TreeModel; //导入依赖的package包/类
/**
 * Return the cache entry for the given resource, or null if this entry does not exist.
 *
 *
 * @param resource the resource to retrieve the cache entry for
 * @return
 */
@Override
public CacheEntry getEntry(URI resource) {
    try {
        try(LDCachingKiWiPersistenceConnection dbcon = persistence.getConnection()) {

            // load cache entry from database
            CacheEntry ce = dbcon.getCacheEntry(resource.stringValue());

            // if entry exists, load triples for the resource from the cache context of the repository
            if(ce != null) {
                SailConnection con = store.getConnection();
                try {
                    con.begin();

                    Model triples = new TreeModel();
                    ModelCommons.add(triples,con.getStatements(resource,null,null,true,store.getValueFactory().createURI(cacheContext)));
                    ce.setTriples(triples);

                    con.commit();
                } catch(SailException ex) {
                    con.rollback();
                } finally {
                    con.close();
                }
            }
            return ce;

        }

    } catch (SailException | SQLException e) {
        log.error("could not retrieve cached triples from repository",e);
    }

    return null;
}
 

import org.openrdf.model.impl.TreeModel; //导入依赖的package包/类
/**
 * Returns metadata for conflict resolution.
 * @return metadata for conflict resolution
 * @throws cz.cuni.mff.odcleanstore.fusiontool.exceptions.LDFusionToolException error
 */
@Override
public Model getMetadata() throws LDFusionToolException {
    Collection<ConstructSource> metadataSources = getConstructSources(config.getMetadataSources());
    Model metadata = new TreeModel();
    for (ConstructSource source : metadataSources) {
        MetadataLoader loader = new MetadataLoader(source);
        loader.loadNamedGraphsMetadata(metadata);
    }
    return metadata;
}
 

import org.openrdf.model.impl.TreeModel; //导入依赖的package包/类
private Model parseChangeSet(String rdfChangeSet, RDFFormat rdfFormat) throws IOException, OpenRDFException {
    RDFParser rdfParser = Rio.createParser(rdfFormat);
    Model changeSet = new TreeModel();
    StatementCollector collector = new StatementCollector(changeSet);
    rdfParser.setRDFHandler(collector);
    rdfParser.parse(new StringReader(rdfChangeSet), "");
    return changeSet;
}
 

import org.openrdf.model.impl.TreeModel; //导入依赖的package包/类
public Model assembleChangeset(Statement affectedStatement, Statement secondaryStatement, String changeType) {
    Model model = new TreeModel(new HashSet<Namespace>(Arrays.asList(Namespaces.RSINE_NAMESPACE, Namespaces.CS_NAMESPACE)));

    URI changeSet = valueFactory.createURI(
        Namespaces.RSINE_NAMESPACE.getName(),
        "cs" +System.currentTimeMillis()+"_" +Math.round(Math.random() * 1000));

    model.add(new StatementImpl(changeSet,
        RDF.TYPE,
        valueFactory.createURI(Namespaces.CS_NAMESPACE.getName(), "ChangeSet")));
    model.add(new StatementImpl(changeSet,
        valueFactory.createURI(Namespaces.CS_NAMESPACE.getName(), "createdDate"),
        valueFactory.createLiteral(new Date())));
    model.add(new StatementImpl(changeSet,
        valueFactory.createURI(Namespaces.RSINE_NAMESPACE.getName(), "createdTimeStamp"),
        valueFactory.createLiteral(System.currentTimeMillis())));
    
    if (changeType.equals(ChangeTripleService.CHANGETYPE_REMOVE)) {
        addActionStatement(model, changeSet, affectedStatement, "removal");
    }
    else if (changeType.equals(ChangeTripleService.CHANGETYPE_ADD)) {
        addActionStatement(model, changeSet, affectedStatement, "addition");
    }
    else if (changeType.equals(ChangeTripleService.CHANGETYPE_UPDATE)) {
        addActionStatement(model, changeSet, affectedStatement, "removal");
        addActionStatement(model, changeSet, secondaryStatement, "addition");
    }
    
    return model;
}
 

import org.openrdf.model.impl.TreeModel; //导入依赖的package包/类
public static Model createModelFromResourceFile(String fileName, RDFFormat format)
    throws RDFParseException, IOException, RDFHandlerException
{
    RDFParser rdfParser = Rio.createParser(format);
    Model model = new TreeModel();
    StatementCollector collector = new StatementCollector(model);
    rdfParser.setRDFHandler(collector);
    rdfParser.parse(Rsine.class.getResourceAsStream(fileName), "");
    return model;
}
 

import org.openrdf.model.impl.TreeModel; //导入依赖的package包/类
private void readChangeSet() throws RDFParseException, IOException, RDFHandlerException {
    RDFParser rdfParser = Rio.createParser(RDFFormat.RDFXML);
    changeSet = new TreeModel();
    StatementCollector collector = new StatementCollector(changeSet);
    rdfParser.setRDFHandler(collector);
    rdfParser.parse(Rsine.class.getResourceAsStream("/changeset.rdf"), "");
}