diff options
Diffstat (limited to 'jurt/com/sun/star/comp/servicemanager/ServiceManager.java')
| -rw-r--r-- | jurt/com/sun/star/comp/servicemanager/ServiceManager.java | 926 |
1 files changed, 926 insertions, 0 deletions
diff --git a/jurt/com/sun/star/comp/servicemanager/ServiceManager.java b/jurt/com/sun/star/comp/servicemanager/ServiceManager.java new file mode 100644 index 000000000000..3d672c6dfddf --- /dev/null +++ b/jurt/com/sun/star/comp/servicemanager/ServiceManager.java @@ -0,0 +1,926 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +package com.sun.star.comp.servicemanager; + +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XComponentContext; + +import com.sun.star.container.XSet; +import com.sun.star.container.XContentEnumerationAccess; +import com.sun.star.container.XEnumeration; + +import com.sun.star.lang.XComponent; +import com.sun.star.lang.XEventListener; +import com.sun.star.lang.XInitialization; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XServiceInfo; +import com.sun.star.lang.XSingleServiceFactory; +import com.sun.star.lang.XSingleComponentFactory; +import com.sun.star.lang.XMultiComponentFactory; + +import com.sun.star.registry.XRegistryKey; +import com.sun.star.registry.XSimpleRegistry; + +import com.sun.star.loader.XImplementationLoader; + +import java.lang.reflect.InvocationTargetException; + +/** + * The <code>ServiceManager</code> class is an implmentation of the <code>ServiceManager</code>the central class needed for + * implementing or using UNO components in Java. + * <p> + * The Methods <code>queryInterface</code> and <code>isSame</code> delegate + * calls to the implementing objects and are used instead of casts + * and identity comparisons. + * <p> + * @version $Revision: 1.10 $ $ $Date: 2008-04-11 11:11:46 $ + * @author Markus Herzog + * @see com.sun.star.lang.XMultiServiceFactory + * @see com.sun.star.container.XSet + * @see com.sun.star.container.XContentEnumerationAccess + * @see com.sun.star.lang.XComponent + * @see com.sun.star.lang.XServiceInfo + * @see com.sun.star.lang.XInitialization + * @since UDK1.0 + */ +public class ServiceManager implements XMultiServiceFactory, + XMultiComponentFactory, + XSet, + XContentEnumerationAccess, + XComponent, + XServiceInfo, + XInitialization +{ + private static final boolean DEBUG = false; + + private static final void DEBUG (String dbg) { + if (DEBUG) System.err.println( dbg ); + } + + private static com.sun.star.uno.Type UNO_TYPE = null; + + XImplementationLoader loader = null; + + static String[] supportedServiceNames = { + "com.sun.star.lang.MultiServiceFactory", + "com.sun.star.lang.ServiceManager" + }; + + java.util.Vector eventListener; + java.util.Hashtable factoriesByImplNames; + java.util.Hashtable factoriesByServiceNames; // keys: + + private com.sun.star.uno.XComponentContext m_xDefaultContext; + + /** + * Creates a new instance of the <code>ServiceManager</code>. + */ + public ServiceManager() { + eventListener = new java.util.Vector(); + factoriesByImplNames = new java.util.Hashtable(); + factoriesByServiceNames = new java.util.Hashtable(); + m_xDefaultContext = null; + } + /** + * Creates a new instance of the <code>ServiceManager</code>. + */ + public ServiceManager( XComponentContext xContext ) { + eventListener = new java.util.Vector(); + factoriesByImplNames = new java.util.Hashtable(); + factoriesByServiceNames = new java.util.Hashtable(); + m_xDefaultContext = xContext; + } + + /** + * Returns the service factory for the <code>ServiceManager</code>. If the given implementation name + * does not equal to the <code>ServiceManagers</code> class name null will be returned. + * <p> + * @return the factory for the <code>ServiceManager</code>. + * @param implName the implementation name of the of the service. + * Must be equal to <code>com.sun.star.comp.servicemanager.ServicManager</code> + * @param multiFactory refernce of the <code>MultiServiceFactory</code>. This parameter will be ignored. + * @param regKey the root key of the registry. This parameter will be ignored. + */ + public static XSingleServiceFactory getServiceFactory( String implName, + XMultiServiceFactory multiFactory, + XRegistryKey regKey) + { + if ( implName.equals(ServiceManager.class.getName()) ) + return new ServiceManagerFactory(); + + return null; + } + + + /** + * Supplies a Java component loader. The loader component must be enlisted at the <code>ServiceManager</code> before. + * <p> + * @return a new instance of the Java component loader + * @see com.sun.star.loader.Java + */ + private XImplementationLoader getLoader() + throws com.sun.star.uno.Exception, + com.sun.star.uno.RuntimeException + { + Object[] param = { this }; + DEBUG("make loader"); + Object loaderObj = createInstanceWithArgumentsAndContext( + "com.sun.star.loader.Java", param, m_xDefaultContext ); + + if (loaderObj == null) + throw new com.sun.star.uno.Exception("Can get an instance of com.sun.star.loader.Java"); + + return UnoRuntime.queryInterface( XImplementationLoader.class, loaderObj ); + } + + /** + * Registers a list of components given by their class names. + * <p> + * @param newImpls list of the components that should be registered, given by their class names. + * If any exception occured during the registration, the process will be canceled. + * @see com.sun.star.container.XSet + */ + private void xaddFactories( String[] newImpls ) + throws com.sun.star.uno.Exception + { + for (int i=0; i<newImpls.length; i++) { + DEBUG ("try to add " + newImpls[i] ); + Object newFactory = null; + + try { + if (loader == null) + loader = getLoader(); + + newFactory = loader.activate( newImpls[i], null, null, null ); + } + catch (com.sun.star.uno.Exception e) { + +//****************************** BEGIN DEPRECATED ****************************************** + + try { + // try to get the class of the implementation + Class clazz = Class.forName( newImpls[i] ); + + Class[] methodClassParam = { String.class, XMultiServiceFactory.class, XRegistryKey.class }; + java.lang.reflect.Method getFactoryMeth = null; + try { + getFactoryMeth = clazz.getMethod("__getServiceFactory", methodClassParam); + } + catch (NoSuchMethodException noSuchMethodEx) { + getFactoryMeth = null; + } + catch (SecurityException securityExc) { + getFactoryMeth = null; + } + + if (getFactoryMeth == null) + getFactoryMeth = clazz.getMethod("getServiceFactory", methodClassParam); + + Object[] methodParams = { newImpls[i], this, null }; + newFactory = getFactoryMeth.invoke( clazz, methodParams ); + } + catch (NoSuchMethodException ex) {} + catch (SecurityException ex) {} + catch (ClassNotFoundException ex) {} + catch (IllegalAccessException ex) {} + catch (IllegalArgumentException ex) {} + catch (InvocationTargetException ex) {} + +//****************************** END DEPRECATED ****************************************** + } + + if ( newFactory == null ) + throw new com.sun.star.loader.CannotActivateFactoryException("Can not get factory for " + newImpls[i]); + + insert( newFactory ); + } // end of for ... + } + + /** + * The method is used to add components to the <code>ServiceManager</code>. The first argument indicates a <code>SimpleRegistry</code>. + * The components which should be added will be searched under the <i>Implementations</i> key in the registry. + * <p> + * @param args the first argument ( args[0] ) specifices the SimpleRegistry object + * @see com.sun.star.lang.XInitialization + * @see com.sun.star.lang.RegistryServiceManager + * @see com.sun.star.lang.XSimpleRegistry + */ + public void initialize( Object args[] ) + throws com.sun.star.uno.Exception, + com.sun.star.uno.RuntimeException { + XSimpleRegistry xSimpleRegistry = null; + try { + xSimpleRegistry = (XSimpleRegistry) args[0]; + if (xSimpleRegistry != null) + { + XRegistryKey rootkey = xSimpleRegistry.getRootKey(); + + XRegistryKey implkey_xRegistryKey = rootkey.openKey("Implementations"); + if(implkey_xRegistryKey != null) { + XRegistryKey xRegistryKeys[] = implkey_xRegistryKey.openKeys(); + + for(int i = 0; i < xRegistryKeys.length; ++ i) { + xaddFactories(new String[]{xRegistryKeys[i].getStringValue()}); + } + } + } + + if (args.length > 1) + { + m_xDefaultContext = (XComponentContext)args[ 1 ]; + } + } + catch (ArrayIndexOutOfBoundsException e) + { + throw new com.sun.star.lang.IllegalArgumentException("Argument must not be null."); + } + } + + /** + * Creates a new instance of a specified service. Therefor the associated factory of the service is + * looked up and used to instanciate a new component. + * <p> + * @return newly created component + * @param serviceSpecifier indicates the service or component name + * @see com.sun.star.lang.XMultiServiceFactory + */ + public java.lang.Object createInstance( String serviceSpecifier ) + throws com.sun.star.uno.Exception, + com.sun.star.uno.RuntimeException + { + return createInstanceWithContext( serviceSpecifier, m_xDefaultContext ); + } + + /** + * Creates a new instance of a specified service with the given parameters. + * Therefor the associated factory of the service is looked up and used to instanciate a new component. + * <p> + * @return newly created component + * @param serviceSpecifier indicates the service or component name + * @see com.sun.star.lang.XMultiServiceFactory + */ + public java.lang.Object createInstanceWithArguments( + String serviceSpecifier, Object[] args ) + throws com.sun.star.uno.Exception, com.sun.star.uno.RuntimeException + { + if (DEBUG) { + System.err.println("createInstanceWithArguments:" ); + + for (int i=0; i<args.length; i++) + System.err.print(" "+ args[i]); + + System.err.println(); + } + + return createInstanceWithArgumentsAndContext( serviceSpecifier, args, m_xDefaultContext ); + } + + /** + * Look up the factory for a given service or implementation name. + * First the requested service name is search in the list of avaible services. If it can not be found + * the name is looked up in the the implementation list. + * <p> + * @return the factory of the service / implementation + * @param serviceSpecifier indicates the service or implementation name + * @see com.sun.star.lang.XMultiServiceFactory + */ + private Object queryServiceFactory(String serviceName) + throws com.sun.star.uno.Exception, + com.sun.star.uno.RuntimeException + { + DEBUG("queryServiceFactory for name " + serviceName ); + Object factory = null; + + if ( factoriesByServiceNames.containsKey( serviceName ) ) { + java.util.Vector aviableFact = (java.util.Vector) factoriesByServiceNames.get( serviceName ); + + DEBUG(""); + DEBUG("aviable factories for " + serviceName +" "+ aviableFact); + DEBUG(""); + + if ( !aviableFact.isEmpty() ) + factory = aviableFact.lastElement(); + + } else // not found in list of services - now try the implementations + factory = factoriesByImplNames.get( serviceName ); // return null if none is aviable + + if (DEBUG) { + if (factory == null) System.err.println("service not registered"); + else + System.err.println("service found:" + factory + " " + UnoRuntime.queryInterface(XSingleServiceFactory.class, factory)); + } + + if (factory == null) + throw new com.sun.star.uno.Exception("Query for service factory for " + serviceName + " failed."); + + return factory; + } + + /** + * Supplies a list of all avialable services names. + * <p> + * @return list of Strings of all service names + * @see com.sun.star.container.XContentEnumerationAccess + */ + public String[] getAvailableServiceNames() + throws com.sun.star.uno.RuntimeException + { + int i = 0; + String[] availableServiceNames = new String[factoriesByServiceNames.size()]; + + java.util.Enumeration keys = factoriesByServiceNames.keys(); + + while (keys.hasMoreElements()) + availableServiceNames[i++] = (String) keys.nextElement(); + + return availableServiceNames; + } + + // XMultiComponentFactory implementation + + /** Create a service instance with given context. + + @param rServiceSpecifier service name + @param xContext context + @return service instance + */ + public java.lang.Object createInstanceWithContext( + String rServiceSpecifier, + com.sun.star.uno.XComponentContext xContext ) + throws com.sun.star.uno.Exception + { + Object fac = queryServiceFactory( rServiceSpecifier ); + if (fac != null) + { + XSingleComponentFactory xCompFac = UnoRuntime.queryInterface( + XSingleComponentFactory.class, fac ); + if (xCompFac != null) + { + return xCompFac.createInstanceWithContext( xContext ); + } + else + { + XSingleServiceFactory xServiceFac = UnoRuntime.queryInterface( + XSingleServiceFactory.class, fac ); + if (xServiceFac != null) + { + if (DEBUG) + System.err.println( "### ignoring context raising service \"" + rServiceSpecifier + "\"!" ); + return xServiceFac.createInstance(); + } + else + { + throw new com.sun.star.uno.Exception( + "retrieved service factory object for \"" + rServiceSpecifier + + "\" does not export XSingleComponentFactory nor XSingleServiceFactory!" ); + } + } + } + return null; + } + /** Create a service instance with given context and arguments. + + @param rServiceSpecifier service name + @param rArguments arguments + @param xContext context + @return service instance + */ + public java.lang.Object createInstanceWithArgumentsAndContext( + String rServiceSpecifier, + java.lang.Object[] rArguments, + com.sun.star.uno.XComponentContext xContext ) + throws com.sun.star.uno.Exception + { + Object fac = queryServiceFactory( rServiceSpecifier ); + if (fac != null) + { + XSingleComponentFactory xCompFac = UnoRuntime.queryInterface( + XSingleComponentFactory.class, fac ); + if (xCompFac != null) + { + return xCompFac.createInstanceWithArgumentsAndContext( rArguments, xContext ); + } + else + { + XSingleServiceFactory xServiceFac = UnoRuntime.queryInterface( + XSingleServiceFactory.class, fac ); + if (xServiceFac != null) + { + if (DEBUG) + System.err.println( "### ignoring context raising service \"" + rServiceSpecifier + "\"!" ); + return xServiceFac.createInstanceWithArguments( rArguments ); + } + else + { + throw new com.sun.star.uno.Exception( + "retrieved service factory object for \"" + rServiceSpecifier + + "\" does not export XSingleComponentFactory nor XSingleServiceFactory!" ); + } + } + } + return null; + } +// public String[] getAvailableServiceNames(); + + /** + * Removes all listeners from the <code>ServiceManager</code> and clears the list of the services. + * <p> + * @see com.sun.star.lang.XComponent + */ + public void dispose() + throws com.sun.star.uno.RuntimeException + { + if (eventListener != null) { + java.util.Enumeration enumer = eventListener.elements(); + + while (enumer.hasMoreElements()) { + XEventListener listener = (XEventListener) enumer.nextElement(); + listener.disposing(new com.sun.star.lang.EventObject(this)); + } + } + + eventListener.removeAllElements(); + factoriesByServiceNames.clear(); + factoriesByImplNames.clear(); + } + + /** + * Adds a new <code>EventListener</code>. The listener is notified when a + * service is added (removed) to (from) the <code>ServiceManager</code>. + * If the listener is already registred a + * <code>com.sun.star.uno.RuntimeException</code> will be thrown. + * <p> + * @param xListener the new listener which should been added. + * @see com.sun.star.lang.XComponent + */ + public void addEventListener( XEventListener xListener ) + throws com.sun.star.uno.RuntimeException + { + if (xListener == null) + throw new com.sun.star.uno.RuntimeException("Listener must not be null"); + + if ( eventListener.contains(xListener) ) + throw new com.sun.star.uno.RuntimeException("Listener already registred."); + + eventListener.addElement(xListener); + } + + /** + * Removes a <code>EventListener</code> from the <code>ServiceManager</code>. + * If the listener is not registered a <code>com.sun.star.uno.RuntimeException</code> + * will be thrown. + * <p> + * @param xListener the new listener which should been removed. + * @see com.sun.star.lang.XComponent + */ + public void removeEventListener( XEventListener xListener ) + throws com.sun.star.uno.RuntimeException + { + if (xListener == null) + throw new com.sun.star.uno.RuntimeException("Listener must not be null"); + + if ( !eventListener.contains(xListener) ) + throw new com.sun.star.uno.RuntimeException("Listener is not registered."); + + eventListener.removeElement(xListener); + } + + /** + * Checks if a component is registered at the <code>ServiceManager</code>. The given object argument must + * provide a <code>XServiceInfo</code> interface. + * <p> + * @return true if the component is registred otherwise false. + * @param object object which provides a <code>XServiceInfo</code> interface. + * @see com.sun.star.container.XSet + * @see com.sun.star.lang.XServiceInfo + */ + public boolean has( Object object ) + throws com.sun.star.uno.RuntimeException + { + if (object == null) + throw new com.sun.star.uno.RuntimeException("The parameter must not been null"); + + XServiceInfo xServiceInfo = UnoRuntime.queryInterface(XServiceInfo.class, object); + + if (xServiceInfo != null) { + return UnoRuntime.areSame(factoriesByImplNames.get(xServiceInfo.getImplementationName()), object); + } + + return false; + } + + /** + * Adds a <code>SingleServiceFactory</code> to the <code>ServiceManager</code>. + * <p> + * @param object factory which should be added. + * @see com.sun.star.container.XSet + * @see com.sun.star.lang.XSingleServiceFactory + */ + public void insert( Object object ) + throws com.sun.star.lang.IllegalArgumentException, + com.sun.star.container.ElementExistException, + com.sun.star.uno.RuntimeException + { + if (object == null) throw new com.sun.star.lang.IllegalArgumentException(); + + XServiceInfo xServiceInfo = + UnoRuntime.queryInterface(XServiceInfo.class, object); + + if (xServiceInfo == null) + throw new com.sun.star.lang.IllegalArgumentException( + "The given object does not implement the XServiceInfo interface." + ); + + if ( factoriesByImplNames.containsKey( xServiceInfo.getImplementationName() ) ) { + throw new com.sun.star.container.ElementExistException( + xServiceInfo.getImplementationName() + " already registred" + ); + } + + DEBUG("add factory " + object.toString() + " for " + xServiceInfo.getImplementationName()); + factoriesByImplNames.put( xServiceInfo.getImplementationName(), object ); + + + String[] serviceNames = xServiceInfo.getSupportedServiceNames(); + java.util.Vector vec = null; + + for (int i=0; i<serviceNames.length; i++) { + if ( !factoriesByServiceNames.containsKey( serviceNames[i] ) ) { + DEBUG("> no registered services found under " + serviceNames[i] + ": adding..." ); + factoriesByServiceNames.put(serviceNames[i], new java.util.Vector()); + } + + vec = (java.util.Vector) factoriesByServiceNames.get( serviceNames[i] ); + + if ( vec.contains( object ) ) + System.err.println("The implementation " + xServiceInfo.getImplementationName() + + " already registered for the service " + serviceNames[i] + " - ignoring!"); + else + vec.addElement(object); + } + } + + /** + * Removes a <code>SingleServiceFactory</code> from the <code>ServiceManager</code>. + * <p> + * @param object factory which should be removed. + * @see com.sun.star.container.XSet + * @see com.sun.star.lang.XSingleServiceFactory + */ + public void remove( Object object ) + throws com.sun.star.lang.IllegalArgumentException, + com.sun.star.container.NoSuchElementException, + com.sun.star.uno.RuntimeException + { + if (object == null) + throw new com.sun.star.lang.IllegalArgumentException( + "The given object must not be null." + ); + + XServiceInfo xServiceInfo = + UnoRuntime.queryInterface(XServiceInfo.class, object); + + if (xServiceInfo == null) + throw new com.sun.star.lang.IllegalArgumentException( + "The given object does not implement the XServiceInfo interface." + ); + + XSingleServiceFactory xSingleServiceFactory = + UnoRuntime.queryInterface(XSingleServiceFactory.class, object); + + if (xSingleServiceFactory == null) + throw new com.sun.star.lang.IllegalArgumentException( + "The given object does not implement the XSingleServiceFactory interface." + ); + + if ( factoriesByImplNames.remove( xServiceInfo.getImplementationName() ) == null ) + throw new com.sun.star.container.NoSuchElementException( + xServiceInfo.getImplementationName() + + " is not registered as an implementation." + ); + + String[] serviceNames = xServiceInfo.getSupportedServiceNames(); + + for ( int i=0; i<serviceNames.length; i++ ) { + if ( factoriesByServiceNames.containsKey( serviceNames[i] ) ) { + java.util.Vector vec = (java.util.Vector) factoriesByServiceNames.get(serviceNames[i]); + + if ( !vec.removeElement(object) ) + System.err.println("The implementation " + xServiceInfo.getImplementationName() + + " is not registered for the service " + serviceNames[i] + " - ignoring!"); + + if ( vec.isEmpty() ) // remove the vector if no implementations aviable for the service + factoriesByServiceNames.remove( serviceNames[i] ); + } + } + } + + /** + * Provides an enumeration of all registred services. + * <p> + * @return an enumeration of all avialable services. + * @see com.sun.star.conatiner.XEnumerationAccess + */ + public XEnumeration createEnumeration() + throws com.sun.star.uno.RuntimeException + { + return new ServiceEnumerationImpl( factoriesByImplNames.elements() ); + } + + /** + * Provides the UNO type of the <code>ServiceManager</code> + * <p> + * @return the UNO type of the <code>ServiceManager</code>. + * @see com.sun.star.container.XElementAccess + * @see com.sun.star.uno.TypeClass + */ + public com.sun.star.uno.Type getElementType() + throws com.sun.star.uno.RuntimeException + { + if ( UNO_TYPE == null ) + UNO_TYPE = new com.sun.star.uno.Type(ServiceManager.class); + + return UNO_TYPE; + } + + /** + * Checks if the any componets are registered. + * <p> + * @return true - if the list of the registred components is not empty - otherwise false. + * @see com.sun.star.container.XElementAccess + */ + public boolean hasElements() { + return ! factoriesByImplNames.isEmpty(); + } + + /** + * Provides an enumeration of of all factorys for a specified service. + * <p> + * @return an enumeration for service name. + * @param serviceName name of the requested service + * @see com.sun.star.container.XContentEnumerationAccess + */ + public XEnumeration createContentEnumeration( String serviceName ) + throws com.sun.star.uno.RuntimeException + { + XEnumeration enumer = null; + + java.util.Vector serviceList = (java.util.Vector) factoriesByServiceNames.get(serviceName); + + if (serviceList != null) + enumer = new ServiceEnumerationImpl( serviceList.elements() ); + else + enumer = new ServiceEnumerationImpl(); + + return enumer; + } + + /** + * Returns the implementation name of the <code>ServiceManager</code> component. + * <p> + * @return the class name of the <code>ServiceManager</code>. + * @see com.sun.star.lang.XServiceInfo + */ + public String getImplementationName() + throws com.sun.star.uno.RuntimeException + { + return getClass().getName(); + } + + /** + * Checks if the <code>ServiceManager</code> supports a service. + * <p> + * @return true if the service is supported - otherwise false. + * @param serviceName service name which should be checked. + * @see com.sun.star.lang.XServiceInfo + */ + public boolean supportsService( String serviceName ) + throws com.sun.star.uno.RuntimeException + { + for (int i=0; i<supportedServiceNames.length; i++) + if (supportedServiceNames[i].equals( serviceName )) return true; + + if (getImplementationName().equals( serviceName )) return true; + + return false; + } + + /** + * Supplies list of all supported services. + * <p> + * @return a list of all supported service names. + * @see com.sun.star.lang.XServiceInfo + */ + public String[] getSupportedServiceNames() + throws com.sun.star.uno.RuntimeException + { + return supportedServiceNames; + } + + /** + * The <code>ServiceEnumerationImpl</code> class provides an + * implementation of the @see com.sun.star.container.XEnumeration interface. + * It is a inner wrapper for a java.util.Enumeration object. + * <p> + * @version $Revision: 1.10 $ $ $Date: 2008-04-11 11:11:46 $ + * @author Markus Herzog + * @see com.sun.star.lang.XSingleServiceFactory + * @see com.sun.star.lang.XServiceInfo + * @since UDK1.0 + */ + class ServiceEnumerationImpl implements XEnumeration { + java.util.Enumeration enumeration = null; + + /** + * Constructs a new empty instance. + */ + public ServiceEnumerationImpl() { + } + + /** + * Constructs a new instance with a given enumeration. + * <p> + * @param enumer is the enumeration which should been wrapped. + * @see com.sun.star.container.XEnumeration + */ + public ServiceEnumerationImpl(java.util.Enumeration enumer) { + enumeration = enumer; + } + + /** + * Checks if the enumeration contains more elements. + * <p> + * @return true if more elements are available - otherwise false. + * @see com.sun.star.container.XEnumeration + */ + public boolean hasMoreElements() + throws com.sun.star.uno.RuntimeException + { + if (enumeration != null) + return enumeration.hasMoreElements(); + + return false; + } + + /** + * Returns the next element of the enumeration. If no further elements + * available a com.sun.star.container.NoSuchElementException exception will be thrown. + * <p> + * @return the next element. + * @see com.sun.star.container.XEnumeration + */ + public Object nextElement() + throws com.sun.star.container.NoSuchElementException, + com.sun.star.lang.WrappedTargetException, + com.sun.star.uno.RuntimeException + { + if (enumeration == null) + throw new com.sun.star.container.NoSuchElementException(); + + try { + return enumeration.nextElement(); + } catch (java.util.NoSuchElementException e) { + com.sun.star.container.NoSuchElementException ex = + new com.sun.star.container.NoSuchElementException(); + ex.fillInStackTrace(); + + throw ex; + } + } + } +} +/** + * The <code>ServiceManagerFactory</code> is the factory class for the + * <code>ServiceManager</code>. As all factories it implments the + * com.sun.star.lang.XSingleServiceFactory and the com.sun.star.lang.XServiceInfo + * interfaces. + * <p> + * @version $Revision: 1.10 $ $ $Date: 2008-04-11 11:11:46 $ + * @author Markus Herzog + * @see com.sun.star.lang.XSingleServiceFactory + * @see com.sun.star.lang.XServiceInfo + * @since UDK1.0 +*/ +class ServiceManagerFactory implements XServiceInfo, XSingleComponentFactory, XSingleServiceFactory +{ + /** + * Creates a new instance of the <code>ServiceManagerFactory</code>. + */ + public ServiceManagerFactory() { + } + + /** + * Supplies the implementation name of the <code>ServiceManager</code>. + * <p> + * @return <code>ServiceManager</code> class name. + * @see com.sun.star.lang.XServiceInfo + */ + public String getImplementationName() + throws com.sun.star.uno.RuntimeException + { + return ServiceManager.class.getName(); + } + + /** + * Checks wether or not a service is supported. + * <p> + * @return true - if the service is supported, otherwise false. + * @param serviceName the name of the service that should be checked. + * @see com.sun.star.lang.XServiceInfo + */ + public boolean supportsService( String serviceName ) + throws com.sun.star.uno.RuntimeException + { + for ( int i=0; i<ServiceManager.supportedServiceNames.length; i++ ) + if ( ServiceManager.supportedServiceNames[i].equals(serviceName) ) return true; + + if ( getImplementationName().equals(serviceName) ) return true; + + return false; + } + + /** + * Returns all service names which are supported by <code>ServiceManager</code>. + * <p> + * @return a list aof all supported service names. + * @see com.sun.star.lang.XServiceInfo + */ + public String[] getSupportedServiceNames() + throws com.sun.star.uno.RuntimeException + { + return ServiceManager.supportedServiceNames; + } + + /** + * Creates a new instance of the <code>ServiceManager</code>. + * <p> + * @return newly created <code>ServiceManager</code> object. + * @see com.sun.star.lang.XSingleServiceFactory + */ + public java.lang.Object createInstance() + throws com.sun.star.uno.Exception, + com.sun.star.uno.RuntimeException + { + return new ServiceManager(); + } + + /** + * Creates a new instance of the <code>ServiceManager</code> with arguments. + * At this time it always throws a com.sun.star.lang.NoSuchMethodException + * because there is no the <code>ServiceManager</code> has no constructor with + * arguments. + * <p> + * @return null - allways throws an exception + * @param aArguments arguments for new instance. + * @see com.sun.star.lang.XSingleServiceFactory + */ + public java.lang.Object createInstanceWithArguments( java.lang.Object[] aArguments ) + throws com.sun.star.uno.Exception, + com.sun.star.uno.RuntimeException + { + throw new com.sun.star.lang.NoSuchMethodException("Constructor with arguments is not supported."); + } + + // XSingleComponentFactory impl + //______________________________________________________________________________________________ + public Object createInstanceWithContext( XComponentContext xContext ) + throws com.sun.star.uno.Exception, com.sun.star.uno.RuntimeException + { + return new ServiceManager( xContext ); + } + //______________________________________________________________________________________________ + public Object createInstanceWithArgumentsAndContext( + Object aArguments [], XComponentContext xContext ) + throws com.sun.star.uno.Exception, com.sun.star.uno.RuntimeException + { + throw new com.sun.star.lang.NoSuchMethodException( + "ServiceManagerFactory.createInstanceWithArgumentsAndContext() not impl!" ); + } +} + + |