root/ossie/trunk/ossie/parser/ComponentInstantiation.cpp @ 604

/*******************************************************************************

Copyright 2004, Virginia Polytechnic Institute and State University

This file is part of the OSSIE Parser.

OSSIE Parser is free software; you can redistribute it and/or modify
it under the terms of the Lesser GNU General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

OSSIE Parser 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
Lesser GNU General Public License for more details.

You should have received a copy of the Lesser GNU General Public License
along with OSSIE Parser; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

Even though all code is original, the architecture of the OSSIE Parser is based
on the architecture of the CRC's SCA Reference Implementation (SCARI)
see: http://www.crc.ca/en/html/rmsc/home/sdr/projects/scari

*********************************************************************************/

#include "ossie/ComponentInstantiation.h"
#define DELPTR(x) if (x!=NULL) delete x, x=NULL;
#define DELARRAY(x) if (x!=NULL) delete []x, x=NULL;

ComponentInstantiation::ComponentInstantiation ():
instantiationId(NULL), instantiationName(NULL)
{}

ComponentInstantiation::ComponentInstantiation (DOMElement* _element):
root(_element), instantiationId(NULL), instantiationName(NULL)
{
    this->parseElement();
}

ComponentInstantiation::ComponentInstantiation
(const ComponentInstantiation & _compInst):
root(_compInst.root), instantiationId(NULL), instantiationName(NULL)
{
    this->instantiationId = new char[strlen (_compInst.instantiationId) + 1];
    strcpy (instantiationId, _compInst.instantiationId);

    this->instantiationName = new char[strlen (_compInst.instantiationName) + 1];
    strcpy (instantiationName, _compInst.instantiationName);

    for (unsigned int i = 0; i < _compInst.properties.size (); i++)
    this->properties.push_back (_compInst.properties[i]);
}

ComponentInstantiation::~ComponentInstantiation()
{
    DELARRAY(instantiationId);
    DELARRAY(instantiationName);

    for (unsigned int i=0; i< properties.size(); i++)   // deep clean
    {
        DELPTR(properties[i]);
    }
}


void ComponentInstantiation::parseElement()
{
    parseID(root);
    parseName(root);
    parseProperties(root);
}

void ComponentInstantiation::parseID(DOMElement * _elem)
{
    tmpXMLStr = XMLString::transcode("id");
    const XMLCh *_id = _elem->getAttribute(tmpXMLStr);
    XMLString::release(&tmpXMLStr);
    this->instantiationId = XMLString::transcode(_id);
}


void ComponentInstantiation::parseName(DOMElement * _elem)
{
    tmpXMLStr = XMLString::transcode("usagename");
    DOMNodeList* nodeList = _elem->getElementsByTagName(tmpXMLStr);
    XMLString::release(&tmpXMLStr);

    if (nodeList->getLength() != 0)
    {
        DOMElement* elem = (DOMElement*) nodeList->item(0);
        this->instantiationName = getTextNode(elem);
    }
}


void ComponentInstantiation::parseProperties(DOMElement * _elem)
{
    tmpXMLStr = XMLString::transcode("componentproperties");
    DOMNodeList* nodeList =  _elem->getElementsByTagName(tmpXMLStr);
    XMLString::release(&tmpXMLStr);

    if (nodeList->getLength() != 0)
    {
        DOMElement *elem = (DOMElement *) nodeList->item (0);
        tmpXMLStr = XMLString::transcode("simpleref");
        nodeList = elem->getElementsByTagName(tmpXMLStr);
        XMLString::release(&tmpXMLStr);

        InstantiationProperty *_tmp;
        for (unsigned int i = 0; i < nodeList->getLength (); i++)
        {
                _tmp = parseSimpleRef ((DOMElement *) nodeList->item (i));
                properties.push_back(_tmp);
        }
    }
}


InstantiationProperty* ComponentInstantiation::parseSimpleRef(DOMElement * _elem)
{
    tmpXMLStr = XMLString::transcode("refid");
    const XMLCh *_propId = _elem->getAttribute(tmpXMLStr);
    XMLString::release(&tmpXMLStr);
    tmpXMLStr = XMLString::transcode("value");
    const XMLCh *_propVal =     _elem->getAttribute(tmpXMLStr);
    XMLString::release(&tmpXMLStr);

    char* tmpStr1 = XMLString::transcode(_propId);
    char* tmpStr2 = XMLString::transcode(_propVal);
    InstantiationProperty* property = new InstantiationProperty(tmpStr1,tmpStr2);

    delete []tmpStr1;
    delete []tmpStr2;

    return property;
}


char* ComponentInstantiation::getTextNode(DOMElement * _elem)
{
    DOMNodeList *nodeList = _elem->getChildNodes ();

    if (nodeList->getLength () == 0)
    {
        char* astr = new char[strlen("Not Specified") +1];
        strcpy(astr,"Not Specified");
        return astr;
    }
    else return XMLString::transcode (nodeList->item (0)->getNodeValue ());
}


char* ComponentInstantiation::toString()
{
    std::vector <InstantiationProperty*>* propertyArray;

    char *str = new char[MAX_BUFFER];   // the caller must release this

    strcpy (str, "\n    ID=");
    str = strcat (str, getID ());
    str = strcat (str, "\n      Name=");
    str = strcat (str, getName ());

    propertyArray = getProperties ();

    if (propertyArray->size () > 0)
    {
        str = strcat (str, "\n     Propert");

        if (propertyArray->size () == 1) str = strcat (str, "y");
        else str = strcat (str, "ies");

        for (unsigned int i = 0; i < propertyArray->size (); i++)
        {
                str = strcat (str, "\n       [");
                str = strcat (str, (char *) i);
                str = strcat (str, "]");
                str = strcat (str, (*propertyArray)[i]->getID ());
        }
    }
    else str = strcat (str, "\n     There are no properties");

    return str;
}


char* ComponentInstantiation::getID() const
{
    return this->instantiationId;
}


char* ComponentInstantiation::getName() const
{
    return this->instantiationName;
}


std::vector <InstantiationProperty*>* ComponentInstantiation::getProperties()
{
    return &properties;
}
XMLCh* ComponentInstantiation::tmpXMLStr = NULL;