C:/development/RenderTools/src/common/XMLNode.cpp

Go to the documentation of this file.

#include "XMLNode.h"
#include "Error.h"

namespace RenderTools {

bool XMLNode::s_verbose = false;

XMLNode::XMLNode( void ){
}

XMLNode::XMLNode( const string tagname ){
        m_tagName = tagname;
}

void XMLNode::load( const string file ){
        Error::assertNoErrors( __FILE__, __LINE__ ); 

        string cleanName = cleanup( file );

        char * text = 0;

        bool maybeFile = true; // could be a filename
        if( cleanName.size() && cleanName[0] =='<' ){
                maybeFile = false;
        }
        else if( findFile( cleanName, s_verbose ) == "" ){
                maybeFile = false;

                if( cleanName[0] != '<' ){
                        cleanName = "<" + cleanName + "/>";
                }
        }

        FILE * fp = 0;
        if( maybeFile && ( fp = fopen( findFile( cleanName, s_verbose ).c_str(), "rb" ) ) != 0 ){
                // find out how big it is
                fseek( fp, 0, SEEK_END );
                int len = ftell( fp );
                fseek( fp, 0, SEEK_SET );
                // clear alloc len + 1
                text = (char *)calloc( len + 1, 1 );
                if( ! text ){
                        Error::error( Error::MEMORY_ALLOCATION_FAILED, __FILE__, __LINE__ );
                }
                fread( text, 1, len, fp );
                fflush( fp );
                fclose( fp );
                text[ len ] = '\0';
        }
        else{
                text = (char *)calloc( cleanName.size() + 1, 1 );
                if( ! text ){
                        Error::error( Error::MEMORY_ALLOCATION_FAILED, __FILE__, __LINE__ );
                }
                memcpy( text, cleanName.c_str(), cleanName.size() );
                text[ cleanName.size() ] = '\0';
        }

        if( text ){
#ifdef RT_RAPIDXML
                xml_document<> doc;
                
                doc.parse<0>( text );

                m_tagName = doc.first_node()->name();
                populate( doc.first_node() );

                doc.clear();

                free( text );

#elif WIN32
#       pragma message( "\twarning: XMLNode constructor not complete due to missing RT_RAPIDXML" )
#elif APPLE
#       warning ( "\twarning: XMLNode constructor not complete due to missing RT_RAPIDXML" )
#endif
        }
        else{
                Error::error( Error::NULL_POINTER, __FILE__, __LINE__ );
        }
}

XMLNode::~XMLNode(){
}

bool XMLNode::save( const string filename ){
        FILE * fp;
        if( ( fp = fopen( filename.c_str(), "wb" ) ) != 0 ){
                fprintf( fp, "%s", toString().c_str() );
                fflush( fp );
                fclose( fp );
                return( true );
        }
        return( false );
}

const string XMLNode::toString( void ) const {
        string tag;
        tag += string( "<" ) + m_tagName + string( " " );

        map< string, string >::const_iterator i = m_attributes.begin();
        for( ; i != m_attributes.end(); i++ ){
                tag += i->first + string( "=\"" ) + i->second + string( "\" " );
        }

        if( ! m_children.size() ){
                tag += string( "/>\n" );
        }
        else{
                tag += string( ">\n" );
                for( unsigned int j = 0; j < m_children.size(); j++ ){
                        tag += m_children[ j ]->toString();
                }
                tag += string( "</" ) + m_tagName + string( ">\n" );
        }

        return( tag );
}

#ifdef RT_RAPIDXML
void XMLNode::populate( const xml_node<> * node ){
        for( xml_attribute<> * attr = node->first_attribute(); attr; attr = attr->next_attribute() ){
                m_attributes[ attr->name() ] = attr->value();
        }
        for( xml_node<> * child = node->first_node(); child; child = child->next_sibling() ){
                addChild( child->name() )->populate( child );
        }
}
#endif

void XMLNode::setTagName( const string name ){
        m_tagName = name;
}

void XMLNode::setParent( const XMLNodePtr parent ){
        m_parent = parent;
}

const XMLNodePtr XMLNode::getParent( void ) const {
        return( m_parent.lock() );
}

const XMLNodePtr XMLNode::findRoot( void ){
        XMLNodePtr root = getSharedPtr< XMLNode >();
        XMLNodePtr parent = getParent();
        while( parent ){
                root = parent;
                parent = parent->getParent();
        }
        return( root );
}

const string XMLNode::getTagName( void ) const {
        return( m_tagName );
}

bool XMLNode::hasChildren( void ) const {
        return( m_children.size() != 0 );
}

const XMLNodePtr XMLNode::getChild( const string name ) const {
        string cleanName = cleanup( name );
        for( unsigned int i = 0; i < m_children.size(); i++ ){
                if( m_children[ i ]->getTagName() == cleanName ){
                        return( m_children[ i ] );
                }
        }
        return( XMLNodePtr() );
}

const XMLNodePtr XMLNode::nextChild( const XMLNodePtr previous ) const {
        if( m_children.size() ){
                if( ! previous ){
                        return( m_children[ 0 ] );
                }
                for( unsigned int i = 0; i < m_children.size() - 1; i++ ){
                        if( m_children[ i ] == previous ){
                                return( m_children[ i + 1 ] );
                        }
                }
        }
        return( XMLNodePtr() );
}

XMLNodePtr XMLNode::nextChild( XMLNodePtr previous ){
        if( m_children.size() ){
                if( ! previous ){
                        return( m_children[ 0 ] );
                }
                for( unsigned int i = 0; i < m_children.size() - 1; i++ ){
                        if( m_children[ i ] == previous ){
                                return( m_children[ i + 1 ] );
                        }
                }
        }
        return( XMLNodePtr() );
}

bool XMLNode::hasAttrib( const string name ) const {
        return( m_attributes.find( name ) != m_attributes.end() );
}

const string XMLNode::getFullName( void ){
        string name;
        if( hasAttrib( "type" ) ){
                name += getAttrib<string>( "type" ) + "::";
        }
        return( name + m_tagName );
}

const XMLNodePtr XMLNode::addChild( const string name, const string value ){
        XMLNodePtr child( new XMLNode() );
        child->setParent( getSharedPtr< XMLNode >() );
        child->setTagName( cleanup( name ) );
        child->setAttrib<string>( "value", cleanup( value ) );
        m_children.push_back( child );
        return( child );
}

const XMLNodePtr XMLNode::addChild( const string name ){
        XMLNodePtr child( new XMLNode() );
        child->setParent( getSharedPtr< XMLNode >() );
        child->setTagName( cleanup( name ) );
        m_children.push_back( child );
        return( child );
}

const XMLNodePtr XMLNode::addChild( XMLNodePtr child ){
        child->setParent( getSharedPtr< XMLNode >() );
        m_children.push_back( child );
        return( child );
}

bool XMLNode::isChild( const XMLNodePtr lookForChild ) const {
        for( unsigned int i = 0; i < m_children.size(); i++ ){
                if( m_children[ i ] == lookForChild || m_children[ i ]->isChild( lookForChild ) ){
                        return( true );
                }
        }
        return( false );
}

bool XMLNode::isParent( const XMLNodePtr lookForParent ) const {
        XMLNodePtr thisPtr = getSharedPtr< XMLNode >();
        XMLNodePtr parent = getParent();
        while( parent ){
                if( parent == lookForParent ){
                        return( true );
                }
                parent = parent->getParent();
        }
        return( false );
}

const XMLNodePtr XMLNode::findByFullName( const string className, const string propertyName, const XMLNodePtr inXml ){
        return( findByFullName( className + "::" + propertyName ) );
}

const XMLNodePtr XMLNode::findByFullName( const string fullname, const XMLNodePtr inXml ){
        XMLNodePtr xml = inXml;
        if( ! xml ){
                xml = findRoot();
        }

        if( xml->getFullName() == fullname && xml->hasChildren() ){
                return( xml );
        }

        XMLNodePtr child = XMLNodePtr();
        while( ( child = xml->nextChild( child ) ) ){
                if( findByFullName( fullname, child ) ){
                        return( child );
                }
        }
        return( XMLNodePtr() );
}

void XMLNode::setVerbose( bool state ){
        s_verbose = state;
}

bool XMLNode::isVerbose( void ){
        return( s_verbose );
}

}; // namespace

---