/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the 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  ;
	                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  ;
		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);

        return xServiceInfo != null && UnoRuntime.areSame(factoriesByImplNames.get(xServiceInfo.getImplementationName()), object);
        
		}

    /**
     * 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  ;
            
        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  ;
        
        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;

        return getImplementationName().equals(serviceName);
        
        }
    
	/**
	 * 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 
        {
            return enumeration != null && enumeration.hasMoreElements();
                
            }
    
		/**
		 * 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;

        return getImplementationName().equals(serviceName);
        
        }

	/**
	 * 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!" );
    }
}