tag_vector_of_tags.hpp

Go to the documentation of this file.

 
#ifndef CFGFILE__TAG_VECTOR_OF_TAGS_HPP__INCLUDED
#define CFGFILE__TAG_VECTOR_OF_TAGS_HPP__INCLUDED
 
// cfgfile include.
#include "tag.hpp"
#include "exceptions.hpp"
#include "types.hpp"
 
// C++ include.
#include <vector>
#include <memory>
 
 
namespace cfgfile {
 
//
// tag_vector_of_tags_t
//
 
template< typename T, typename Trait = string_trait_t >
class tag_vector_of_tags_t
    :   public tag_t< Trait >
{
public:
    typedef std::shared_ptr< T > ptr_to_tag_t;
    typedef std::vector< ptr_to_tag_t > vector_of_tags_t;
 
    explicit tag_vector_of_tags_t( const typename Trait::string_t & name,
        bool is_mandatory = false )
        :   tag_t< Trait >( name, is_mandatory )
    {
    }
 
    tag_vector_of_tags_t( tag_t< Trait > & owner,
        const typename Trait::string_t & name,
        bool is_mandatory = false )
        :   tag_t< Trait >( owner, name, is_mandatory )
    {
    }
 
    ~tag_vector_of_tags_t()
    {
    }
 
    typename vector_of_tags_t::size_type
    size() const
    {
        return m_tags.size();
    }
 
    const T &
    at( typename vector_of_tags_t::size_type index ) const
    {
        return *m_tags.at( index );
    }
 
    const vector_of_tags_t &
    values() const
    {
        return m_tags;
    }
 
    void
    set_value( ptr_to_tag_t p )
    {
        m_tags.push_back( p );
 
        this->set_defined();
    }
 
    void
    set_values( const vector_of_tags_t & v )
    {
        m_tags = v;
 
        this->set_defined();
    }
 
    void
    query_opt_values( vector_of_tags_t & receiver )
    {
        if( this->is_defined() )
            receiver = m_tags;
    }
 
    const typename tag_t< Trait >::child_tags_list_t & children() const override
    {
        static const typename tag_t< Trait >::child_tags_list_t empty;
 
        if( m_current )
            return m_current->children();
        else
            return empty;
    }
 
    typename Trait::string_t print( int indent = 0 ) const override
    {
        typename Trait::string_t result;
 
        if( this->is_defined() )
        {
            for( const ptr_to_tag_t & p : m_tags )
                result.append( p->print( indent ) );
        }
 
        return result;
    }
 
#if defined( CFGFILE_QT_SUPPORT ) && defined( CFGFILE_XML_SUPPORT )
    void print( QDomDocument & doc, QDomElement * parent = 0 ) const override
    {
        if( this->is_defined() )
        {
            for( const ptr_to_tag_t & p : m_tags )
                p->print( doc, parent );
        }
    }
#endif
 
    void on_start( const parser_info_t< Trait > & info ) override
    {
        m_current = std::make_shared< T > ( this->name(), this->is_mandatory() );
        m_current->set_parent( this->parent() );
        m_current->on_start( info );
    }
 
    void on_finish( const parser_info_t< Trait > & info ) override
    {
        m_current->on_finish( info );
        m_tags.push_back( m_current );
        m_current.reset();
 
        this->set_defined();
    }
 
    void on_string( const parser_info_t< Trait > & info,
        const typename Trait::string_t & str ) override
    {
        m_current->on_string( info, str );
    }
 
private:
    vector_of_tags_t m_tags;
    ptr_to_tag_t m_current;
}; // class tag_vector_of_tags_t
 
} /* namespace cfgfile */
 
#endif // CFGFILE__TAG_VECTOR_OF_TAGS_HPP__INCLUDED