Listeners(Object lockObj) { for (int i=0;i<listenerArray.length;i++) listenerArray[i]=new ListenerType(lockObj); }
/** Add a listener to this listener type. Any number of listeners are supported. */ public void addListener(JAMonListener listenerToAdd) { synchronized(lockObj) { // this first case is either 1) the first listener for this type. // in this case for performance reasons there is no reason to create // a compositeListener at this point, 2) a null was passed so the listener // will be nullified. Either way the listener is assigned to the variable // representing the Listenertype if (listener == null || listenerToAdd == null) listener = listenerToAdd; else // else add the listener to the composite (create the composite if necessary) listener = addCompositeListener(listenerToAdd); } }
private static void test(ListenerType lt, String name) { System.out.print(lt.hasListener(name)+"-"); JAMonListener l=lt.getListener(name); if (l!=null) System.out.print(l.getName()+","); }
public static void main(String[] args) { ListenerType lt=new ListenerType(new Object()); CompositeListener cl1=new CompositeListener("cl1"); CompositeListener cl2=new CompositeListener("cl2"); cl2.addListener(new JAMonBufferListener("buff4")); cl1.addListener(cl2); lt.addListener(cl1); lt.addListener(new JAMonBufferListener("buff5")); test(lt, "cl1"); test(lt, "cl2"); test(lt, "buff2"); test(lt, "buff4"); test(lt, "buffX"); testDisp(lt); lt.removeListener("buff4"); testDisp(lt); lt.removeListener("cl2"); testDisp(lt); lt.removeListener("buff1"); lt.removeListener("buff2"); testDisp(lt); lt.removeListener("buff5"); testDisp(lt);
public static void main(String[] args) throws Exception { TimeMon mon=new TimeMon2(); mon.getListenerType("value").addListener(new JAMonBufferListener("first")); mon.getListenerType("value").addListener(new JAMonBufferListener("second")); mon.getListenerType("value").removeListener("first"); mon.getListenerType("value").removeListener("second"); mon.getListenerType("value").addListener(new JAMonBufferListener("1")); mon.getListenerType("max").addListener(new JAMonBufferListener("2")); mon.getListenerType("min").addListener(new JAMonBufferListener("3")); mon.getListenerType("maxactive").addListener(new JAMonBufferListener("4")); testDisplay("value", mon.getListenerType("value").getListener()); testDisplay("max", mon.getListenerType("max").getListener()); testDisplay("min", mon.getListenerType("min").getListener()); testDisplay("maxactive", mon.getListenerType("maxactive").getListener());
delme.getListenerType("max").addListener(jbl); MonitorFactory.getMonitor("/jamon/jamonadmin.jsp","ms.").add(100); jbl=(JAMonBufferListener)MonitorFactory.getMonitor("/jamon/jamonadmin.jsp","ms.").getListenerType("max").getListener(); Object[][] data=jbl.getData();
/** No check for null objects. If that is important first call hasListener(listenerType) * above * * @param listenerType * @return */ public JAMonListener getListener(int listenerType) { return listeners.getListenerType(listenerType).getListener(); }
/** Returns true if any listeners exist */ public boolean hasListeners() { for (int i=0;i<listenerArray.length;i++) { if (listenerArray[i].hasListeners()) return true; } return false; }
/** Introduced as a way to remove listeners that allows for lazy initialization saving a fair amount of memory. Note * a future enhancement would be to delete the Listeners object when all listeners are removed. * * @since 2.71 * */ public void removeListener(String listenerTypeName, String listenerName) { synchronized (monData) { if (!monData.hasListeners()) // return if there is nothing to remove return; ListenerType type=getListenerType(listenerTypeName); if (type!=null) type.removeListener(listenerName); } }
/** Introduced as a way to check for listeners that allows for lazy initialization saving a fair amount of memory. Note * a future enhancement would be to delete the Listeners object when all listeners are removed. * * @since 2.71 */ public boolean hasListener(String listenerTypeName, String listenerName) { synchronized (monData) { if (!monData.hasListeners()) return false; ListenerType type=getListenerType(listenerTypeName); if (type==null) return false; else return type.hasListener(listenerName); } }
/** Introduced as a way to add listeners that allows for lazy initialization saving a fair amount of memory. Note * a future enhancement would be to delete the Listeners object when all listeners are removed. * * @since 2.71 */ public void addListener(String listenerTypeName, JAMonListener listener) { synchronized (monData) { Listeners listeners; if (monData.hasListeners()) listeners=monData.getListeners(); else listeners=monData.createListeners(); listeners.getListenerType(listenerTypeName).addListener(listener); } }
private static void testDisp(ListenerType lt) { System.out.println(); System.out.print("*"); Object[][] data=lt.getData(); int rows=(data==null) ? 0 : data.length; for (int i=0;i<rows;i++) for (int j=0;j<data[0].length;j++) System.out.print(data[i][j]+", "); }
private JAMonBufferListener getExceptionBufferListener() { if (MonitorFactory.exists(MonitorFactory.EXCEPTIONS_LABEL, EXCEPTION)) { Monitor mon = MonitorFactory.getMonitor(MonitorFactory.EXCEPTIONS_LABEL, EXCEPTION); if (mon.hasListener("value", "FIFOBuffer")) { JAMonListener bufferListener = mon.getListenerType("value").getListener("FIFOBuffer"); if (bufferListener instanceof JAMonBufferListener) { return (JAMonBufferListener) bufferListener; } } } return null; }
/** Returns true if any listeners exist. This method really isn't needed as Monitor.hasListeners() should suffice*/ public boolean hasListeners() { for (int i=0;i<listenerArray.length;i++) { if (listenerArray[i].hasListeners()) return true; } return false; }
@Override public String getMostRecentException() { if (!MonitorFactory.exists(LABEL, UNITS)) { return "No exceptions have been thrown"; } if (!MonitorFactory.getMonitor(LABEL, UNITS).hasListener("value", "FIFOBuffer")) { return "Exception Stacktrace tracking is not enabled."; } JAMonListener listener = MonitorFactory.getMonitor(LABEL, UNITS).getListenerType("value").getListener("FIFOBuffer"); if (!(listener instanceof JAMonBufferListener) || ((JAMonBufferListener) listener).isEmpty()) { return "There are no stacktraces"; } return getMostRecentStacktrace((JAMonBufferListener) listener); }
final boolean hasListener(int listenerType) { return (listenerArray[listenerType].hasListeners()); }
Listeners(Object lockObj) { for (int i=0;i<listenerArray.length;i++) listenerArray[i]=new ListenerType(lockObj); }
/** * Add a listener that receives notification every time this monitors * add method is called. If null is passed all associated Listeners will * be detached. */ // Some jamon 2.4 introduced methods. Mostly listener related. public void addListener(JAMonListener listenerToAdd) { synchronized(lockObj) { // this first case is either 1) the first listener for this type. // in this case for performance reasons there is no reason to create // a compositeListener at this point, 2) a null was passed so the listener // will be nullified. Either way the listener is assigned to the variable // representing the Listenertype if (listener == null || listenerToAdd == null) listener = listenerToAdd; else // else add the listener to the composite (create the composite if necessary) listener = addCompositeListener(listenerToAdd); } }
delme.addListener("max", jbl); MonitorFactory.getMonitor("/jamon/jamonadmin.jsp","ms.").add(100); jbl=(JAMonBufferListener)MonitorFactory.getMonitor("/jamon/jamonadmin.jsp","ms.").getListenerType("max").getListener(); Object[][] data=jbl.getDetailData().getData();
/** Returns true if this listenertype ('max', 'min', 'value', 'maxactive') has any listeners at all * * @param listenerTypeName * @return boolean */ public boolean hasListeners(String listenerTypeName) { synchronized (monData) { if (!monData.hasListeners()) return false; ListenerType type=getListenerType(listenerTypeName); if (type==null) return false; else return type.hasListeners(); } }