org/objectweb/proactive/core/group/ProActiveComponentGroup.java

/* 
 * ################################################################
 * 
 * ProActive: The Java(TM) library for Parallel, Distributed, 
 *            Concurrent computing with Security and Mobility
 * 
 * Copyright (C) 1997-2007 INRIA/University of Nice-Sophia Antipolis
 * Contact: proactive@objectweb.org
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or any later version.
 *  
 * This library 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 for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 * USA
 *  
 *  Initial developer(s):               The ProActive Team
 *                        http://www.inria.fr/oasis/ProActive/contacts.html
 *  Contributor(s): 
 * 
 * ################################################################
 */ 
package org.objectweb.proactive.core.group;

import java.lang.reflect.Constructor;

import org.apache.log4j.Logger;
import org.objectweb.fractal.api.Component;
import org.objectweb.fractal.api.Interface;
import org.objectweb.fractal.api.factory.InstantiationException;
import org.objectweb.fractal.api.type.ComponentType;
import org.objectweb.proactive.core.component.ControllerDescription;
import org.objectweb.proactive.core.component.ProActiveInterface;
import org.objectweb.proactive.core.component.ProActiveInterfaceImpl;
import org.objectweb.proactive.core.component.exceptions.InterfaceGenerationFailedException;
import org.objectweb.proactive.core.component.gen.RepresentativeInterfaceClassGenerator;
import org.objectweb.proactive.core.component.group.ProxyForComponentGroup;
import org.objectweb.proactive.core.component.group.ProxyForComponentInterfaceGroup;
import org.objectweb.proactive.core.component.representative.ProActiveComponentRepresentative;
import org.objectweb.proactive.core.component.representative.ProActiveComponentRepresentativeImpl;
import org.objectweb.proactive.core.component.type.ProActiveInterfaceType;
import org.objectweb.proactive.core.mop.ClassNotReifiableException;
import org.objectweb.proactive.core.mop.ConstructionOfProxyObjectFailedException;
import org.objectweb.proactive.core.mop.ConstructionOfReifiedObjectFailedException;
import org.objectweb.proactive.core.mop.ConstructorCall;
import org.objectweb.proactive.core.mop.InvalidProxyClassException;
import org.objectweb.proactive.core.mop.MOP;
import org.objectweb.proactive.core.mop.StubObject;
import org.objectweb.proactive.core.util.log.Loggers;
import org.objectweb.proactive.core.util.log.ProActiveLogger;


public class ProActiveComponentGroup {
    protected static Logger logger = ProActiveLogger.getLogger(Loggers.COMPONENTS);
    
    public static ProActiveInterface newComponentInterfaceGroup(
        ProActiveInterfaceType interfaceType, Component owner)
        throws ClassNotFoundException, ClassNotReifiableException {
        try {
            Object result = MOP.newInstance(ProActiveInterfaceImpl.class.getName(),
                        null, null, ProxyForComponentInterfaceGroup.class.getName(), null);

            ProxyForComponentInterfaceGroup proxy = (ProxyForComponentInterfaceGroup) ((StubObject) result).getProxy();
            proxy.className = Interface.class.getName();

            //return a reference on the generated interface reference corresponding to the interface type
            ProActiveInterface generated = RepresentativeInterfaceClassGenerator.instance()
                                                                                .generateFunctionalInterface(interfaceType.getFcItfName(),
                    owner, interfaceType);
            ((StubObject) generated).setProxy(proxy);

            proxy.setInterfaceType(interfaceType);
            proxy.setOwner(owner);

            return generated;
        } catch (InvalidProxyClassException e) {
            logger.error("**** InvalidProxyClassException ****");
        } catch (ConstructionOfProxyObjectFailedException e) {
            logger.error("**** ConstructionOfProxyObjectFailedException ****");
        } catch (ConstructionOfReifiedObjectFailedException e) {
            logger.error("**** ConstructionOfReifiedObjectFailedException ****");
        } catch (InterfaceGenerationFailedException e) {
            logger.error("**** Interface could not be generated **** " +
                e.getMessage());
        }
        return null;
    }

    public static ProActiveComponentRepresentative newComponentRepresentativeGroup(
        ComponentType componentType, ControllerDescription controllerDesc)
        throws ClassNotFoundException, InstantiationException {
        try {
            ProActiveComponentRepresentative result = null;

            // create the stub with the appropriate parameters
            Constructor constructor = ProActiveComponentRepresentativeImpl.class.getConstructor(new Class[] {
                        ComponentType.class, String.class, String.class
                    });
            result = (ProActiveComponentRepresentative) constructor.newInstance(new Object[] {
                        componentType,
                        controllerDesc.getHierarchicalType(),
                        controllerDesc.getControllersConfigFileLocation()
                    });

            // build the constructor call for the proxy object to create
            ConstructorCall reifiedCall = MOP.buildTargetObjectConstructorCall(ProActiveComponentRepresentativeImpl.class,
                    new Object[] {
                        componentType,
                        controllerDesc.getHierarchicalType(),
                        controllerDesc.getControllersConfigFileLocation()
                    });

            // Instanciates the proxy object
            ProxyForComponentGroup proxy = (ProxyForComponentGroup) MOP.createProxyObject(ProxyForComponentGroup.class.getName(),
                    MOP.EMPTY_OBJECT_ARRAY, reifiedCall);

            // connect the stub to the proxy
            result.setProxy(proxy);

            proxy.className = Component.class.getName();
            proxy.setComponentType(componentType);
            proxy.setControllerDesc(controllerDesc);

            return result;
        } catch (Exception e) {
            throw new InstantiationException(
                "cannot create group of component representatives : " +
                e.getMessage());
        }
    }
}

---