org/objectweb/proactive/core/group/ProActiveGroup.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.util.Iterator;

import org.apache.log4j.Logger;
import org.objectweb.proactive.ActiveObjectCreationException;
import org.objectweb.proactive.ProActive;
import org.objectweb.proactive.core.body.future.FutureProxy;
import org.objectweb.proactive.core.descriptor.data.VirtualNode;
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.InvalidProxyClassException;
import org.objectweb.proactive.core.mop.MOP;
import org.objectweb.proactive.core.mop.Proxy;
import org.objectweb.proactive.core.mop.StubObject;
import org.objectweb.proactive.core.node.Node;
import org.objectweb.proactive.core.node.NodeException;
import org.objectweb.proactive.core.node.NodeFactory;
import org.objectweb.proactive.core.util.log.Loggers;
import org.objectweb.proactive.core.util.log.ProActiveLogger;


public class ProActiveGroup {

    protected static Logger logger = ProActiveLogger.getLogger(Loggers.GROUPS);

    public static final Class DEFAULT_PROXYFORGROUP_CLASS = org.objectweb.proactive.core.group.ProxyForGroup.class;

    public static final String DEFAULT_PROXYFORGROUP_CLASS_NAME = "org.objectweb.proactive.core.group.ProxyForGroup";

    private ProActiveGroup() {
    }

    public static Group getGroup(Object o) {
        return ProActiveGroup.findProxyForGroup(o);
    }

    public static String getType(Object o) {
        ProxyForGroup tmp = ProActiveGroup.findProxyForGroup(o);
        if (tmp != null) {
            return tmp.getTypeName();
        } else {
            return o.getClass().getName();
        }
    }

    public static Object newGroup(String className)
    throws ClassNotFoundException, ClassNotReifiableException {
        return ProActiveGroup.newGroup(className, (Class[])null);
    }
    
    

    public static Object newGroup(String className, Object[][] params)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        Node[] nodeList = new Node[1];
        nodeList[0] = NodeFactory.getDefaultNode();

        return ProActiveGroup.newGroup(className, params, nodeList);
    }
    

    public static Object newGroup(String className, Object[][] params,
        String nodeName)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        Node[] nodeList = new Node[1];
        nodeList[0] = NodeFactory.getNode(nodeName);
        return ProActiveGroup.newGroup(className, params, nodeList);
    }

    public static Object newGroup(String className, Object[][] params,
        String[] nodeListString)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        Node[] nodeList = new Node[nodeListString.length];
        for (int i = 0; i < nodeListString.length; i++)
            nodeList[i] = NodeFactory.getNode(nodeListString[i]);
        return ProActiveGroup.newGroup(className, params, nodeList);
    }

    public static Object newGroup(String className, Object[][] params, Node node)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        Node[] nodeList = new Node[1];
        nodeList[0] = node;
        return ProActiveGroup.newGroup(className, params, nodeList);
    }

    public static Object newGroup(String className, Class[] genericParameters, Object[][] params,
        Node[] nodeList)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        Object result = ProActiveGroup.newGroup(className, genericParameters);
        Group g = ProActiveGroup.getGroup(result);

        if (params != null) {
            for (int i = 0; i < params.length; i++) {
                g.add(ProActive.newActive(className, params[i],
                        nodeList[i % nodeList.length]));
            }
        }

        return result;
    }
    
    
    public static Object newGroup(String className, Object[][] params,
            Node[] nodeList)
            throws ClassNotFoundException, ClassNotReifiableException, 
                ActiveObjectCreationException, NodeException {
        return ProActiveGroup.newGroup(className, (Class[])null, params, nodeList);
    }

    public static Object newGroup(String className, Object[][] params,
        VirtualNode virtualNode)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        return ProActiveGroup.newGroup(className, params, virtualNode.getNodes());
    }

    public static Object newGroup(String className, Object[] params,
        Node[] nodeList)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        Object result = ProActiveGroup.newGroup(className, (Class[])null);
        Group g = ProActiveGroup.getGroup(result);

        if (params != null) {
            for (int i = 0; i < nodeList.length; i++) {
                g.add(ProActive.newActive(className, params,
                        nodeList[i % nodeList.length]));
            }
        }

        return result;
    }

    public static Object newGroup(String className, Object[] params,
        VirtualNode virtualNode)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        return ProActiveGroup.newGroup(className, params, virtualNode.getNodes());
    }

    public static Object newGroup(String className, Object[] params, Node node)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        Node[] nodeList = new Node[1];
        nodeList[0] = node;
        return ProActiveGroup.newGroup(className, params, nodeList);
    }

    public static Object newGroup(String className, Object[] params,
        String nodeName)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        Node[] nodeList = new Node[1];
        nodeList[0] = NodeFactory.getNode(nodeName);
        return ProActiveGroup.newGroup(className, params, nodeList);
    }

    public static Object newGroup(String className, Object[] params,
        String[] nodeListString)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        Node[] nodeList = new Node[nodeListString.length];
        for (int i = 0; i < nodeListString.length; i++)
            nodeList[i] = NodeFactory.getNode(nodeListString[i]);
        return ProActiveGroup.newGroup(className, params, nodeList);
    }

    public static Object turnActiveGroup(Object ogroup)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        return ProActive.turnActive(ogroup, null, ProActiveGroup.getType(ogroup),
            (Node) null, null, null);
    }

    public static Object turnActiveGroup(Object ogroup, Node node)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        return ProActive.turnActive(ogroup, null, ProActiveGroup.getType(ogroup),
            node, null, null);
    }

    public static Object turnActiveGroup(Object ogroup, String nodeName)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        return ProActive.turnActive(ogroup, null, ProActiveGroup.getType(ogroup),
            NodeFactory.getNode(nodeName), null, null);
    }

    // -------------------------------------------------------------------------
    // Start Deprecated
    // -------------------------------------------------------------------------

    public static Object newGroupBuiltWithMultithreading(String className,
        Object[][] params)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        Node[] nodeList = new Node[1];
        nodeList[0] = NodeFactory.getDefaultNode();

        return ProActiveGroup.newGroupBuiltWithMultithreading(className,
            params, nodeList);
    }

    public static Object newGroupBuiltWithMultithreading(String className,
        Object[][] params, Node[] nodeList)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        Object result = ProActiveGroup.newGroup(className, (Class[])null);
        ProxyForGroup proxy = (org.objectweb.proactive.core.group.ProxyForGroup) ProActiveGroup.getGroup(result);

        proxy.createMemberWithMultithread(className, null, params, nodeList);

        return result;
    }

    public static Object newGroupBuiltWithMultithreading(String className,
        Object[][] params, String[] nodeList)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        Node[] nodeListString = new Node[nodeList.length];
        for (int i = 0; i < nodeList.length; i++)
            nodeListString[i] = NodeFactory.getNode(nodeList[i]);
        return ProActiveGroup.newGroupBuiltWithMultithreading(className,
            params, nodeListString);
    }

    public static Object newGroupBuiltWithMultithreading(String className,
        Object[][] params, VirtualNode virtualNode)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        return ProActiveGroup.newGroupBuiltWithMultithreading(className,
            params, virtualNode.getNodes());
    }

    public static Object newGroupBuiltWithMultithreading(String className,
        Object[] params, String[] nodeList)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        Node[] nodeListString = new Node[nodeList.length];
        for (int i = 0; i < nodeList.length; i++)
            nodeListString[i] = NodeFactory.getNode(nodeList[i]);
        return ProActiveGroup.newGroupBuiltWithMultithreading(className,
            params, nodeListString);
    }

    public static Object newGroupBuiltWithMultithreading(String className,
        Object[] params, Node[] nodeList)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        Object result = ProActiveGroup.newGroup(className, (Class[])null);
        ProxyForGroup proxy = (org.objectweb.proactive.core.group.ProxyForGroup) ProActiveGroup.getGroup(result);

        proxy.createMemberWithMultithread(className, null, params, nodeList);

        return result;
    }

    public static Object newGroupBuiltWithMultithreading(String className,
        Object[] params, VirtualNode virtualNode)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        return ProActiveGroup.newGroupBuiltWithMultithreading(className,
            params, virtualNode.getNodes());
    }

    // -------------------------------------------------------------------------
    // End Deprecated
    // -------------------------------------------------------------------------

    public static Object newGroupInParallel(String className, Object[][] params)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        return newGroupInParallel(className, null, params);
    }

    public static Object newGroupInParallel(String className,
        Object[][] params, Node[] nodeList)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        return newGroupInParallel(className, null, params, nodeList);
    }

    public static Object newGroupInParallel(String className,
        Object[][] params, String[] nodeList)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        return newGroupInParallel(className, null, params, nodeList);
    }

    public static Object newGroupInParallel(String className,
        Object[][] params, VirtualNode virtualNode)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        return newGroupInParallel(className, null, params, virtualNode);
    }

    public static Object newGroupInParallel(String className, Object[] params,
        String[] nodeList)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        return newGroupInParallel(className, null, params, nodeList);
    }

    public static Object newGroupInParallel(String className, Object[] params,
        Node[] nodeList)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        return newGroupInParallel(className, null, params, nodeList);
    }

    public static Object newGroupInParallel(String className, Object[] params,
        VirtualNode virtualNode)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        return ProActiveGroup.newGroupInParallel(className, null, params, virtualNode);
    }
    


    public static Object newGroupInParallel(String className, Class[] genericParameters, Object[][] params)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        Node[] nodeList = new Node[1];
        nodeList[0] = NodeFactory.getDefaultNode();

        return ProActiveGroup.newGroupInParallel(className, genericParameters, params, nodeList);
    }

    public static Object newGroupInParallel(String className, Class[] genericParameters, 
        Object[][] params, Node[] nodeList)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        Object result = ProActiveGroup.newGroup(className, genericParameters);
        ProxyForGroup proxy = (org.objectweb.proactive.core.group.ProxyForGroup) ProActiveGroup.getGroup(result);

        proxy.createMemberWithMultithread(className, genericParameters, params, nodeList);

        return result;
    }

    public static Object newGroupInParallel(String className, Class[] genericParameters, 
        Object[][] params, String[] nodeList)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        Node[] nodeListString = new Node[nodeList.length];
        for (int i = 0; i < nodeList.length; i++)
            nodeListString[i] = NodeFactory.getNode(nodeList[i]);
        return ProActiveGroup.newGroupInParallel(className, genericParameters, params,
            nodeListString);
    }

    public static Object newGroupInParallel(String className, Class[] genericParameters, 
        Object[][] params, VirtualNode virtualNode)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        return ProActiveGroup.newGroupInParallel(className, genericParameters, params,
            virtualNode.getNodes());
    }

    public static Object newGroupInParallel(String className, Class[] genericParameters, Object[] params,
        String[] nodeList)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        Node[] nodeListString = new Node[nodeList.length];
        for (int i = 0; i < nodeList.length; i++)
            nodeListString[i] = NodeFactory.getNode(nodeList[i]);
        return ProActiveGroup.newGroupInParallel(className, genericParameters, params,
            nodeListString);
    }

    public static Object newGroupInParallel(String className, Class[] genericParameters, Object[] params,
        Node[] nodeList)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        Object result = ProActiveGroup.newGroup(className, genericParameters);
        ProxyForGroup proxy = (org.objectweb.proactive.core.group.ProxyForGroup) ProActiveGroup.getGroup(result);

        proxy.createMemberWithMultithread(className, genericParameters, params, nodeList);

        return result;
    }

    public static Object newGroupInParallel(String className, Class[] genericParameters, Object[] params,
        VirtualNode virtualNode)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        return ProActiveGroup.newGroupInParallel(className, genericParameters, params,
            virtualNode.getNodes());
    }

    
    
    public static Object newGroup(String className, Class[] genericParameters)
        throws ClassNotFoundException, ClassNotReifiableException {
        MOP.checkClassIsReifiable(MOP.forName(className));

        Object result = null;

        try {
            result = MOP.newInstance(className,
                    genericParameters, null, DEFAULT_PROXYFORGROUP_CLASS_NAME, null);

            ProxyForGroup proxy = (org.objectweb.proactive.core.group.ProxyForGroup) ((StubObject) result).getProxy();
            proxy.className = className;
            proxy.stub = (StubObject) result;
        } catch (ClassNotReifiableException e) {
            logger.error("**** ClassNotReifiableException ****");
        } catch (InvalidProxyClassException e) {
            logger.error("**** InvalidProxyClassException ****");
        } catch (ConstructionOfProxyObjectFailedException e) {
            logger.error("**** ConstructionOfProxyObjectFailedException ****");
        } catch (ConstructionOfReifiedObjectFailedException e) {
            logger.error("**** ConstructionOfReifiedObjectFailedException ****");
        }

        return result;
    }

    public static Object newGroup(String className, Class[] genericParameters, Object[][] params)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        Node[] nodeList = new Node[1];
        nodeList[0] = NodeFactory.getDefaultNode();

        return ProActiveGroup.newGroup(className, genericParameters, params, nodeList);
    }
    

    public static Object newGroup(String className, Class[] genericParameters, Object[][] params,
        String nodeName)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        Node[] nodeList = new Node[1];
        nodeList[0] = NodeFactory.getNode(nodeName);
        return ProActiveGroup.newGroup(className, genericParameters, params, nodeList);
    }

    public static Object newGroup(String className, Class[] genericParameters, Object[][] params,
        String[] nodeListString)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        Node[] nodeList = new Node[nodeListString.length];
        for (int i = 0; i < nodeListString.length; i++)
            nodeList[i] = NodeFactory.getNode(nodeListString[i]);
        return ProActiveGroup.newGroup(className, genericParameters, params, nodeList);
    }

    public static Object newGroup(String className, Class[] genericParameters, Object[][] params, Node node)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        Node[] nodeList = new Node[1];
        nodeList[0] = node;
        return ProActiveGroup.newGroup(className, genericParameters, params, nodeList);
    }

    
    public static Object newGroup(String className, Class[] genericParameters, Object[][] params,
        VirtualNode virtualNode)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        return ProActiveGroup.newGroup(className, genericParameters, params, virtualNode.getNodes());
    }

    public static Object newGroup(String className, Class[] genericParameters, Object[] params,
        Node[] nodeList)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        Object result = ProActiveGroup.newGroup(className, (Class[])genericParameters);
        Group g = ProActiveGroup.getGroup(result);

        if (params != null) {
            for (int i = 0; i < nodeList.length; i++) {
                g.add(ProActive.newActive(className, genericParameters, params,
                        nodeList[i % nodeList.length]));
            }
        }

        return result;
    }

    public static Object newGroup(String className, Class[] genericParameters, Object[] params,
        VirtualNode virtualNode)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        return ProActiveGroup.newGroup(className, genericParameters, params, virtualNode.getNodes());
    }

    public static Object newGroup(String className, Class[] genericParameters, Object[] params, Node node)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        Node[] nodeList = new Node[1];
        nodeList[0] = node;
        return ProActiveGroup.newGroup(className, genericParameters, params, nodeList);
    }

    public static Object newGroup(String className, Class[] genericParameters, Object[] params,
        String nodeName)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        Node[] nodeList = new Node[1];
        nodeList[0] = NodeFactory.getNode(nodeName);
        return ProActiveGroup.newGroup(className, genericParameters, params, nodeList);
    }

    public static Object newGroup(String className, Class[] genericParameters, Object[] params,
        String[] nodeListString)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        Node[] nodeList = new Node[nodeListString.length];
        for (int i = 0; i < nodeListString.length; i++)
            nodeList[i] = NodeFactory.getNode(nodeListString[i]);
        return ProActiveGroup.newGroup(className, genericParameters, params, nodeList);
    }
    
    
    public static Object turnActiveGroup(Object ogroup, Class[] genericParameters)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        return ProActive.turnActive(ogroup, genericParameters, ProActiveGroup.getType(ogroup),
            (Node) null, null, null);
    }

    public static Object turnActiveGroup(Object ogroup, Class[] genericParameters, Node node)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        return ProActive.turnActive(ogroup, genericParameters, ProActiveGroup.getType(ogroup),
            node, null, null);
    }

    public static Object turnActiveGroup(Object ogroup, Class[] genericParameters, String nodeName)
        throws ClassNotFoundException, ClassNotReifiableException, 
            ActiveObjectCreationException, NodeException {
        return ProActive.turnActive(ogroup, genericParameters, ProActiveGroup.getType(ogroup),
            NodeFactory.getNode(nodeName), null, null);
    }



    public static Object captureView(Object ogroup) {
        Object result = null;

        try {
            result = ProActiveGroup.newGroup(ProActiveGroup.getType(ogroup), (Class[])null);
        } catch (ClassNotReifiableException e) {
            logger.error("**** ClassNotReifiableException ****");
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            logger.error("**** ClassNotFoundException ****");
            e.printStackTrace();
        }

        Group go = ProActiveGroup.getGroup(ogroup);
        Group gr = ProActiveGroup.getGroup(result);

        Iterator it = go.iterator();
        while (it.hasNext()) {
            gr.add(it.next());
        }

        return result;
    }

    public static void waitAll(Object o) {
        if (MOP.isReifiedObject(o)) {
            org.objectweb.proactive.core.mop.Proxy theProxy = ProActiveGroup.findProxyForGroup(o);

            // If the object represents a group, we use the proxyForGroup's method
            if (theProxy != null) {
                ((org.objectweb.proactive.core.group.ProxyForGroup) theProxy).waitAll();
            }

            // Else the "standard waitFor" method has been used in the findProxyForGroup method
        }
    }

    public static void waitOne(Object o) {
        if (MOP.isReifiedObject(o)) {
            org.objectweb.proactive.core.mop.Proxy theProxy = ProActiveGroup.findProxyForGroup(o);

            // If the object represents a group, we use the proxyForGroup's method
            if (theProxy != null) {
                ((org.objectweb.proactive.core.group.ProxyForGroup) theProxy).waitOne();
            }

            // Else the "standard waitFor" method has been used in the findProxyForGroup method
        }
    }

    public static void waitN(Object o, int n) {
        if (MOP.isReifiedObject(o)) {
            org.objectweb.proactive.core.mop.Proxy theProxy = ProActiveGroup.findProxyForGroup(o);

            // If the object represents a group, we use the proxyForGroup's method
            if (theProxy != null) {
                ((org.objectweb.proactive.core.group.ProxyForGroup) theProxy).waitN(n);
            }

            // Else the "standard waitFor" method has been used in the findProxyForGroup method
        }
    }

    public static boolean allAwaited(Object o) {
        // If the object is not reified, it cannot be a future (or a group of future)
        if (!(MOP.isReifiedObject(o))) {
            return false;
        } else {
            org.objectweb.proactive.core.mop.Proxy theProxy = ProActiveGroup.findProxyForGroup(o);

            // If the object represents a group, we use the proxyForGroup's method
            if (theProxy != null) {
                return ((org.objectweb.proactive.core.group.ProxyForGroup) theProxy).allAwaited();
            }
            // Else the "standard waitFor" method has been used in the findProxyForGroup method so the future is arrived
            else {
                return false;
            }
        }
    }

    public static boolean allArrived(Object o) {
        // If the object is not reified, it cannot be a future (or a group of future)
        if (!(MOP.isReifiedObject(o))) {
            return true;
        } else {
            org.objectweb.proactive.core.mop.Proxy theProxy = ProActiveGroup.findProxyForGroup(o);

            // If the object represents a group, we use the proxyForGroup's method
            if (theProxy != null) {
                return ((org.objectweb.proactive.core.group.ProxyForGroup) theProxy).allArrived();
            }
            // Else the "standard waitFor" method has been used in the findProxyForGroup method so the future is arrived
            else {
                return true;
            }
        }
    }

    public static Object waitAndGetOne(Object o) {
        if (MOP.isReifiedObject(o)) {
            org.objectweb.proactive.core.mop.Proxy theProxy = ProActiveGroup.findProxyForGroup(o);

            // If the object represents a group, we use the proxyForGroup's method
            if (theProxy != null) {
                return ((org.objectweb.proactive.core.group.ProxyForGroup) theProxy).waitAndGetOne();
            }
            // Else the "standard waitFor" method has been used in the findProxyForGroup method so the future is arrived, just return it
            else {
                return o;
            }
        }
        // if o is not a reified object just return it
        else {
            return o;
        }
    }

    public static Object waitAndGetOneThenRemoveIt(Object o) {
        if (MOP.isReifiedObject(o)) {
            org.objectweb.proactive.core.mop.Proxy theProxy = ProActiveGroup.findProxyForGroup(o);

            // If the object represents a group, we use the proxyForGroup's method
            if (theProxy != null) {
                return ((org.objectweb.proactive.core.group.ProxyForGroup) theProxy).waitAndGetOneThenRemoveIt();
            }
            // Else the "standard waitFor" method has been used in the findProxyForGroup method so the future is arrived, just return it
            else {
                return o;
            }
        }
        // if o is not a reified object just return it
        else {
            return o;
        }
    }

    public static void waitTheNth(Object o, int n) {
        if (MOP.isReifiedObject(o)) {
            org.objectweb.proactive.core.mop.Proxy theProxy = ProActiveGroup.findProxyForGroup(o);

            // If the object represents a group, we use the proxyForGroup's method
            if (theProxy != null) {
                ((org.objectweb.proactive.core.group.ProxyForGroup) theProxy).waitTheNth(n);
            }

            // Else the "standard waitFor" method has been used in the findProxyForGroup method
        }
    }

    public static Object waitAndGetTheNth(Object o, int n) {
        if (MOP.isReifiedObject(o)) {
            org.objectweb.proactive.core.mop.Proxy theProxy = ProActiveGroup.findProxyForGroup(o);

            // If the object represents a group, we use the proxyForGroup's method
            if (theProxy != null) {
                return ((org.objectweb.proactive.core.group.ProxyForGroup) theProxy).waitAndGetTheNth(n);
            }
            // Else the "standard waitFor" method has been used in the findProxyForGroup method so the future is arrived, just return it
            else {
                return o;
            }
        }
        // if o is not a reified object just return it
        else {
            return o;
        }
    }

    public static int waitOneAndGetIndex(Object o) {
        if (MOP.isReifiedObject(o)) {
            org.objectweb.proactive.core.mop.Proxy theProxy = ProActiveGroup.findProxyForGroup(o);

            // If the object represents a group, we use the proxyForGroup's method
            if (theProxy != null) {
                return ((org.objectweb.proactive.core.group.ProxyForGroup) theProxy).waitOneAndGetIndex();
            }
            // Else return 0
            else {
                return 0;
            }
        }
        // if o is not a reified object, return -1
        else {
            return -1;
        }
    }

    public static int size(Object o) {
        ProxyForGroup theProxy = ProActiveGroup.findProxyForGroup(o);
        if (theProxy == null) {
            throw new java.lang.IllegalArgumentException(
                "Parameter doesn't represent a group");
        } else {
            return theProxy.size();
        }
    }

    public static Object get(Object o, int n) {
        org.objectweb.proactive.core.mop.Proxy theProxy = ProActiveGroup.findProxyForGroup(o);
        if (theProxy == null) {
            return null;
        } else {
            return ((org.objectweb.proactive.core.group.ProxyForGroup) theProxy).get(n);
        }
    }

    public static boolean isGroup(Object o) {
        return (ProActiveGroup.findProxyForGroup(o) != null);
    }

    public static void setScatterGroup(Object ogroup) {
        Proxy proxytmp = ProActiveGroup.findProxyForGroup(ogroup);
        if (proxytmp != null) {
            ((ProxyForGroup) proxytmp).setDispatchingOn();
        }
    }

    public static void unsetScatterGroup(Object ogroup) {
        Proxy proxytmp = ProActiveGroup.findProxyForGroup(ogroup);
        if (proxytmp != null) {
            ((ProxyForGroup) proxytmp).setDispatchingOff();
        }
    }

    public static void setUniqueSerialization(Object ogroup) {
        Proxy proxytmp = ProActiveGroup.findProxyForGroup(ogroup);
        if (proxytmp != null) {
            ((ProxyForGroup) proxytmp).setUniqueSerializationOn();
        }
    }

    public static void unsetUniqueSerialization(Object ogroup) {
        Proxy proxytmp = ProActiveGroup.findProxyForGroup(ogroup);
        if (proxytmp != null) {
            ((ProxyForGroup) proxytmp).setUniqueSerializationOff();
        }
    }

    public static boolean isScatterGroupOn(Object ogroup) {
        Proxy proxytmp = ProActiveGroup.findProxyForGroup(ogroup);
        if (proxytmp != null) {
            return ((ProxyForGroup) proxytmp).isDispatchingOn();
        } else {
            return false;
        }
    }

    static ProxyForGroup findProxyForGroup(Object ogroup) {
        if (!(MOP.isReifiedObject(ogroup))) {
            return null;
        } else {
            Proxy tmp = ((StubObject) ogroup).getProxy();

            // obj is an object representing a Group (and not a future)
            if (tmp instanceof org.objectweb.proactive.core.group.ProxyForGroup) {
                return (org.objectweb.proactive.core.group.ProxyForGroup) tmp;
            }

            // obj is a future ... but may be a future-Group
            while (tmp instanceof org.objectweb.proactive.core.body.future.FutureProxy)
                // future of future ...
                if (MOP.isReifiedObject(((FutureProxy) tmp).getResult())) {
                    tmp = ((StubObject) ((FutureProxy) tmp).getResult()).getProxy();
                }
                // future of standard object (or group proxy in case of multicast interfaces)
                else {
                        if (((FutureProxy)tmp).getResult() instanceof ProxyForGroup) {
                                return (ProxyForGroup)((FutureProxy)tmp).getResult();
                        }
                    return null;
                }

            // future-Group
            if (tmp instanceof org.objectweb.proactive.core.group.ProxyForGroup) {
                return (org.objectweb.proactive.core.group.ProxyForGroup) tmp;
            }
            // future of an active object
            else {
                return null;
            }
        }
    }
}

---