How to use

Graph

in

com.hp.hpl.jena.graph

  public void send(Triple triple)
  {
    graph.add(triple) ;
  }
}

/**
 * This method will return null until the source iterator is exhausted.
 *
 * @return The elements that turned out not to be common to the two inputs.
 */
public Iterator<Triple> notCommon() {
  return source.hasNext() ? null : notCommon.find(ANY, ANY, ANY);
}

/**
 * Remove the triple, ie, remove it from the adds, add it to the removals.
 */
@Override
public void performDelete(Triple t)
{
  L.delete(t) ;
  if (base.contains(t)) 
    R.add(t) ;
}

/**
  Add a triple to the difference: add it to the left operand, and remove it from the 
  right operand.
*/
@Override public void performAdd( Triple t )
  {
  L.add( t );
  R.delete( t );
  }

private void clearGraph(Graph graph) {
  if ( !graph.isEmpty() )
    graph.clear() ;
}

static private void addAll(Graph srcGraph, Graph dstGraph)
{
  Iterator<Triple> triples = srcGraph.find(Node.ANY, Node.ANY, Node.ANY) ;
  for ( Triple t : Iter.iter(triples) )
    dstGraph.add(t) ;
}

public static void removeAll(Graph g, Node s, Node p, Node o) {
  ExtendedIterator<Triple> it = g.find(s, p, o);
  try {
    while (it.hasNext()) {
      Triple t = it.next();
      g.delete(t);
      it.remove();
    }
  } finally {
    it.close();
  }
}

@Override
public void write(Kryo kryo, Output output, Graph object) {
  output.writeInt(object.size());
  final Iterator<Triple> it = object.find(null, null, null);
  while (it.hasNext()) {
    final Triple next = it.next();
    kryo.writeClassAndObject(output, next);
  }
}

public boolean handledRemove(Triple triple)
{
  graph.delete(triple) ;
  return true ;
}

@Override
public int size()
{
  return graph.size() ;
}

  public static boolean isContainer(Graph graph, Node container, Node containerType)
  {
//        if ( container.isLiteral() )
//            return false ;
    
    if ( containerType == null )
      return  isContainer(graph, container, BAG) ||
          isContainer(graph, container, ALT) ||
          isContainer(graph, container, SEQ) ;
    
    return graph.contains(container, RDFtype, containerType) ; 
  }
   

@Override
public PrefixMapping getPrefixMapping()
{
  return graph.getPrefixMapping() ;
}

@Override
public void close()
  {
  L.close();
  R.close();
  this.closed = true;
  }
  

@Test public void load_dataset_01()
{
  DatasetGraphTDB dsg = TDBFactory.createDatasetGraph() ;
  TDBLoader.load(dsg, DIR+"data-1.nq", false) ;
  assertTrue(dsg.getDefaultGraph().isEmpty()) ;
  assertEquals(1, dsg.getGraph(g).size()) ;
}

@Override
public boolean isEmpty()
{
  return graph.isEmpty() ;
}

public void clearGraph()
{ 
  if ( graph != null )
  {
    Iterator<Triple> iter = Iter.convert(graph.find(Node.ANY, Node.ANY, Node.ANY)) ;
    List<Triple> triples = Iter.toList(iter) ;
    
    for ( Triple t : triples )
      graph.delete(t) ;
  }
}

@Override
public void write(Kryo kryo, Output output, Graph object) {
  output.writeInt(object.size());
  final Iterator<Triple> it = object.find(null, null, null);
  while (it.hasNext()) {
    final Triple next = it.next();
    kryo.writeClassAndObject(output, next);
  }
}

/**
  To remove a triple, remove it from <i>both</i> operands.
*/
@Override public void performDelete( Triple t )
  {
  L.delete( t );
  R.delete( t );
  }

ReorderStatsHandler(Graph graph, GraphStatisticsHandler stats)
{
  this.stats = stats ;
  N = graph.size() ;
  // Note: when these are too badly wrong, the app can supply a statistics file. 
  TERM_S = 10 ;       // Wild guess: "An average subject has 10 properties".
  TERM_P = N/10 ;     // Wild guess: "An average vocabulary has 10 properties"
  TERM_O = 20 ;       // Wild guess: "An average object is in 20 triples".
  TERM_TYPE = N/10 ;  // Wild guess: "An average class has 1/10 of the resources."
}
 

  @Override
  public boolean doCheck( Node n, EnhGraph g ) {
    return g.asGraph().contains( n, RDF.type.asNode(), OWL.Ontology.asNode() );
  }
}