How to use

IsoMatcher

in

org.apache.jena.sparql.util

private boolean isomorphic(DatasetGraph dsg1, DatasetGraph dsg2) {
  return IsoMatcher.isomorphic(dsg1, dsg2) ;
}

public static boolean isomorphic(DatasetGraph dsg1, DatasetGraph dsg2) {
  List<Tuple<Node>> x1 = tuplesQuads(dsg1.find()) ;
  List<Tuple<Node>> x2 = tuplesQuads(dsg2.find()) ;
  
  IsoMatcher matcher = new IsoMatcher(x1, x2, NodeUtils.sameTerm) ;
  return matcher.match() ;
}

private List<Cause> match(Tuple<Node> t1, Collection<Tuple<Node>> g2, Mapping mapping) {
  List<Cause> matches = new ArrayList<>() ;
  for ( Tuple<Node> t2 : g2 ) {
    // No - multiple bNodes.
    Mapping step = gen(t1, t2, mapping) ;
    if (step != null) { 
      Cause c = new Cause(t2, step) ;
      matches.add(c) ;
    }
  }
  return matches ;
}

public static boolean isomorphic(List<Tuple<Node>> x1, List<Tuple<Node>> x2) {
  x1 = new ArrayList<>(x1) ;
  x2 = new ArrayList<>(x2) ;
  IsoMatcher matcher = new IsoMatcher(x1, x2, NodeUtils.sameTerm) ;
  return matcher.match() ;
}

public static boolean isomorphic(Graph g1, Graph g2) {
  List<Tuple<Node>> x1 = tuplesTriples(g1.find(null, null, null)) ;
  List<Tuple<Node>> x2 = tuplesTriples(g2.find(null, null, null)) ;
  
  IsoMatcher matcher = new IsoMatcher(x1, x2, NodeUtils.sameTerm) ;
  return matcher.match() ;
}

public boolean match() {
  return match(tuples1, tuples2, Mapping.rootMapping) ;
}

  System.out.println("  t1 = "+t1) ;
tuples.remove(t1) ;
List<Cause> causes = match(t1, tuples2, mapping) ;
for ( Cause c : causes ) {
  if ( DEBUG ) 
  if ( tuples2.isEmpty() )
    return true ;
  if ( match(tuples, tuples2, c.mapping) ) {
    if ( DEBUG ) 
      System.out.println("Yes") ;

private void test$(List<Tuple<Node>> t1, List<Tuple<Node>> t2, boolean iso)
{
  boolean b = IsoMatcher.isomorphic(t1, t2) ;
  if ( b != iso ) {
    System.out.println("====") ;
    System.out.println(t1) ;
    System.out.println("----") ;
    System.out.println(t2) ;
    System.out.println("Expected: "+iso+" ; got: "+b) ;
  }
  assertEquals(iso, b) ;
}

private Mapping gen(Tuple<Node> t1, Tuple<Node> t2, Mapping _mapping) {
  if ( t1.len() != t2.len() )
    return null ;
  
  Mapping mapping = _mapping ;
  for ( int i = 0 ; i < t1.len() ; i++ ) {
    Node n1 = t1.get(i) ;
    Node n2 = t2.get(i) ;
    if ( ! nodeTest.equal(n1, n2) ) {
      mapping = gen(n1, n2, mapping) ;
      if ( mapping == null )
        return null ;
    }
  }            
  return mapping ;
}

private static boolean isIsomorphic(Dataset ds1, Dataset ds2)
{
  return IsoMatcher.isomorphic(ds1.asDatasetGraph(), ds2.asDatasetGraph()) ;
}

private static boolean isomorphic(Dataset ds1, Dataset ds2) {
  return IsoMatcher.isomorphic(ds1.asDatasetGraph(), ds2.asDatasetGraph());
}

private void testDSG$(String s1, String s2, boolean iso) {
  s1 = "(dataset "+s1+")" ;
  s2 = "(dataset "+s2+")" ;
  
  DatasetGraph dsg1 = SSE.parseDatasetGraph(s1) ;
  DatasetGraph dsg2 = SSE.parseDatasetGraph(s2) ;
  boolean b = IsoMatcher.isomorphic(dsg1, dsg2) ;
  if ( b != iso ) {
    System.out.println("====") ;
    SSE.write(dsg1) ;
    System.out.println("----") ;
    SSE.write(dsg2) ;
    System.out.println("Expected: "+iso+" ; got: "+b) ;
  }
  assertEquals(iso, b) ;
}

  @Test
  public void trix_writer() {
    DatasetGraph dsg = RDFDataMgr.loadDatasetGraph(fNQuads) ;
    ByteArrayOutputStream bout = new ByteArrayOutputStream() ;
    RDFDataMgr.write(bout, dsg, Lang.TRIX) ;
    ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()) ;
    DatasetGraph dsg2 = DatasetGraphFactory.create() ;
    RDFDataMgr.read(dsg2, bin, Lang.TRIX) ;
    boolean b = IsoMatcher.isomorphic(dsg, dsg2) ;
    assertTrue("Not isomorphic", b) ;
  }
}

private boolean hasSameContent(final WonMessage processedMessage, final WonMessage message) {
 Dataset messageContent = message.getMessageContent();
 Dataset processedContent = processedMessage.getMessageContent();
 for (String name : RdfUtils.getModelNames(processedContent)) {
  Model model = processedContent.getNamedModel(name);
  if (WonRdfUtils.SignatureUtils.isSignatureGraph(name, model)
   && !RdfUtils.getModelNames(messageContent).contains(name)) {
   processedContent.removeNamedModel(name);
  }
 }
 if (IsoMatcher.isomorphic(processedContent.asDatasetGraph(), messageContent.asDatasetGraph())) {
  return true;
 }
 return false;
}

@Test public void graph_02() {
  ByteArrayOutputStream out = new ByteArrayOutputStream() ;
  StreamRDFWriter.write(out, graph, Lang.RDFTHRIFT) ;
  byte[] bytes = out.toByteArray() ;
  ByteArrayInputStream in = new ByteArrayInputStream(bytes) ;
  
  
  Graph g2 = GraphFactory.createGraphMem() ;
  RDFDataMgr.read(g2, in, Lang.RDFTHRIFT) ;
  boolean b = IsoMatcher.isomorphic(graph, g2) ;
  assertTrue(b) ;
  
  // Stronger - same bNodes.
  // ** Java8
  //graph.find(null, null, null).forEachRemaining(t -> assertTrue(g2.contains(t))) ;
  
  // Stronger - same bNodes.
  sameTerms(graph, g2) ;
}

@Test public void graph_01() {
  ByteArrayOutputStream out = new ByteArrayOutputStream() ;
  StreamRDF stream = BinRDF.streamToOutputStream(out, true) ; // With values.
  StreamOps.graphToStream(graph, stream) ;
  
  byte[] bytes = out.toByteArray() ;
  ByteArrayInputStream in = new ByteArrayInputStream(bytes) ;
  
  Graph g2 = GraphFactory.createGraphMem() ;
  StreamRDF stream2 = StreamRDFLib.graph(g2) ;
  BinRDF.inputStreamToStream(in, stream2) ;
  
  //assertTrue(graph.isIsomorphicWith(g2)) ;
  boolean b = IsoMatcher.isomorphic(graph, g2) ; //****
  assertTrue(b) ;
  
  // Stronger - same bNodes.
  sameTerms(graph, g2) ;
}

  @Test
  public void trix_dataset() {
    DatasetGraph ds1 = RDFDataMgr.loadDatasetGraph(fInput) ;
    DatasetGraph ds2 = null ;
    if ( fExpected != null )
      ds2 = RDFDataMgr.loadDatasetGraph(fExpected) ;
    if ( ds2 != null )
      assertTrue("Datasets not isomorphic", IsoMatcher.isomorphic(ds1, ds2)) ;
  }
}

private void testGraph$(String s1, String s2, boolean iso) {
  s1 = "(graph "+s1+")" ;
  s2 = "(graph "+s2+")" ;
  
  Graph g1 = SSE.parseGraph(s1) ;
  Graph g2 = SSE.parseGraph(s2) ;
  boolean b = IsoMatcher.isomorphic(g1, g2) ;
    
  if ( b != iso ) {
    System.out.println("====") ;
    SSE.write(g1) ;
    System.out.println("----") ;
    SSE.write(g2) ;
    System.out.println("Expected: "+iso+" ; got: "+b) ;
  }
  assertEquals(iso, b) ;
  // Check with the other code.
  assertEquals(b, g1.isIsomorphicWith(g2)) ;
}

@Test public void dataset_02() {
  DatasetGraph dsg1 = datasetGraph ;
  ByteArrayOutputStream out = new ByteArrayOutputStream() ;
  StreamRDFWriter.write(out, dsg1, Lang.RDFTHRIFT) ;
  
  byte[] bytes = out.toByteArray() ;
  ByteArrayInputStream in = new ByteArrayInputStream(bytes) ;
  DatasetGraph dsg2 = DatasetGraphFactory.create() ;
  
  StreamRDF stream2 = StreamRDFLib.dataset(dsg2) ;
  BinRDF.inputStreamToStream(in, stream2) ;
  
  boolean b = IsoMatcher.isomorphic(dsg1, dsg2) ;
  assertTrue(b) ;
  // Stronger - same bNode and same as in original data.
  Node obj = Iter.first(dsg1.listGraphNodes(), Node::isBlank) ;
  termAsObject(dsg1, obj) ;
}

boolean b = IsoMatcher.isomorphic(ds.asDatasetGraph(), ds2.asDatasetGraph()) ;
if ( ! b ) {
  System.out.println("Test: "+format.toString()) ;