/** Answer a memory-based Graph with the Standard reification style. */ public static Graph createDefaultGraph() { return Factory.createGraphMem( ); }
/** Create a graph - always the Jena default graph type */ public static Graph createJenaDefaultGraph() { return Factory.createDefaultGraph() ; }
/** Create a graph that is a Jena memory graph * @see #createDefaultGraph */ public static Graph createGraphMem() { return Factory.createGraphMem() ; }
/** Create a graph - always the Jena default graph type */ public static Graph createJenaDefaultGraph() { return Factory.createDefaultGraph() ; }
/** Create a graph that is a Jena memory graph * @see #createDefaultGraph */ public static Graph createGraphMem() { return Factory.createGraphMem() ; }
public PelletInfGraph(KnowledgeBase kb, PelletReasoner pellet, GraphLoader loader) { this( kb, Factory.createDefaultGraph(), pellet, loader ); }
public Delta(Graph base) { super(Factory.createGraphMem(), Factory.createGraphMem()) ; this.base = base ; }
public static Graph createDefaultGraph() { return new RandomOrderGraph(Factory.createDefaultGraph()); } public static Model createDefaultModel() {
public Graph create() { return Factory.createGraphMem(); }
/** Parse a file and return a graph */ public static Graph loadGraph(String filename, Lang lang, String baseURI) { if ( lang == null ) lang = Lang.guess(filename, Lang.NTRIPLES) ; Graph g = Factory.createDefaultGraph() ; read(filename, g, lang, baseURI) ; return g ; }
/** Answer a new memory-based model with the given reification style @deprecated Hidden partial reifications not supported -- only style "Standard" */ @Deprecated public static Model createDefaultModel( ReificationStyle style ) { return new ModelCom( Factory.createGraphMem( ) ); }
/** * Get the single static precomputed rule closure. */ @Override protected synchronized InfGraph getPreload() { // We only support this in HYBRID mode if (cachePreload && preload == null && mode == HYBRID) { preload = new FBRuleInfGraph( this, rules, null, Factory.createDefaultGraph() ); if (enableTGCCaching) ((FBRuleInfGraph)preload).setUseTGCCache(); preload.prepare(); } return preload; }
/** Answer a new graph which is the reachable subgraph from <code>node</code> in <code>graph</code> with the terminating condition given by the TripleBoundary passed to the constructor. */ public Graph extract( Node node, Graph graph ) { return extractInto( Factory.createGraphMem(), node, graph ); }
Graph explanationGraph = Factory.createDefaultGraph();
/** Answer a fresh Model with the default specification. */ public static Model createDefaultModel() { return new ModelCom( Factory.createGraphMem( ) ); }
private Graph loadSchema( Resource root, Assembler a ) { Graph result = Factory.createDefaultGraph(); for (StmtIterator models = root.listProperties( JA.ja_schema ); models.hasNext();) loadSchema( result, a, getResource( models.nextStatement() ) ); return result; }
/** * Constructor. * @param graph the inference graph which owns this context. */ public BFRuleContext(ForwardRuleInfGraphI graph) { this.graph = graph; env = new BindingStack(); stack = new ArrayList<Triple>(); pending = new ArrayList<Triple>(); pendingCache = Factory.createGraphMem(); }
/** Parse a string and return the triples in a graph (in-memory) (convenience operation)*/ public static Graph graphFromString(String string, Lang language, String baseURI) { Graph g = Factory.createDefaultGraph() ; Sink<Triple> sink = graphSink(g) ; Tokenizer tokenizer = TokenizerFactory.makeTokenizerString(string) ; LangRIOT parser = RiotReader.createParserTriples(tokenizer, language, baseURI, sink) ; parser.parse() ; sink.flush(); return g ; }
/** Create a graph and record it with the given name in the local map. */ @Override public Graph createGraph( String name, boolean strict ) { GraphMemBase already = (GraphMemBase) graphs.get( name ); if (already == null) { Graph result = Factory.createGraphMem( ); graphs.put( name, result ); return result; } else if (strict) throw new AlreadyExistsException( name ); else return already.openAgain(); }
/** * Create the graph used to hold the deductions. Can be overridden * by subclasses that need special purpose graph implementations here. * Assumes the graph underlying fdeductions and associated SafeGraph * wrapper can be reused if present thus enabling preservation of * listeners. */ protected Graph createDeductionsGraph() { if (fdeductions != null) { Graph dg = fdeductions.getGraph(); if (dg != null) { // Reuse the old graph in order to preserve any listeners safeDeductions.clear(); return dg; } } Graph dg = Factory.createGraphMem( ); safeDeductions = new SafeGraph( dg ); return dg; }