org/objectweb/proactive/core/component/adl/vnexportation/LinkedVirtualNode.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.component.adl.vnexportation;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;


public class LinkedVirtualNode {
    private List composingVirtualNodes;
    private LinkedVirtualNode composer = null;
    private String componentName;
    private String virtualNodeName;
    private boolean isMultiple = false;
    boolean isLeaf = false;

    //    /private boolean selfExported = false;
    public final static String EMPTY_COMPONENT_NAME = "component_name";
    public final static String EMPTY_VIRTUAL_NODE_NAME = "virtual_node_name";

    public LinkedVirtualNode(String componentName, String virtualNodeName) {
        this.componentName = componentName;
        this.virtualNodeName = virtualNodeName;
        composingVirtualNodes = new ArrayList();
    }

    void setComposer(LinkedVirtualNode composer) {
        this.composer = composer;
    }

    public boolean addComposingVirtualNode(LinkedVirtualNode vn) {
        //        System.out.println("ADDING " + vn.toString() + " \nTO : " + toString());
        setMultiple(vn.isMultiple());
        if (!composingVirtualNodes.contains(vn)) {
            composingVirtualNodes.add(vn);
            vn.setComposer(this);
            return true;
        }
        return false;
    }

    public List getComposingVirtualNodes() {
        return composingVirtualNodes;
    }

    public String getComposingVirtualNodesAsString() {
        Iterator iter = getComposingVirtualNodes().iterator();
        StringBuffer buff = new StringBuffer();
        while (iter.hasNext()) {
            LinkedVirtualNode element = (LinkedVirtualNode) iter.next();
            if (element.getDefiningComponentName().equals(EMPTY_COMPONENT_NAME) ||
                    element.getVirtualNodeName().equals(EMPTY_VIRTUAL_NODE_NAME)) {
                continue;
            }
            buff.append(element.getDefiningComponentName() + "." +
                element.getVirtualNodeName());
            buff.append(";");
        }
        return buff.toString();
    }

    public String getVirtualNodeName() {
        return virtualNodeName;
    }

    public String getCompleteNameBeforeComposition() {
        return componentName + '.' + virtualNodeName;
    }

    public String getExportedVirtualNodeNameAfterComposition() {
        return ((composer == null) ? virtualNodeName
                                   : composer.getExportedVirtualNodeNameAfterComposition());
    }

    public String getExportedVirtualNodeNameBeforeComposition() {
        return ((composer == null) ? virtualNodeName
                                   : composer.getVirtualNodeName());
    }

    public void setMultiple(boolean yes) {
        if (yes) {
            isMultiple = true;
        }
    }

    public boolean isMultiple() {
        return isMultiple;
    }

    public boolean isExported() {
        return composingVirtualNodes.size() > 0;
    }

    public String getDefiningComponentName() {
        return componentName;
    }

    //    public void setSelfExported() {
    //        selfExported=true;
    //    }

    public boolean isSelfExported() {
        if (composer == null) {
            return false;
        }

        // FIXME find a better way
        return (isLeaf ||
        composer.getDefiningComponentName().equals(getDefiningComponentName()));
    }

    public boolean isComposedFrom(String componentName, String virtualNodeName) {
        Iterator it = composingVirtualNodes.iterator();
        while (it.hasNext()) {
            LinkedVirtualNode lvn = (LinkedVirtualNode) it.next();
            if (lvn.getDefiningComponentName().equals(componentName)) {
                if (lvn.getVirtualNodeName().equals(virtualNodeName)) {
                    return true;
                }
            }
        }
        return false;
    }

    public LinkedVirtualNode getComposer() {
        return composer;
    }

    public void setIsLeaf() {
        isLeaf = true;
    }

    public boolean isLeaf() {
        return isLeaf;
    }

    public String toString() {
        StringBuffer buffer = new StringBuffer();
        if (composer == this) {
            buffer.append(getDefiningComponentName() + "." +
                getVirtualNodeName() + "<--" + componentName + "." +
                virtualNodeName + "-->{");
        } else if (composer != null) {
            buffer.append(composer.getDefiningComponentName() + "." +
                composer.getVirtualNodeName() + "<--" + componentName + "." +
                virtualNodeName + "-->{");
        }
        Iterator it = composingVirtualNodes.iterator();
        while (it.hasNext()) {
            LinkedVirtualNode lvn = (LinkedVirtualNode) it.next();
            if (lvn == this) {
                continue;
            }
            buffer.append(lvn.toString());
        }
        return buffer.append("}").toString();
    }
}

---