@Override public void event(Object dest, Event event) { graph.getEventManager().notifyEvent( graph , GraphEvents.finishRead ) ; } } ;
/** * Test that registering a listener twice results in the listener receiving * the events twice. */ @ContractTest public void testRegisterTwice() { gem.register(L).register(L); gem.notifyAddTriple(mockGraph, SPO); L.assertHas(new Object[] { "add", mockGraph, SPO, "add", mockGraph, SPO }); }
@ContractTest public void testListening() { assertFalse("Should not be listening", gem.listening()); gem.register(L); assertTrue("Should be listening", gem.listening()); gem.unregister(L); assertFalse("Should not be listening", gem.listening()); }
/** * Test that registering a listener twice and unregistering it once will * result in the listener receiving each event one time. */ @ContractTest public void testUnregisterOnce() { gem.register(L).register(L).unregister(L); gem.notifyDeleteTriple(mockGraph, SPO); L.assertHas(new Object[] { "delete", mockGraph, SPO }); }
/** * Test that unregistering a listener after registering it results in it not * receiving messages. */ @ContractTest public void testUnregisterWorks() { gem.register(L).unregister(L); gem.notifyAddTriple(mockGraph, SPO); L.assertHas(new Object[] {}); }
/** * Test that sending a general event is reported as an event and the value * is saved. */ @ContractTest public void testGeneralEvent() { gem.register(L); Object value = new int[] {}; gem.notifyEvent(mockGraph, value); L.assertHas(new Object[] { "someEvent", mockGraph, value }); }
public void testUnregisterWorks() { Graph g = getGraph(); GraphEventManager gem = g.getEventManager(); gem.register( L ).unregister( L ); g.add( SPO ); L.assertHas( new Object[] {} ); }
public SecuredGraphEventManager(final SecuredGraph securedGraph, final Graph baseGraph, final GraphEventManager manager) { this.securedGraph = securedGraph; this.baseGraph = baseGraph; manager.register(this); }
/** * Test that deleting a triple is reported. */ @ContractTest public void testDeleteTriple() { gem.register(L); gem.notifyDeleteTriple(mockGraph, SPO); L.assertHas(new Object[] { "delete", mockGraph, SPO }); }
void unregister(GraphEventManager gem) { registered = false; inPlay = false; gem.unregister(this); }
/** * Test that adding an array is reported as adding an array. */ @ContractTest public void testAddArray() { gem.register(L); gem.notifyAddArray(mockGraph, tripleArray); L.assertHas(new Object[] { "add[]", mockGraph, tripleArray }); }
/** * Test that adding a list as an iterator is reported as an add iterator. */ @ContractTest public void testAddListAsIterator() { gem.register(L); List<Triple> elems = Arrays.asList(tripleArray); gem.notifyAddIterator(mockGraph, elems); L.assertHas(new Object[] { "addIterator", mockGraph, elems }); }
/** * Test that deleting a list is reported as deleting a list. */ @ContractTest public void testDeleteList() { gem.register(L); List<Triple> elems = Arrays.asList(tripleArray); gem.notifyDeleteList(mockGraph, elems); L.assertHas(new Object[] { "deleteList", mockGraph, elems }); }
/** * Test that adding a list is reported as adding a list */ @ContractTest public void testAddList() { gem.register(L); List<Triple> elems = Arrays.asList(tripleArray); gem.notifyAddList(mockGraph, elems); L.assertHas(new Object[] { "addList", mockGraph, elems }); }
/** * Test that deleting a list as an iterator is reported as deleting an * iterator. */ @ContractTest public void testDeleteListAsIterator() { gem.register(L); List<Triple> elems = Arrays.asList(tripleArray); gem.notifyDeleteIterator(mockGraph, elems); L.assertHas(new Object[] { "deleteIterator", mockGraph, elems }); }
/** Tell the event manager that the triple <code>t</code> has been deleted from the graph. */ public void notifyDelete( Triple t ) { getEventManager().notifyDeleteTriple( this, t ); }
/** Tell the event manager that the triple <code>t</code> has been added to the graph. */ public void notifyAdd( Triple t ) { getEventManager().notifyAddTriple( this, t ); }
boolean listening = getEventManager().listening(); boolean wantAdditions = listening || additions != null; boolean wantDeletions = listening || deletions != null; getEventManager().notifyAddList(this, additionsTemp); getEventManager().notifyDeleteList(this, deletionsTemp);
/** Add triples into the destination (arg 1) from the source (arg 2)*/ public static void addInto(Graph dstGraph, Graph srcGraph ) { if ( dstGraph == srcGraph && ! dstGraph.getEventManager().listening() ) return ; dstGraph.getPrefixMapping().setNsPrefixes(srcGraph.getPrefixMapping()) ; addIteratorWorker(dstGraph, findAll( srcGraph )); dstGraph.getEventManager().notifyAddGraph( dstGraph, srcGraph ); }
private static boolean requireEvents(Graph graph) { return graph.getEventManager().listening() ; }