/**     * Well known endpoint protocol specification identifier: the standard     * router     */    public static final ModuleSpecID refRouterServiceMonitorSpecID = (ModuleSpecID)    ID.create( URI.create( WK_ID_PREFIX + "0000010B0106" ));            /**     * Well known endpoint protocol specification identifier: the standard     * tls endpoint protocol     */    public static final ModuleSpecID refTlsServiceMonitorSpecID = (ModuleSpecID)    ID.create( URI.create( WK_ID_PREFIX + "0000010D0106" ));        /**     * Well known application: the Proxy     */    public static final ModuleSpecID refProxyServiceMonitorSpecID = (ModuleSpecID)    ID.create( URI.create( WK_ID_PREFIX + "0000010E0106" ));        /**     * Well known endpoint protocol specification identifier: the standard     * relay endpoint protocol     */    public static final ModuleSpecID refRelayServiceMonitorSpecID = (ModuleSpecID)    ID.create( URI.create( WK_ID_PREFIX + "0000010F0106" ));            private static ModuleClassID standardServiceMonitorClassIDs[] = new ModuleClassID[] {        resolverServiceMonitorClassID,        rendezvousServiceMonitorClassID,        endpointServiceMonitorClassID,        transportServiceMonitorClassID };                public static ModuleImplAdvertisement getReferenceAllPurposeMonitorServiceImplAdvertisement(boolean includeTransports) {            ModuleImplAdvertisement moduleImplAdvertisement = AdvertisementUtilities.createModuleImplAdvertisement(refMonitorServiceSpecID, "net.jxta.impl.meter.MonitorManager", "Service Monitor");            StructuredTextDocument param =  (StructuredTextDocument) StructuredDocumentFactory.newStructuredDocument(MimeMediaType.XMLUTF8, "serviceMonitor");                        addServiceMonitorServiceAdvertisement(param, refResolverServiceMonitorSpecID, "Resolver",            "net.jxta.impl.resolver.resolverMeter.ResolverServiceMonitor",            "net.jxta.impl.resolver.resolverMeter.ResolverServiceMetric",            "net.jxta.impl.resolver.resolverMeter.ResolverServiceMonitorFilter");                        addServiceMonitorServiceAdvertisement(param, refEndpointServiceMonitorSpecID, "Endpoint",            "net.jxta.impl.endpoint.endpointMeter.EndpointServiceMonitor",            "net.jxta.impl.endpoint.endpointMeter.EndpointServiceMetric",            "net.jxta.impl.endpoint.endpointMeter.EndpointServiceMonitorFilter");                        addServiceMonitorServiceAdvertisement(param, refTransportServiceMonitorSpecID, "Transport",            "net.jxta.impl.endpoint.transportMeter.TransportServiceMonitor",            "net.jxta.impl.endpoint.transportMeter.TransportServiceMetric",            "net.jxta.impl.endpoint.transportMeter.TransportServiceMonitorFilter");                        addServiceMonitorServiceAdvertisement(param, refRendezvousServiceMonitorSpecID, "Rendezvous",            "net.jxta.impl.rendezvous.rendezvousMeter.RendezvousServiceMonitor",            "net.jxta.impl.rendezvous.rendezvousMeter.RendezvousServiceMetric",            "net.jxta.impl.rendezvous.rendezvousMeter.RendezvousServiceMonitorFilter");                        moduleImplAdvertisement.setParam(param);            return moduleImplAdvertisement;        }                        private static void addServiceMonitorServiceAdvertisement(Element root, ModuleSpecID moduleSpecID, String title, String implClassName, String metricClassName, String filterClassName) {            ModuleImplAdvertisement moduleImplAdvertisement = createServiceMonitorModuleImplAdvertisement(moduleSpecID, title, implClassName, metricClassName, filterClassName);                        Element serviceMonitorElement = DocumentSerializableUtilities.createChildElement(root, SERVICE_MONITOR_TAG);                        ModuleClassID moduleClassID = moduleSpecID.getBaseClass();            DocumentSerializableUtilities.addString(serviceMonitorElement, CLASS_ID_TAG, moduleClassID.toString());                        Element serviceMonitorAdvertisementElement = DocumentSerializableUtilities.createChildElement(serviceMonitorElement, SERVICE_MONITOR_ADVERTISEMENT_TAG);            Element advDoc = (Element) moduleImplAdvertisement.getDocument(MimeMediaType.XMLUTF8);            DocumentSerializableUtilities.copyChildren(serviceMonitorAdvertisementElement, advDoc);        }                public static ModuleImplAdvertisement createServiceMonitorModuleImplAdvertisement(ModuleSpecID moduleSpecID, String title, String implClassName, String metricClassName, String filterClassName) {            ModuleImplAdvertisement moduleImplAdvertisement = AdvertisementUtilities.createModuleImplAdvertisement(moduleSpecID, implClassName, "Service Monitor");                        StructuredTextDocument param =  (StructuredTextDocument) StructuredDocumentFactory.newStructuredDocument(MimeMediaType.XMLUTF8, "serviceMonitor");                        DocumentSerializableUtilities.addString(param, SERVICE_TITLE_TAG, title);            DocumentSerializableUtilities.addString(param, METRIC_CLASS_TAG, metricClassName);            DocumentSerializableUtilities.addString(param, FILTER_CLASS_TAG, filterClassName);            moduleImplAdvertisement.setParam(param);                        return moduleImplAdvertisement;        }                public static ModuleImplAdvertisement getServiceMonitorImplAdvertisement(ModuleClassID serviceMonitorModuleClassID, ModuleImplAdvertisement monitorServiceImplAdvertisement) {                        String classIDText = serviceMonitorModuleClassID.toString();                        StructuredDocument param = 	monitorServiceImplAdvertisement.getParam();                        for(Enumeration e = param.getChildren(SERVICE_MONITOR_TAG); e.hasMoreElements(); ) {                Element serviceMonitorElement = (Element) e.nextElement();                                String serviceMonitorClassIDText = DocumentSerializableUtilities.getString(serviceMonitorElement, CLASS_ID_TAG, "");                                if (classIDText.equals(serviceMonitorClassIDText)) {                    TextElement serviceMonitorAdvertisementElement = (TextElement) DocumentSerializableUtilities.getChildElement(serviceMonitorElement, SERVICE_MONITOR_ADVERTISEMENT_TAG);                    return (ModuleImplAdvertisement) AdvertisementFactory.newAdvertisement(serviceMonitorAdvertisementElement);                }            }                        return null;                    }                private static class ServiceResource {            String serviceMonitorClassName;            Class serviceMonitorClass;            String serviceMonitorFilterClassName;            Class serviceMonitorFilterClass;            String serviceMetricClassName;            Class serviceMetricClass;                        ServiceResource(ModuleImplAdvertisement moduleImplAdvertisement) throws JxtaException {                try {                    serviceMonitorClassName = moduleImplAdvertisement.getCode();                                        serviceMonitorFilterClassName = getServiceMonitorFilterClassName(moduleImplAdvertisement);                    serviceMonitorFilterClass = Class.forName(serviceMonitorFilterClassName);                                        if (!(ServiceMonitorFilter.class).isAssignableFrom(serviceMonitorFilterClass))                        throw new JxtaException("Bad ServiceMonitorImplAdvertisment: " + serviceMonitorFilterClassName + " is not a ServiceMonitorFilter");                                        serviceMetricClassName = getServiceMetricClassName(moduleImplAdvertisement);                    serviceMetricClass = Class.forName(serviceMetricClassName);                                        if (!(ServiceMetric.class).isAssignableFrom(serviceMetricClass))                        throw new JxtaException("Bad ServiceMonitorImplAdvertisment: " + serviceMetricClassName + " is not a ServiceMetric");                } catch (Exception e) {                    throw new JxtaException("Bad ServiceMonitorImplAdvertisment: Unable to load constituent parts", e);                }            }        }                        /**         * Register the Implementation Advertisement for a ServiceMonitor Type         *  This contains the Monitor, Metric and Filter classNames         */        public static void registerServiceMonitorModuleImplAdvertisement(ModuleImplAdvertisement moduleImplAdvertisement) throws JxtaException {            ModuleClassID moduleClassID = moduleImplAdvertisement.getModuleSpecID().getBaseClass();                        if (registeredMonitorResources.get(moduleClassID) != null)                return;                        registeredMonitorResources.put(moduleClassID, new ServiceResource(moduleImplAdvertisement));        }                /**         * Create an empty ServiceMonitorFilter for the corresponding ModuleClassID         *         * @exception JxtaException  If not found or other errors         */        public static ServiceMonitorFilter createServiceMonitorFilter(ModuleClassID moduleClassID) throws MonitorFilterException {            try {                ServiceResource serviceResource = (ServiceResource) registeredMonitorResources.get(moduleClassID);                ServiceMonitorFilter serviceMonitorFilter = (ServiceMonitorFilter) serviceResource.serviceMonitorFilterClass.newInstance();                serviceMonitorFilter.init(moduleClassID);                return serviceMonitorFilter;            } catch (Exception e) {                throw new MonitorFilterException("Unable to Create Filter: " + moduleClassID);			// this should never happen, we already did our checks            }        }                        /**         * Create an empty Service Metric for the corresponding ModuleClassID         *         * @exception JxtaException  If not found or other errors         */        public static ServiceMetric createServiceMetric(ModuleClassID moduleClassID) throws JxtaException {            try {                ServiceResource serviceResource = (ServiceResource) registeredMonitorResources.get(moduleClassID);                ServiceMetric serviceMetric = (ServiceMetric) serviceResource.serviceMetricClass.newInstance();                serviceMetric.init(moduleClassID);                return serviceMetric;            } catch (Exception e) {                throw new JxtaException("Unable to Create Service Metric");			// this should never happen, we already did our checks            }        }                /**         * get ServiceMetric ClassName from its ImplAdvertisement         */        public static String getServiceMetricClassName(ModuleImplAdvertisement serviceMonitorModuleImplAdvertisement) {            Element param = serviceMonitorModuleImplAdvertisement.getParam();            return DocumentSerializableUtilities.getString(param, METRIC_CLASS_TAG, null);        }                /**         * get ServiceMonitorFilter ClassName from its ImplAdvertisement         */        public static String getServiceMonitorFilterClassName(ModuleImplAdvertisement serviceMonitorModuleImplAdvertisement) {            Element param = serviceMonitorModuleImplAdvertisement.getParam();            return DocumentSerializableUtilities.getString(param, FILTER_CLASS_TAG, null);        }                /**         * Get a list of all registered Service Monitor types         */        public static ModuleClassID[] getRegisteredModuleClassIDs() {            return (ModuleClassID[]) standardServiceMonitorClassIDs.clone();        }                /**         * Get the name of standard Monitor Type         **/        public static String getMonitorTypeName(ModuleClassID moduleClassID) {            if(moduleClassID.equals(monitorServiceClassID)) return "monitor";                        if(moduleClassID.equals(resolverServiceMonitorClassID)) return "Resolver";                        if(moduleClassID.equals(discoveryServiceMonitorClassID)) return "Discovery";                        if(moduleClassID.equals(pipeServiceMonitorClassID)) return "Pipe";                        if(moduleClassID.equals(membershipServiceMonitorClassID)) return "Membership";                        if(moduleClassID.equals(rendezvousServiceMonitorClassID)) return "Rendezvous";                        if(moduleClassID.equals(peerinfoServiceMonitorClassID)) return "PeerInfo";                        if(moduleClassID.equals(endpointServiceMonitorClassID)) return "Endpoint";                        if(moduleClassID.equals(transportServiceMonitorClassID)) return "Transport";                        if(moduleClassID.equals(routerServiceMonitorClassID)) return "monitor";                        if(moduleClassID.equals(tlsProtoServiceMonitorClassID)) return "Tls";                        if(moduleClassID.equals(proxyServiceMonitorClassID)) return "Proxy";                        if(moduleClassID.equals(relayServiceMonitorClassID)) return "Relay";                        return null;        }                }