/** * Notifies the listeners */ protected void fireConfigChangedEvent() { listeners.dispatch(new ConfigChangedEvent()); }
/** * Fire an event to all registered listeners. * <p> * The source repository of the event is automatically set to this * repository, before the event is delivered to any listeners. * * @param event * the event to deliver. */ public void fireEvent(RepositoryEvent<?> event) { event.setRepository(this); myListeners.dispatch(event); globalListeners.dispatch(event); }
/** {@inheritDoc} */ @Override public void dispatch(ConfigChangedListener listener) { listener.onConfigChanged(this); } }
/** * Add a listener to the list. * * @param type * type of listener being registered. * @param listener * the listener instance. * @return a handle to later remove the registration, if desired. */ public <T extends RepositoryListener> ListenerHandle addListener( Class<T> type, T listener) { ListenerHandle handle = new ListenerHandle(this, type, listener); add(handle); return handle; }
/** * Commit this change and release the lock. * <p> * If this method fails (returns false) the lock is still released. * * @return true if the commit was successful and the file contains the new * data; false if the commit failed and the file remains with the * old data. * @throws java.lang.IllegalStateException * the lock is not held. */ public boolean commit() { final LockFile tmp = myLock; requireLocked(tmp); myLock = null; if (!tmp.commit()) { return false; } snapshot = tmp.getCommitSnapshot(); if (indexChangedListener != null && !Arrays.equals(readIndexChecksum, writeIndexChecksum)) { indexChangedListener.onIndexChanged(new IndexChangedEvent(true)); } return true; }
/** * Dispatch an event to all interested listeners. * <p> * Listeners are selected by the type of listener the event delivers to. * * @param event * the event to deliver. */ @SuppressWarnings("unchecked") public void dispatch(RepositoryEvent event) { List<ListenerHandle> list = lists.get(event.getListenerType()); if (list != null) { for (ListenerHandle handle : list) event.dispatch(handle.listener); } }
/** * Register a {@link org.eclipse.jgit.events.WorkingTreeModifiedListener}. * * @param listener * the listener implementation. * @return handle to later remove the listener. * @since 4.9 */ public ListenerHandle addWorkingTreeModifiedListener( WorkingTreeModifiedListener listener) { return addListener(WorkingTreeModifiedListener.class, listener); }
} finally { if (performingCheckout) { WorkingTreeModifiedEvent event = new WorkingTreeModifiedEvent( getUpdated().keySet(), getRemoved()); if (!event.isEmpty()) { repo.fireEvent(event);
/** * Adds a listener to be notified about changes. * <p> * Clients are supposed to remove the listeners after they are done with * them using the {@link org.eclipse.jgit.events.ListenerHandle#remove()} * method * * @param listener * the listener * @return the handle to the registered listener */ public ListenerHandle addChangeListener(ConfigChangedListener listener) { return listeners.addConfigChangedListener(listener); }
/** {@inheritDoc} */ @Override public void notifyIndexChanged(boolean internal) { synchronized (snapshotLock) { snapshot = FileSnapshot.save(getIndexFile()); } fireEvent(new IndexChangedEvent(internal)); }
/** {@inheritDoc} */ @Override public void dispatch(IndexChangedListener listener) { listener.onIndexChanged(this); } }
/** * Remove the listener and stop receiving events. */ public void remove() { parent.remove(this); }
/** {@inheritDoc} */ @Override public void dispatch(RefsChangedListener listener) { listener.onRefsChanged(this); } }
/** If the parent should fire listeners, fires them. */ void fireRefsChanged() { final int last = lastNotifiedModCnt.get(); final int curr = modCnt.get(); if (last != curr && lastNotifiedModCnt.compareAndSet(last, curr) && last != 0) parent.fireEvent(new RefsChangedEvent()); }
/** {@inheritDoc} */ @Override public void dispatch(WorkingTreeModifiedListener listener) { listener.onWorkingTreeModified(this); } }
repo.fireEvent(new WorkingTreeModifiedEvent( actuallyModifiedPaths, null));
/** * Register a RefsChangedListener. * * @param listener * the listener implementation. * @return handle to later remove the listener. */ public ListenerHandle addRefsChangedListener(RefsChangedListener listener) { return addListener(RefsChangedListener.class, listener); }
dc.unlock(); } finally { WorkingTreeModifiedEvent event = new WorkingTreeModifiedEvent( actuallyModifiedPaths, null); actuallyModifiedPaths = null; if (!event.isEmpty()) { repo.fireEvent(event);
/** * Register a ConfigChangedListener. * * @param listener * the listener implementation. * @return handle to later remove the listener. */ public ListenerHandle addConfigChangedListener( ConfigChangedListener listener) { return addListener(ConfigChangedListener.class, listener); }
/** * Register an IndexChangedListener. * * @param listener * the listener implementation. * @return handle to later remove the listener. */ public ListenerHandle addIndexChangedListener(IndexChangedListener listener) { return addListener(IndexChangedListener.class, listener); }