• Main
• Home
• Features
• Screenshots
• Downloads
• License
• Team profile
• Documentation
• Manual
• FAQ
• Reference

Search this page:

PCMOutputNode.cpp

Go to the documentation of this file.

//
// This source file is a part of ParCompMark
// Parallel Compositing Benchmark Framework
//
// for latest info see http://parcompmark.sourceforge.net

//
// Copyright (C) 2006 IT2 ParCompMark Dev. Team
// 
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
// 
// This program 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 General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

//
// Inner includes
//

#include "../include/PCMOutputNode.h"

//
// Outer includes
//

#include "tinyxml/tinyxml.h"

namespace ParCompMark
{

  //
  // Class constants
  //

  const std::string OutputNode::TEXTNODENAME = "#text";

  //
  // Constructors & destructor
  //

   OutputNode::OutputNode(const std::string & name, const NodeType & type):
        // Parent constructor call 
   Name(name                    /* Name of the node */
  ),
        // Type of the node 
   mType(type           /* Type of the node */
        )
        // You have to initialize the following attributes:
        // - mType
        // - mAttributes
        // - mChildren
        // - mText
  {
        Assert(_testXMLName(name), INVALID_OPERATION_ERROR, "OutputNode::OutputNode");

        // STL autoinitialization
  }

 /*----------------------------------------------------------------------*/

  OutputNode::OutputNode(const std::string & text):
        // Parent constructor call 
   Name(TEXTNODENAME            /* Name of the node */
  ),
        // Type of the node 
   mType(OutputNode::TEXT       /* Text field type */
  ),
        // Text data 
   mText(text           /* Text data */
        )
        // You have to initialize the following attributes:
        // - mType
        // - mAttributes
        // - mChildren
        // - mText
  {
        // STL autoinitialization
  }

 /*----------------------------------------------------------------------*/

  OutputNode::~OutputNode()
  {
        // STL autofinalization
  }

 /*----------------------------------------------------------------------*/

  //
  // Class methods
  //

  OutputNode::Pointer OutputNode::parseFromXML(std::string & xmlDocument)
  {

        OutputNode::Pointer root;

        return root;
  }

 /*----------------------------------------------------------------------*/

  bool OutputNode::_testXMLName(const std::string & name)
  {
        // TODO: implement

        return true;
  }

 /*----------------------------------------------------------------------*/

  std::string OutputNode::_convertSpecialChars(const std::string & string)
  {
        // TODO: implement

        return string;
  }

 /*----------------------------------------------------------------------*/

  //
  // Methods
  //

  OutputNode::Pointer OutputNode::createChildNode(const std::string & name, const NodeType & type)
  {
        Assert(mType != OutputNode::TEXT
           && mType != OutputNode::CDATA, INVALID_OPERATION_ERROR, "OutputNode::createChildNode");

        // Create child and put into list and map
        OutputNode::Pointer child(new OutputNode(name, type));
        mChildren.push_back(child);

        return child;
  }

 /*----------------------------------------------------------------------*/

  OutputNode::Pointer OutputNode::createChildNode(const std::string & text)
  {
        Assert(mType != OutputNode::TEXT
           && mType != OutputNode::CDATA, INVALID_OPERATION_ERROR, "OutputNode::createChildNode");

        // Create child and put into list and map
        OutputNode::Pointer child(new OutputNode(text));
        mChildren.push_back(child);

        return child;
  }

 /*----------------------------------------------------------------------*/

  void OutputNode::addChildNode(OutputNode::Pointer child)
  {
        Assert(mType != OutputNode::TEXT
           && mType != OutputNode::CDATA, INVALID_OPERATION_ERROR, "OutputNode::addChildNode");
        Assert(child.getPtr() != this, INVALID_OPERATION_ERROR, "OutputNode::addChildNode");

        // Put child into list and map
        mChildren.push_back(child);
  }

 /*----------------------------------------------------------------------*/

  u32 OutputNode::getChildCount()
  {
        return mChildren.size();
  }

 /*----------------------------------------------------------------------*/

  OutputNode::Pointer OutputNode::getFirstChildNode()
  {
        Assert(mType != OutputNode::TEXT && mType != OutputNode::CDATA
           && mChildren.size(), INVALID_OPERATION_ERROR, "OutputNode::getFirstChild");
        return mChildren.front();
  }

 /*----------------------------------------------------------------------*/

  bool OutputNode::hasAttribute(const std::string & attribute) const
  {
        Assert(mType != OutputNode::TEXT
           && mType != OutputNode::CDATA, INVALID_OPERATION_ERROR, "OutputNode::hasAttribute");
        return mAttributes.find(attribute) != mAttributes.end();
  }

 /*----------------------------------------------------------------------*/

  const std::string & OutputNode::getAttribute(const std::string & attribute) const
  {
        Assert(mType != OutputNode::TEXT
           && mType != OutputNode::CDATA, INVALID_OPERATION_ERROR, "OutputNode::getAttribute");
        AttributeMapIterator i = mAttributes.find(attribute);

        // Exception if the child does not exist
        Assert(i != mAttributes.end(), INVALID_NAME_ERROR, "OutputNode::getAttribute");

        return i->second;
  }

 /*----------------------------------------------------------------------*/

  void OutputNode::setAttribute(const std::string & attribute, const std::string & value)
  {
        Assert(_testXMLName(attribute), INVALID_OPERATION_ERROR, "OutputNode::setAttribute");
        Assert(mType != OutputNode::TEXT
           && mType != OutputNode::CDATA, INVALID_OPERATION_ERROR, "OutputNode::createAttribute");

        mAttributes[attribute] = value;
  }

 /*----------------------------------------------------------------------*/

  std::ostringstream & OutputNode::serialize2XML(std::ostringstream & osstr)
  {

        // Textual node
        if(mType == OutputNode::TEXT)
        {
         osstr << mText;
        } else if(mType == OutputNode::CDATA)
        {
         osstr << "<![CDATA[" << mText << "]]>";
        }
        // Nontextual node
        else
        {

         // XML namespace
         std::string xmlNameSpace;

         switch (mType)
         {
                case OutputNode::DEFINITION:
                 xmlNameSpace = "def:";
                 break;
                case OutputNode::INFORMATION:
                 xmlNameSpace = "info:";
                 break;
                case OutputNode::REFERENCE:
                 xmlNameSpace = "ref:";
                 break;
                case OutputNode::STATISTICS:
                 xmlNameSpace = "stat:";
                 break;
                default:
                 xmlNameSpace = "";
         }

         osstr << '<' << xmlNameSpace;

         // Node name
         osstr << mName;

         // Attributes
         for(AttributeMapIterator i = mAttributes.begin(); i != mAttributes.end(); i++)
                osstr << ' ' << i->first << "=\"" << _convertSpecialChars(i->second) << '\"';

         // Children
         if(mChildren.size())
         {
                osstr << ">";
                for(ChildNodeListIterator i = mChildren.begin(); i != mChildren.end(); i++)
                 (*i).getPtr()->serialize2XML(osstr);
                osstr << "</" << xmlNameSpace << mName << ">";
         } else
         {
                osstr << "/>";
         }
        }

        // Test error 
        Assert(!osstr.bad(), INVALID_OPERATION_ERROR, "OutputNode::serialize2XML");

        return osstr;
  }

 /*----------------------------------------------------------------------*/

  std::string OutputNode::serialize2XML()
  {
        std::ostringstream osstr;
        return serialize2XML(osstr).str();
  }

 /*----------------------------------------------------------------------*/

  void OutputNode::refreshData()
  {
        // Nothing to do
  }

 /*----------------------------------------------------------------------*/

  void OutputNode::clean()
  {
        for(ChildNodeListIterator i = mChildren.begin(); i != mChildren.end(); i++)
        {

         i->getPtr()->clean();

         i->kill();

        }

        mChildren.clear();

  }

 /*----------------------------------------------------------------------*/

}

© Copyright - 2006 (IT)² ParCompMark Dev. Team