tag_scalar_vector.hpp

Go to the documentation of this file.

 
#ifndef CFGFILE__TAG_SCALAR_VECTOR_HPP__INCLUDED
#define CFGFILE__TAG_SCALAR_VECTOR_HPP__INCLUDED
 
//cfgfile include.
#include "tag.hpp"
#include "constraint.hpp"
#include "format.hpp"
#include "string_format.hpp"
#include "types.hpp"
#include "exceptions.hpp"
#include "parser_info.hpp"
 
#if defined( CFGFILE_QT_SUPPORT ) && defined( CFGFILE_XML_SUPPORT )
// Qt include.
#include <QDomDocument>
#include <QDomElement>
#include <QDomText>
#endif
 
// C++ include.
#include <vector>
 
 
namespace cfgfile {
 
//
// tag_scalar_vector_t
//
 
template< class T, class Trait = string_trait_t >
class tag_scalar_vector_t
    :   public tag_t< Trait >
{
public:
    typedef std::vector< T > values_vector_t;
 
    explicit tag_scalar_vector_t( const typename Trait::string_t & name,
        bool is_mandatory = false )
        :   tag_t< Trait >( name, is_mandatory )
        ,   m_constraint( nullptr )
    {
    }
 
    tag_scalar_vector_t( tag_t< Trait > & owner,
        const typename Trait::string_t & name,
        bool is_mandatory = false )
        :   tag_t< Trait >( owner, name, is_mandatory )
        ,   m_constraint( nullptr )
    {
    }
 
    ~tag_scalar_vector_t()
    {
    }
 
    typename values_vector_t::size_type
    size() const
    {
        return m_values.size();
    }
 
    const T &
    at( typename values_vector_t::size_type index ) const
    {
        return m_values.at( index );
    }
 
    const values_vector_t &
    values() const
    {
        return m_values;
    }
 
    void
    set_value( const T & v )
    {
        if( m_constraint )
        {
            if( !m_constraint->check( v ) )
                throw exception_t< Trait >(
                    Trait::from_ascii( "Invalid value: \"" ) +
                    typename Trait::string_t(
                        format_t< T, Trait >::to_string( v ) ) +
                    Trait::from_ascii( "\". Value must match to the "
                        "constraint in tag \"" ) +
                    this->name() + Trait::from_ascii( "\"." ) );
        }
 
        m_values.push_back( v );
 
        this->set_defined();
    }
 
    void
    set_values( const values_vector_t & v )
    {
        m_values = v;
 
        this->set_defined();
    }
 
    void
    query_opt_values( values_vector_t & receiver )
    {
        if( this->is_defined() )
            receiver = m_values;
    }
 
    void
    set_constraint( constraint_t< T > * c )
    {
        m_constraint = c;
    }
 
    typename Trait::string_t print( int indent = 0 ) const override
    {
        typename Trait::string_t result;
 
        if( this->is_defined() )
        {
            result.append( typename Trait::string_t( indent,
                const_t< Trait >::c_tab ) );
            result.push_back( const_t< Trait >::c_begin_tag );
            result.append( this->name() );
 
            for( const T & v : m_values )
            {
                result.push_back( const_t< Trait >::c_space );
 
                typename Trait::string_t value =
                    format_t< T, Trait >::to_string( v );
 
                value = to_cfgfile_format< Trait >( value );
 
                result.append( value );
            }
 
            if( !this->children().empty() )
            {
                result.push_back( const_t< Trait >::c_carriage_return );
 
                for( const tag_t< Trait > * tag : this->children() )
                    result.append( tag->print( indent + 1 ) );
 
                result.append( typename Trait::string_t( indent,
                    const_t< Trait >::c_tab ) );
            }
 
            result.push_back( const_t< Trait >::c_end_tag );
            result.push_back( const_t< Trait >::c_carriage_return );
        }
 
        return result;
    }
 
#if defined( CFGFILE_QT_SUPPORT ) && defined( CFGFILE_XML_SUPPORT )
    void print( QDomDocument & doc, QDomElement * parent = 0 ) const override
    {
        if( this->is_defined() )
        {
            QDomElement this_element = doc.createElement( this->name() );
 
            if( !parent )
                doc.appendChild( this_element );
            else
                parent->appendChild( this_element );
 
            typename values_vector_t::size_type i = 1;
 
            for( const T & v : m_values )
            {
                typename Trait::string_t value =
                    format_t< T, Trait >::to_string( v );
 
                value = to_cfgfile_format< Trait >( value );
 
                QString tmp = value;
 
                if( tmp.startsWith( const_t< Trait >::c_quotes ) &&
                    tmp.endsWith( const_t< Trait >::c_quotes ) )
                        tmp = tmp.mid( 1, tmp.length() - 2 );
 
                this_element.setAttribute( QString( "a" ) + QString::number( i ),
                    tmp );
 
                ++i;
            }
 
            if( !this->children().empty() )
            {
                for( const tag_t< Trait > * tag : this->children() )
                    tag->print( doc, &this_element );
            }
        }
    }
#endif
 
    void on_finish( const parser_info_t< Trait > & info ) override
    {
        for( const tag_t< Trait > * tag : this->children() )
        {
            if( tag->is_mandatory() && !tag->is_defined() )
                throw exception_t< Trait >(
                    Trait::from_ascii( "Undefined child mandatory tag: \"" ) +
                    tag->name() +
                    Trait::from_ascii( "\". Where parent is: \"" ) +
                    this->name() + Trait::from_ascii( "\". In file \"" ) +
                    info.file_name() + Trait::from_ascii( "\" on line " ) +
                    Trait::to_string( info.line_number() ) +
                    Trait::from_ascii( "." ) );
        }
    }
 
    void on_string( const parser_info_t< Trait > & info,
        const typename Trait::string_t & str ) override
    {
        if( this->is_any_child_defined() )
            throw exception_t< Trait >(
                Trait::from_ascii( "Value \"" ) + str +
                Trait::from_ascii( "\" for tag \"" ) + this->name() +
                Trait::from_ascii( "\" must be defined before any child "
                    "tag. In file \"" ) +
                info.file_name() + Trait::from_ascii( "\" on line " ) +
                Trait::to_string( info.line_number() ) +
                Trait::from_ascii( "." ) );
 
        const T value = format_t< T, Trait >::from_string( info, str );
 
        if( m_constraint )
        {
            if( !m_constraint->check( value ) )
                throw exception_t< Trait >(
                    Trait::from_ascii( "Invalid value: \"" ) +
                    str + Trait::from_ascii( "\". Value must match to the "
                        "constraint in tag \"" ) +
                    this->name() + Trait::from_ascii( "\". In file \"" ) +
                    info.file_name() + Trait::from_ascii( "\" on line " ) +
                    Trait::to_string( info.line_number() ) +
                    Trait::from_ascii( "." ) );
        }
 
        m_values.push_back( value );
 
        this->set_defined();
    }
 
private:
    values_vector_t m_values;
    constraint_t< T > * m_constraint;
}; // class tag_scalar_vector_t
 
} /* namespace cfgfile */
 
#endif // CFGFILE__TAG_SCALAR_VECTOR_HPP__INCLUDED