org/objectweb/proactive/core/group/ProxyForGroup.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.InvocationTargetException;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;
import java.util.Vector;

import org.apache.log4j.Logger;
import org.objectweb.proactive.Body;
import org.objectweb.proactive.ProActive;
import org.objectweb.proactive.core.UniqueID;
import org.objectweb.proactive.core.body.LocalBodyStore;
import org.objectweb.proactive.core.body.proxy.AbstractProxy;
import org.objectweb.proactive.core.component.ProActiveInterface;
import org.objectweb.proactive.core.exceptions.manager.NFEManager;
import org.objectweb.proactive.core.exceptions.proxy.FailedGroupRendezVousException;
import org.objectweb.proactive.core.group.spmd.MethodCallSetSPMDGroup;
import org.objectweb.proactive.core.group.threadpool.ThreadPool;
import org.objectweb.proactive.core.mop.ClassNotReifiableException;
import org.objectweb.proactive.core.mop.ConstructionOfReifiedObjectFailedException;
import org.objectweb.proactive.core.mop.ConstructorCall;
import org.objectweb.proactive.core.mop.MOP;
import org.objectweb.proactive.core.mop.MethodCall;
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.util.log.Loggers;
import org.objectweb.proactive.core.util.log.ProActiveLogger;
import org.objectweb.proactive.core.util.profiling.PAProfilerEngine;
import org.objectweb.proactive.core.util.profiling.Profiling;
import org.objectweb.proactive.core.util.timer.CompositeAverageMicroTimer;


public class ProxyForGroup extends AbstractProxy implements Proxy, Group,
    java.io.Serializable {

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

    protected String className;

    protected Vector memberList;

    protected Map elementNames;

    // NOT FULLY IMPLEMENTED !!!
    transient protected UniqueID proxyForGroupID;

    protected int waited = 0;

    protected boolean dispatching = false;

    protected boolean uniqueSerialization = false;

    protected StubObject stub;

    transient protected ThreadPool threadpool;

    protected CompositeAverageMicroTimer timer;

    /* ----------------------- CONSTRUCTORS ----------------------- */
    public ProxyForGroup(String nameOfClass)
        throws ConstructionOfReifiedObjectFailedException {
        this();
        this.className = nameOfClass;
    }

    public ProxyForGroup() throws ConstructionOfReifiedObjectFailedException {
        this.memberList = new Vector();
        this.proxyForGroupID = new UniqueID();
        this.threadpool = new ThreadPool();
        this.elementNames = new HashMap();
        if (Profiling.GROUP) {
            timer = new CompositeAverageMicroTimer("Group");
            PAProfilerEngine.registerTimer(timer);
        }
    }

    public ProxyForGroup(ConstructorCall c, Object[] p)
        throws ConstructionOfReifiedObjectFailedException {
        this();
    }

    /* ----------------------------- GENERAL ---------------------------------- */

    protected void setDispatchingOn() {
        this.dispatching = true;
    }

    protected void setDispatchingOff() {
        this.dispatching = false;
    }

    protected void setUniqueSerializationOn() {
        this.uniqueSerialization = true;
    }

    protected void setUniqueSerializationOff() {
        this.uniqueSerialization = false;
    }

    protected boolean isDispatchingOn() {
        return this.dispatching;
    }

    private boolean isDispatchingCall(MethodCall mc) {
        for (int i = 0; i < mc.getNumberOfParameter(); i++)
            if (ProActiveGroup.isScatterGroupOn(mc.getParameter(i))) {
                return true;
            }
        return false;
    }

    /* ------------------------ THE PROXY'S METHOD ------------------------ */

    public synchronized Object reify(MethodCall mc)
        throws InvocationTargetException  {
        //System.out.println("A method is called : \"" + mc.getName() + "\" on " + this.memberList.size() + " membres.");
        ExceptionListException exceptionList = null;

        /* if the method called is toString, apply it to the proxy, not to the members */
        if ("toString".equals(mc.getName())) {
            return this.toString();
        }

        /* if the method called is hashCode, apply it to the proxy, not to the members */
        if ("hashCode".equals(mc.getName())) {
            return new Integer(this.hashCode());
        }

        if ("equals".equals(mc.getName()) && (mc.getNumberOfParameter() == 1)) {
            return new Boolean(this.equals(mc.getParameter(0)));
        }
        
        // there may be some reorganization of the parameters
//        redistributeParameters(mc);

        /* result will be a stub on a proxy for group representing the group of results */
        Object result = null;

        /* check if the threadpool is big enough to make the call (is there is not enough thread, create new ones) */
        this.threadpool.checkNumberOfThreads(this.memberList.size());

        /* if OneWay : do not construct result */
        if (mc.isOneWayCall()) {
            exceptionList = new ExceptionListException();
            this.oneWayCallOnGroup(mc, exceptionList);
        }
        /* Special case : the method returns void but is Synchronous because it throws Exception */
        else if (mc.getReifiedMethod().getReturnType() == Void.TYPE) {
            exceptionList = new ExceptionListException();
            this.oneWayCallOnGroup(mc, exceptionList);
        }
        /* if the call is asynchronous the group of result will be a group a future */
        else { // with group in general case : SYNC == ASYNC !!!!
            result = this.asynchronousCallOnGroup(mc);
        }

        /* A barrier of synchronisation to be sur that all calls are done before continuing the execution */
        this.threadpool.complete();

        /* Throws the exceptionList if one or more exceptions occur in the oneWayCall */
        if ((exceptionList != null) && (exceptionList.size() != 0)) {
            FailedGroupRendezVousException fgrve = new FailedGroupRendezVousException(
                    "RendezVous failed in group method: " + mc.getName(),
                    exceptionList, this);
            NFEManager.fireNFE(fgrve, this);
        }

        return result;
    }

    public void finalize() {
        this.threadpool.clean();
    }

    /* ------------ FOR ASYNCHRONOUS CALL ------------ */

    protected Object asynchronousCallOnGroup(MethodCall mc) throws InvocationTargetException {
        Object result;
        Body body = ProActive.getBodyOnThis();
        if (Profiling.GROUP) {
            timer.setTimer("asynchronousCallOnGroup." + mc.getName());
            timer.start();
        }

        // Creates a stub + ProxyForGroup for representing the result
        String returnTypeClassName = null;
        try {
            Object[] paramProxy = new Object[0];
            Type t = mc.getReifiedMethod().getGenericReturnType();
            if (t instanceof TypeVariable) {
                returnTypeClassName = mc.getGenericTypesMapping().get(t).getName();
            } else {
                returnTypeClassName = mc.getReifiedMethod().getReturnType().getName();
            }

            result = MOP.newInstance(returnTypeClassName,
                    null, null, ProxyForGroup.class.getName(), paramProxy);
            
            ((ProxyForGroup) ((StubObject) result).getProxy()).className = returnTypeClassName;
            
        } catch (ClassNotReifiableException e1) {
            throw new InvocationTargetException(e1, "Method " + mc.getReifiedMethod().toGenericString() + " : cannot return a group of results for the non reifiable type " + returnTypeClassName);
        } catch (Exception e2) {
                throw new InvocationTargetException(e2, "Method " + mc.getReifiedMethod().toGenericString() + " : cannot create group of results");
        }

        int size = this.memberList.size();

        // Init the lists of result with null value to permit the "set(index)" operation
        Vector memberListOfResultGroup = ((ProxyForGroup) ((StubObject) result).getProxy()).memberList;
        for (int i = 0; i < size; i++) {
            memberListOfResultGroup.add(null);
        }

        // Creating Threads
        if (isDispatchingCall(mc) == false) {
            if (uniqueSerialization) {
                mc.transformEffectiveArgumentsIntoByteArray();
            }
            for (int index = 0; index < this.memberList.size(); index++)
                this.threadpool.addAJob(new ProcessForAsyncCall(this,
                        this.memberList, memberListOfResultGroup, index, mc,
                        body));
        } else { // isDispatchingCall == true
            //Object[] individualEffectiveArguments = distributeParameters(mc);
            for (int index = 0; index < memberList.size(); index++) {
                
                Object[] individualEffectiveArguments = new Object[mc.getNumberOfParameter()];
                for (int i = 0; i < mc.getNumberOfParameter(); i++)
                    if (ProActiveGroup.isScatterGroupOn(mc.getParameter(i))) {
                        individualEffectiveArguments[i] = ProActiveGroup.get(mc.getParameter(
                                    i),
                                index % ProActiveGroup.size(mc.getParameter(i)));
                    } else {
                        individualEffectiveArguments[i] = mc.getParameter(i);
                    }
                this.threadpool.addAJob(new ProcessForAsyncCall(this,
                        this.memberList, memberListOfResultGroup, index,
                        new MethodCall(mc.getReifiedMethod(), mc.getGenericTypesMapping(),
                            individualEffectiveArguments, mc.getExceptionContext()),
                        body));
            }
        }

        LocalBodyStore.getInstance().setCurrentThreadBody(body);
        if (Profiling.GROUP) {
            timer.stop();
        }
        return result;
    }

//    protected Object[] distributeParameters(MethodCall mc) {
//        Object[] individualEffectiveArguments = null;
//        individualEffectiveArguments = new Object[mc.getNumberOfParameter()];
//        for (int index = 0; index < memberList.size(); index++) {
//            for (int i = 0; i < mc.getNumberOfParameter(); i++)
//                if (ProActiveGroup.isScatterGroupOn(mc.getParameter(i))) {
//                    individualEffectiveArguments[i] = ProActiveGroup.get(mc.getParameter(
//                                i),
//                            index % ProActiveGroup.size(mc.getParameter(i)));
//                } else {
//                    individualEffectiveArguments[i] = mc.getParameter(i);
//                }
//        }
//        return individualEffectiveArguments;
//    }

    protected void addToListOfResult(Vector memberListOfResultGroup,
        Object result, int index) {
        memberListOfResultGroup.set(index, result);
    }

    /* -------------------- FOR ONEWAY CALL ---------------------- */

    protected void oneWayCallOnGroup(MethodCall mc,
        ExceptionListException exceptionList) throws InvocationTargetException {
        Body body = ProActive.getBodyOnThis();
        if (Profiling.GROUP) {
            timer.setTimer("oneWayCallOnGroup." + mc.getName());
            timer.start();
        }

        // Creating Threads
        if (isDispatchingCall(mc) == false) {
            if (uniqueSerialization) {
                mc.transformEffectiveArgumentsIntoByteArray();
            }
            for (int index = 0; index < this.memberList.size(); index++) {
                this.threadpool.addAJob(new ProcessForOneWayCall(this,
                        this.memberList, index, mc, body, exceptionList));
            }
        } else { // isDispatchingCall == true
//            Object[] individualEffectiveArguments = distributeParameters(mc);
            for (int index = 0; index < memberList.size(); index++) {
                Object[] individualEffectiveArguments = new Object[mc.getNumberOfParameter()];
                for (int i = 0; i < mc.getNumberOfParameter(); i++)
                    if (ProActiveGroup.isScatterGroupOn(mc.getParameter(i))) {
                        individualEffectiveArguments[i] = ProActiveGroup.get(mc.getParameter(
                                    i),
                                index % ProActiveGroup.size(mc.getParameter(i)));
                    } else {
                        individualEffectiveArguments[i] = mc.getParameter(i);
                    }
                this.threadpool.addAJob(new ProcessForOneWayCall(this,
                        this.memberList, index,
                        new MethodCall(mc.getReifiedMethod(), mc.getGenericTypesMapping(),
                            individualEffectiveArguments, mc.getExceptionContext()),
                        body, exceptionList));
            }
        }

        LocalBodyStore.getInstance().setCurrentThreadBody(body);

        if (Profiling.GROUP) {
            timer.stop();
        }
    }

    /* ------------------- java.util.List methods------------------ */

    public boolean add(Object o) {
        try {
            if ((MOP.forName(this.className)).isAssignableFrom(o.getClass())) {

                /* if o is an reified object and if it is "assignableFrom" the class of the group, ... add it into the group */
                if (MOP.isReifiedObject(o)) {
                    return this.memberList.add(o);
                }
                // COMPONENTS

                /* if o is a reference on a component interface*/
                else if (o instanceof ProActiveInterface) {
                    return this.memberList.add(o);
                } /* if o is a Group */ else if (o instanceof org.objectweb.proactive.core.group.ProxyForGroup) {

                    /* like an addMerge call */
                    return this.memberList.addAll(((org.objectweb.proactive.core.group.ProxyForGroup) o).memberList);
                } /* o is a standard Java object */ else {
                    return this.memberList.add(o);
                }
            } else {
                if (logger.isInfoEnabled()) {
                    logger.info("uncompatible Object");
                }
                return false;
            }
        } catch (java.lang.ClassNotFoundException e) {
            if (logger.isInfoEnabled()) {
                logger.info("Unknown class : " + this.className);
            }
        }
        return true;
    }

    public boolean addAll(Collection c) {
        boolean modified = false;
        Iterator iterator = c.iterator();
        while (iterator.hasNext()) {
            modified |= this.add(iterator.next());
        }
        return modified;
    }

    public void clear() {
        this.memberList.clear();
    }

    public boolean contains(Object o) {
        return this.memberList.contains(o);
    }

    public boolean containsAll(Collection c) {
        boolean contained;
        Iterator iterator = c.iterator();
        while (iterator.hasNext()) {
            contained = this.contains(iterator.next());
            if (!contained) {
                return false;
            }
        }
        return true;
    }

    public boolean equals(Object o) {
        ProxyForGroup p = ProActiveGroup.findProxyForGroup(o);
        if (p != null) {
            // comparing with another group
            return this.memberList.equals(((org.objectweb.proactive.core.group.ProxyForGroup) p).memberList);
        } else {
            return false;
        }
    }

    public int hashCode() {
        return this.memberList.hashCode();
    }

    public boolean isEmpty() {
        return this.memberList.isEmpty();
    }

    public Iterator iterator() {
        return this.memberList.iterator();
    }

    public boolean remove(Object o) {
        return this.memberList.remove(o);
    }

    public boolean removeAll(Collection c) {
        boolean modified = false;
        Iterator iterator = c.iterator();
        while (iterator.hasNext()) {
            modified |= this.remove(iterator.next());
        }
        return modified;
    }

    public boolean retainAll(Collection c) {
        boolean modified = false;
        Iterator iterator = c.iterator();
        while (iterator.hasNext()) {
            Object tmp = iterator.next();
            if (this.contains(tmp)) {
                modified |= this.remove(tmp);
            }
        }
        return modified;
    }

    public int size() {
        return this.memberList.size();
    }

    public Object[] toArray() {
        return this.memberList.toArray();
    }

    public Object[] toArray(Object[] a) {
        return this.memberList.toArray(a);
    }

    /* ---------------------- THE GROUP'S METHOD ------------------- */

    public void addMerge(Object oGroup) {
        try {

            /* check oGroup is an Reified Object and if it is "assignableFrom" the class of the group */
            if ((MOP.isReifiedObject(oGroup)) &&
                    ((MOP.forName(this.className)).isAssignableFrom(
                        oGroup.getClass()))) {

                /* check oGroup is an object representing a group */
                if (((StubObject) oGroup).getProxy() instanceof org.objectweb.proactive.core.group.ProxyForGroup) {
                    memberList.addAll(((ProxyForGroup) ((StubObject) oGroup).getProxy()).memberList);
                } /* if oGroup is a Standard Active Object (but not a group), just add it */ else {
                    this.add(oGroup);
                }
            } /* if oGroup is a Group */ else if (oGroup instanceof org.objectweb.proactive.core.group.ProxyForGroup) {
                memberList.addAll(((org.objectweb.proactive.core.group.ProxyForGroup) oGroup).memberList);
            }
        } catch (java.lang.ClassNotFoundException e) {
            if (logger.isInfoEnabled()) {
                logger.info("Unknown class : " + this.className);
            }
        }
    }

    public int indexOf(Object obj) {
        return this.memberList.indexOf(obj);
    }

    public ListIterator listIterator() {
        return this.memberList.listIterator();
    }

    public Object remove(int index) {
        // decrease indexes in the map element names <-> indexes
        Iterator it = elementNames.keySet().iterator();
        while (it.hasNext()) {
            String key = (String) it.next();
            Integer value = (Integer) elementNames.get(key);
            if (value.intValue() > index) {
                elementNames.put(key, new Integer(value.intValue() - 1));
            }
        }
        return this.memberList.remove(index);
    }

    public Object get(int i) {
        return this.memberList.get(i);
    }

    public Class getType() throws java.lang.ClassNotFoundException {
        return MOP.forName(this.className);
    }

    public String getTypeName() {
        return this.className;
    }

    public Object getGroupByType() {
        Object result;
        try { // a new proxy is generated
            result = MOP.newInstance(this.className, 
                    null, null, ProxyForGroup.class.getName(), null);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
        ProxyForGroup proxy = (ProxyForGroup) ((StubObject) result).getProxy();
        proxy.memberList = this.memberList;
        proxy.className = this.className;
        proxy.proxyForGroupID = this.proxyForGroupID;
        proxy.waited = this.waited;
        return result;
    }

    //  This is the best thing to do, but createStubObject has a private acces !!!! :
    //    // Instanciates the stub object
    //    StubObject stub = MOP.createStubObject(this.className, MOP.forName(this.className));
    //    // Connects the proxy to the stub
    //    stub.setProxy(this);
    //    return stub;
    //  }
    //  An other way is to "store" the stub and return it when asked

    public Group union(Group g) {
        try {
            if ((MOP.forName(this.getTypeName())).isAssignableFrom(MOP.forName(
                            g.getTypeName()))) {
                ProxyForGroup result = new ProxyForGroup(this.getTypeName());

                // add the members of this
                Iterator it = this.iterator();
                while (it.hasNext()) {
                    result.add(it.next());
                }

                // add the members of g
                it = g.iterator();
                while (it.hasNext()) {
                    result.add(it.next());
                }
                return result;
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (ConstructionOfReifiedObjectFailedException e) {
            e.printStackTrace();
        }

        // the group are incompatible (i.e. they have not members of the the same class)
        return null;
    }

    public Group intersection(Group g) {
        try {
            if ((MOP.forName(this.getTypeName())).isAssignableFrom(MOP.forName(
                            g.getTypeName()))) {
                ProxyForGroup result = new ProxyForGroup(this.getTypeName());
                Object member;
                Iterator it = this.iterator();

                // add the members of the group that belong to g
                while (it.hasNext()) {
                    member = it.next();
                    if (g.indexOf(member) > -1) {
                        result.add(member);
                    }
                }
                return result;
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (ConstructionOfReifiedObjectFailedException e) {
            e.printStackTrace();
        }

        // the group are incompatible (i.e. they have not members of the the same class)
        return null;
    }

    public Group exclude(Group g) {
        try {
            if ((MOP.forName(this.getTypeName())).isAssignableFrom(MOP.forName(
                            g.getTypeName()))) {
                ProxyForGroup result = new ProxyForGroup(this.getTypeName());
                Object member;
                Iterator it = this.iterator();
                while (it.hasNext()) {
                    member = it.next();
                    if (g.indexOf(member) < 0) {
                        result.add(member);
                    }
                }
                return result;
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (ConstructionOfReifiedObjectFailedException e) {
            e.printStackTrace();
        }

        // the group are incompatible (i.e. they have not members of the the same class)
        return null;
    }

    public Group difference(Group g) {
        try {
            if ((MOP.forName(this.getTypeName())).isAssignableFrom(MOP.forName(
                            g.getTypeName()))) {
                ProxyForGroup result = new ProxyForGroup(this.getTypeName());
                Object member;
                Iterator it = this.iterator();

                // add the members of the group that do not belong to g
                while (it.hasNext()) {
                    member = it.next();
                    if (g.indexOf(member) < 0) {
                        result.add(member);
                    }
                }
                it = g.iterator();
                // add the members of g that do not belong to the group
                while (it.hasNext()) {
                    member = it.next();
                    if (this.indexOf(member) < 0) {
                        result.add(member);
                    }
                }
                return result;
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (ConstructionOfReifiedObjectFailedException e) {
            e.printStackTrace();
        }

        // the group are incompatible (i.e. they have not members of the the same class)
        return null;
    }

    public Group range(int begin, int end) {
        // bag arguments => return null
        if (begin > end) {
            return null;
        }
        if (begin < 0) {
            begin = 0;
        }
        if (end > this.size()) {
            end = this.size();
        }
        try {
            ProxyForGroup result = new ProxyForGroup(this.getTypeName());
            for (int i = begin; i <= end; i++) {
                result.add(this.get(i));
            }
            return result;
        } catch (ConstructionOfReifiedObjectFailedException e) {
            e.printStackTrace();
            return null;
        }
    }

    public void setSPMDGroup(Object spmdGroup) {
        try {
            this.reify(new MethodCallSetSPMDGroup(spmdGroup));
        } catch (InvocationTargetException e) {
            logger.info("Unable to set the SPMD group");
            e.printStackTrace();
        }
    }

    public void display() {
        logger.info("Number of member : " + memberList.size());
        for (int i = 0; i < memberList.size(); i++)
            logger.info("  " + i + " : " +
                memberList.get(i).getClass().getName());
    }

    /* ------------------- SYNCHRONIZATION -------------------- */

    public void waitAll() {
        ProActive.waitForAll(this.memberList);
    }

    public void waitOne() {
        ProActive.waitForAny(this.memberList);
    }

    public void waitTheNth(int n) {
        ProActive.waitFor(this.memberList.get(n));
    }

    public void waitN(int n) {
        for (int i = 0; i < n; i++) {
            this.waitTheNth(i);
        }
    }

    public Object waitAndGetOne() {
        return this.memberList.get(ProActive.waitForAny(this.memberList));
    }

    public Object waitAndGetOneThenRemoveIt() {
        return this.memberList.remove(ProActive.waitForAny(this.memberList));
    }

    public Object waitAndGetTheNth(int n) {
        ProActive.waitForTheNth(this.memberList, n);
        return this.memberList.get(n);
    }

    public int waitOneAndGetIndex() {
        int index = 0;
        this.memberList.get(ProActive.waitForAny(this.memberList));
        while (ProActive.isAwaited(this.memberList.get(index))) {
            index++;
        }
        return index;
    }

    public boolean allAwaited() {
        for (int i = 0; i < this.memberList.size(); i++)
            if (!(ProActive.isAwaited(this.memberList.get(i)))) {
                return false;
            }
        return true;
    }

    public boolean allArrived() {
        for (int i = 0; i < this.memberList.size(); i++)
            if (ProActive.isAwaited(this.memberList.get(i))) {
                return false;
            }
        return true;
    }

    public ExceptionListException getExceptionList() {
        ExceptionListException exceptionList = new ExceptionListException();
        for (int i = 0; i < this.memberList.size(); i++) {
            if (this.memberList.get(i) instanceof Throwable) {
                exceptionList.add(new ExceptionInGroup(null, i,
                        (Throwable) this.memberList.get(i)));
            }
        }
        return exceptionList;
    }

    public void purgeExceptionAndNull() {
        Iterator it = this.memberList.iterator();
        while (it.hasNext()) {
            Object element = (Object) it.next();
            if ((element instanceof Throwable) || (element == null)) {
                it.remove();
            }
        }
    }

    public void setRatioMemberToThread(int i) {
        this.threadpool.ratio(i);
    }

    public void setAdditionalThread(int i) {
        this.threadpool.thread(i);
    }

    /* ---------------------- METHOD FOR SYNCHRONOUS CREATION OF A TYPED GROUP ---------------------- */

    public void createMemberWithMultithread(String className, Class[] genericParameters,
        Object[][] params, Node[] nodeList) {
        // Initializes the Group to the correct size
        for (int i = 0; i < params.length; i++) {
            this.memberList.add(null);
        }
        for (int i = 0; i < params.length; i++) {
            this.threadpool.addAJob(new ProcessForGroupCreation(this,
                    className, genericParameters, params[i], nodeList[i % nodeList.length], i));
        }
        this.threadpool.complete();
    }

    protected void createMemberWithMultithread(String className, Class[] genericParameters,
        Object[] params, Node[] nodeList) {
        // Initializes the Group to the correct size
        for (int i = 0; i < nodeList.length; i++) {
            this.memberList.add(null);
        }
        for (int i = 0; i < nodeList.length; i++) {
            this.threadpool.addAJob(new ProcessForGroupCreation(this,
                    className, genericParameters, params, nodeList[i], i));
        }
        this.threadpool.complete();
    }

    /*
     * @see java.util.List#set(int, java.lang.Object)
     */
     public Object set(int index, Object o) {
        return this.memberList.set(index, o);
    }
     
     

    /*
     * @see java.util.List#add(int, java.lang.Object)
     */
    public void add(int index, Object element) {
        memberList.add(index, element);
    }

    /*
     * @see java.util.List#addAll(int, java.util.Collection)
     */
    public boolean addAll(int index, Collection c) {
        return memberList.addAll(index, c);
    }

    /*
     * @see java.util.List#lastIndexOf(java.lang.Object)
     */
    public int lastIndexOf(Object o) {
        return memberList.lastIndexOf(o);
    }

    /*
     * @see java.util.List#listIterator(int)
     */
    public ListIterator listIterator(int index) {
        return memberList.listIterator(index);
    }

    /*
     * @see java.util.List#subList(int, int)
     */
    public List subList(int fromIndex, int toIndex) {
        return memberList.subList(fromIndex, toIndex);
    }

    /* ------------------------ PRIVATE METHODS FOR SERIALIZATION --------------------- */
    private void writeObject(java.io.ObjectOutputStream out)
        throws java.io.IOException {
        // this.threadpool.finalize();
        out.defaultWriteObject();
    }

    private void readObject(java.io.ObjectInputStream in)
        throws java.io.IOException, ClassNotFoundException {
        in.defaultReadObject();
        this.proxyForGroupID = new UniqueID();
        this.threadpool = new ThreadPool();
    }

    //Map class style method

    public boolean containsKey(String key) {
        return this.elementNames.containsKey(key);
    }

    public boolean containsValue(Object value) {
        return this.memberList.contains(value);
    }

    public synchronized Object getNamedElement(String key) {
        return get(((Integer) this.elementNames.get(key)).intValue());
    }

    public synchronized void addNamedElement(String key, Object value) {
        if (elementNames.containsKey(key)) {
            removeNamedElement(key);
        }
        this.elementNames.put(key, new Integer(this.size()));
        this.add(value);
    }

    public Set keySet() {
        return this.elementNames.keySet();
    }

    public synchronized Object removeNamedElement(String key) {
        int index = ((Integer) elementNames.get(key)).intValue();
        Object removed = get(index);
        remove(index);
        elementNames.remove(key);
        return removed;
    }
    
    protected void redistributeParameters(MethodCall mc) {
        // nothing here
    }

    
    public String getClassName() {
    
        return className;
    }

    
    public Vector getMemberList() {
    
        return memberList;
    }

    
    public void setClassName(String className) {
    
        this.className = className;
    }

}

---