tag.hpp

Go to the documentation of this file.

 
#ifndef CFGFILE__TAG_HPP__INCLUDED
#define CFGFILE__TAG_HPP__INCLUDED
 
#if defined( CFGFILE_QT_SUPPORT ) && defined( CFGFILE_XML_SUPPORT )
// Qt include.
#include <QDomDocument>
#include <QDomElement>
#endif
 
// cfgfile include.
#include "parser_info.hpp"
#include "types.hpp"
#include "exceptions.hpp"
 
// C++ include.
#include <vector>
#include <algorithm>
 
 
namespace cfgfile {
 
//
// tag_t
//
 
template< typename Trait = string_trait_t >
class tag_t {
public:
    template< typename T1 > friend class parser_t;
 
    typedef std::vector< tag_t< Trait >* > child_tags_list_t;
 
    explicit tag_t( const typename Trait::string_t & name,
        bool is_mandatory = false )
        :   m_name( name )
        ,   m_is_mandatory( is_mandatory )
        ,   m_is_defined( false )
        ,   m_parent( nullptr )
        ,   m_line_number( -1 )
        ,   m_column_number( -1 )
    {
    }
 
    tag_t( tag_t< Trait > & owner, const typename Trait::string_t & name,
        bool is_mandatory = false )
        :   m_name( name )
        ,   m_is_mandatory( is_mandatory )
        ,   m_is_defined( false )
        ,   m_parent( nullptr )
        ,   m_line_number( -1 )
        ,   m_column_number( -1 )
    {
        owner.add_child( *this );
    }
 
    virtual ~tag_t()
    {
    }
 
    void add_child( tag_t< Trait > & tag )
    {
        if( std::find_if( m_child_tags.cbegin(), m_child_tags.cend(),
            [ &tag ] ( const tag_t< Trait > * t )
            {
                return ( tag.name() == t->name() );
            } ) != m_child_tags.cend() )
        {
            throw exception_t< Trait > (
                Trait::from_ascii( "Tag with name \"" ) +
                tag.name() +
                Trait::from_ascii( "\" already exists in parent tag \"" ) +
                this->name() +
                Trait::from_ascii( "\"." ) );
        }
 
        if( std::find( m_child_tags.cbegin(), m_child_tags.cend(), &tag ) ==
            m_child_tags.cend() )
        {
            m_child_tags.push_back( &tag );
 
            tag.set_parent( this );
        }
    }
 
    void remove_child( tag_t< Trait > & tag )
    {
        auto it = std::find( m_child_tags.cbegin(), m_child_tags.cend(), &tag );
 
        if( it != m_child_tags.cend() )
        {
            m_child_tags.erase( it );
 
            tag.set_parent( nullptr );
        }
    }
 
    const tag_t< Trait > * parent() const
    {
        return m_parent;
    }
 
    const typename Trait::string_t & name() const
    {
        return m_name;
    }
 
    bool is_mandatory() const
    {
        return m_is_mandatory;
    }
 
    bool is_defined() const
    {
        for( const tag_t< Trait > * tag : children() )
        {
            if( tag->is_mandatory() && !tag->is_defined() )
                return false;
        }
 
        return m_is_defined;
    }
 
    void set_defined( bool on = true )
    {
        m_is_defined = on;
    }
 
    typename Trait::pos_t line_number() const
    {
        return m_line_number;
    }
 
    typename Trait::pos_t column_number() const
    {
        return m_column_number;
    }
 
    virtual const child_tags_list_t & children() const
    {
        return m_child_tags;
    }
 
    virtual typename Trait::string_t print( int indent = 0 ) const = 0;
 
#if defined( CFGFILE_QT_SUPPORT ) && defined( CFGFILE_XML_SUPPORT )
    virtual void print( QDomDocument & doc,
        QDomElement * parent = 0 ) const = 0;
#endif
 
    virtual void on_start( const parser_info_t< Trait > & info )
    {
        m_line_number = info.line_number();
        m_column_number = info.column_number();
    }
 
    virtual void on_finish( const parser_info_t< Trait > & info ) = 0;
 
    virtual void on_string( const parser_info_t< Trait > & info,
        const typename Trait::string_t & str ) = 0;
 
protected:
    template< class T1, class T2 > friend class tag_vector_of_tags_t;
 
    void set_parent( const tag_t< Trait > * p )
    {
        m_parent = p;
    }
 
    bool is_any_child_defined() const
    {
        return std::any_of( m_child_tags.cbegin(), m_child_tags.cend(),
            [] ( tag_t< Trait > * tag ) { return ( tag->is_defined() ); } );
    }
 
    bool is_defined_member_value() const
    {
        return m_is_defined;
    }
 
private:
    DISABLE_COPY( tag_t )
 
    
    typename Trait::string_t m_name;
    bool m_is_mandatory;
    bool m_is_defined;
    child_tags_list_t m_child_tags;
    const tag_t< Trait > * m_parent;
    typename Trait::pos_t m_line_number;
    typename Trait::pos_t m_column_number;
}; // class tag_t
 
} /* namespace cfgfile */
 
#endif // CFGFILE__TAG_HPP__INCLUDED