Java MemoryStore类代码示例

import org.eclipse.rdf4j.sail.memory.MemoryStore; //导入依赖的package包/类
private LDPath<Value> createLdpath(Model model) {
  Repository repository = new SailRepository(new MemoryStore());
  Rdf4jRepositoryBackend repositoryBackend;

  try {
    repository.initialize();
    repositoryBackend = new Rdf4jRepositoryBackend(repository);

    final RepositoryConnection connection = repository.getConnection();
    connection.add(model);
    connection.close();
  } catch (RepositoryException re) {
    throw new LdPathExecutorRuntimeException("Unable to initialize RDF4JRepository.", re);
  }

  LDPath<Value> result = new LDPath<>(repositoryBackend, LD_PATH_CONFIG);

  result.registerFunction(new SortByPropertyFunction<>(ldpathNamespaces));

  return result;
}
 

import org.eclipse.rdf4j.sail.memory.MemoryStore; //导入依赖的package包/类
/**
 * Initialize repository and load triples
 * 
 * @throws IOException 
 */
public void init() throws IOException {
    LOG.debug("Initialize repository");
    repo = new SailRepository(new MemoryStore());
    repo.initialize();
    
    Optional<RDFFormat> fmt = Rio.getParserFormatForFileName(path.toString());
    if (!fmt.isPresent()) {
        throw new IOException("Could not determine file type");
    }
    
    LOG.debug("Adding triples");
    BufferedReader r = Files.newBufferedReader(path);
    
    Date start = new Date();
    RepositoryConnection con = repo.getConnection();
    try {
        con.add(r, BASE_URI, fmt.get());
    } catch (RepositoryException cve) {
        LOG.error("Error adding triples", cve);
    }
    LOG.info("{} triples loaded in {} ms", 
            con.size(), new Date().getTime() - start.getTime());
            
    if(con.isEmpty()) {
        LOG.error("No statements loaded");
        close();
    }
}
 

import org.eclipse.rdf4j.sail.memory.MemoryStore; //导入依赖的package包/类
@Bean
public ConfigurationBackend configurationBackend(
    @Value("classpath:/model/elmo.trig") Resource elmoConfiguration,
    @Value("#{applicationProperties.resourcePath}") String resourcePath,
    @Value("classpath:/model/elmo-shapes.trig") Resource elmoShapes,
    ShaclValidator shaclValidator) {
  return new FileConfigurationBackend(elmoConfiguration, new SailRepository(new MemoryStore()),
      resourcePath, elmoShapes, shaclValidator);
}
 

import org.eclipse.rdf4j.sail.memory.MemoryStore; //导入依赖的package包/类
@Bean(name="repository", initMethod = "initialize",
        destroyMethod = "shutDown")
public Repository repository(final Environment env)
        throws RepositoryException, IOException, RDFParseException {
    // For tets we use only in memory
    Sail store = new MemoryStore();
    return new SailRepository(store);
}
 

import org.eclipse.rdf4j.sail.memory.MemoryStore; //导入依赖的package包/类
/**
 * Creates a local in-memory Sesame repository which is disposed when the VM shuts down.
 */
private Repository createInMemoryRepository(Configuration configuration) {
    LOG.trace("Creating local in-memory repository.");
    final MemoryStore ms = new MemoryStore();
    if (configuration.is(SesameConfigParam.USE_INFERENCE)) {
        return new SailRepository(new ForwardChainingRDFSInferencer(ms));
    } else {
        return new SailRepository(ms);
    }
}
 

import org.eclipse.rdf4j.sail.memory.MemoryStore; //导入依赖的package包/类
/**
 * RDF store
 * 
 * @param f file to be used as storage
 */
public Storage(File f) {
    logger.info("Opening RDF store " + f.getAbsolutePath());
    
    MemoryStore mem = new MemoryStore(f);
    mem.setPersist(false);
    repo = new SailRepository(mem);
}
 

import org.eclipse.rdf4j.sail.memory.MemoryStore; //导入依赖的package包/类
/**
   * Main program
   * 
   * @param args 
   */
  public static void main(String[] args)  {
      logger.info("-- START --");
      if (args.length < 2) {
          logger.error("No input or output file");
          System.exit(-1);
      }
      
      Optional<RDFFormat> fmtin = Rio.getParserFormatForFileName(args[0]);
      if(!fmtin.isPresent()) {
          logger.error("No parser for input {}", args[0]);
          System.exit(-2);
      }
      
      int code = 0;
      Repository repo = new SailRepository(new MemoryStore());
repo.initialize();

Serializer s = getSerializer();		
s.setOutputFile(new File(args[1]));
	
      try (RepositoryConnection con = repo.getConnection()) {
          con.add(new File(args[0]), "http://data.gov.be", fmtin.get());
	
	XMLStreamWriter w = s.getXMLStreamWriter();

	w.writeStartDocument();
	writeCatalog(w, con);
	w.writeEndDocument();
	
	w.close();		
} catch (IOException|XMLStreamException|SaxonApiException ex) {
          logger.error("Error converting", ex);
          System.exit(-1);
      } finally {
	repo.shutDown();
}
  }
 

import org.eclipse.rdf4j.sail.memory.MemoryStore; //导入依赖的package包/类
@Override
public RDF4JGraph createGraph() {
    final Sail sail = new MemoryStore();
    final Repository repository = new SailRepository(sail);
    repository.initialize();
    return rdf4jFactory.asGraph(repository);
}
 

import org.eclipse.rdf4j.sail.memory.MemoryStore; //导入依赖的package包/类
@Override
@Test
public void testRemoveAll() throws Exception {
	Repository repo = new SailRepository(new MemoryStore());
	repo.initialize();
	RepositoryModelSet modelSet = new RepositoryModelSet(repo);
	modelSet.open();
	URI context1 = new URIImpl("uri:context1");
	URI context2 = new URIImpl("uri:context2");
	modelSet.addStatement(context1, new URIImpl("uri:r1"), new URIImpl(
			"uri:p1"), new URIImpl("uri:r2"));
	modelSet.addStatement(context1, new URIImpl("uri:r1"), new URIImpl(
			"uri:p1"), new URIImpl("uri:r3"));
	modelSet.addStatement(context2, new URIImpl("uri:r4"), new URIImpl(
			"uri:p2"), new URIImpl("uri:r5"));
	modelSet.addStatement(context2, new URIImpl("uri:r4"), new URIImpl(
			"uri:p2"), new URIImpl("uri:r6"));
	Model model1 = modelSet.getModel(context1);
	model1.open();
	Model model2 = modelSet.getModel(context2);
	model2.open();
	assertEquals(4, modelSet.size());
	assertEquals(2, model1.size());
	assertEquals(2, model2.size());

	model2.removeAll();

	assertEquals(2, modelSet.size());
	assertEquals(2, model1.size());
	assertEquals(0, model2.size());
	model1.close();
	model2.close();
}
 

import org.eclipse.rdf4j.sail.memory.MemoryStore; //导入依赖的package包/类
public static Repository createRepository(Collection<Statement> statements) throws RepositoryException {
    Repository repository = new SailRepository(new MemoryStore());
    repository.initialize();
    RepositoryConnection connection = repository.getConnection();
    connection.add(statements);
    connection.close();
    return repository;
}
 

import org.eclipse.rdf4j.sail.memory.MemoryStore; //导入依赖的package包/类
@Before
public void before() {
  repository = new SailRepository(new MemoryStore());
  repository.initialize();
  backend = new Rdf4jRepositoryBackend(repository);
}
 

import org.eclipse.rdf4j.sail.memory.MemoryStore; //导入依赖的package包/类
@Before
public void initVars() {
  elmoConfiguration = new ClassPathResource("/model/elmo.trig");
  elmoShapes = new ClassPathResource("/model/elmo-shapes.trig");
  sailRepository = new SailRepository(new MemoryStore());
}
 

import org.eclipse.rdf4j.sail.memory.MemoryStore; //导入依赖的package包/类
@Before
public void initVars() throws IOException {
  elmoConfiguration = new ClassPathResource("/model/elmo.trig");
  elmoShapes = new ClassPathResource("/model/elmo-shapes.trig");
  sailRepository = new SailRepository(new MemoryStore());
}
 

import org.eclipse.rdf4j.sail.memory.MemoryStore; //导入依赖的package包/类
@Test
public void testWriteAndFind() throws Exception {
    Repository repo = new SailRepository(new MemoryStore());
    repo.initialize();

    try (RepositoryConnection connection = repo.getConnection()) {

        ValueFactory vf = SimpleValueFactory.getInstance();

        String ex = "http://example.org/";

        IRI lilie = vf.createIRI(ex, "Lilie");

        connection.add(lilie, FOAF.NAME, vf.createLiteral("Lilie"));
        connection.add(lilie, FOAF.MBOX, vf.createIRI("mailto:[email protected]"));
        connection.add(lilie, FOAF.KNOWS, vf.createIRI(ex, "Bob"));

        boolean hasStatement = connection.hasStatement(vf.createIRI(ex, "Lilie"), null, null, false);
        assertTrue(hasStatement);

        RepositoryResult<Statement> statements = connection.getStatements(vf.createIRI(ex, "Lilie"), FOAF.NAME, null);

        assertEquals("Lilie", statements.next().getObject().stringValue());
    }

}
 

import org.eclipse.rdf4j.sail.memory.MemoryStore; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    this.store = new SailRepository(new MemoryStore());
    store.initialize();
}