tag_scalar.hpp

Go to the documentation of this file.

 
#ifndef CFGFILE__TAG_SCALAR_HPP__INCLUDED
#define CFGFILE__TAG_SCALAR_HPP__INCLUDED
 
//cfgfile include.
#include "tag.hpp"
#include "constraint.hpp"
#include "format.hpp"
#include "string_format.hpp"
#include "exceptions.hpp"
#include "const.hpp"
 
#if defined( CFGFILE_QT_SUPPORT ) && defined( CFGFILE_XML_SUPPORT )
// Qt include.
#include <QDomDocument>
#include <QDomElement>
#include <QDomText>
#endif
 
 
namespace cfgfile {
 
//
// tag_scalar_t
//
 
template< class T, class Trait = string_trait_t >
class tag_scalar_t
    :   public tag_t< Trait >
{
public:
    explicit tag_scalar_t( const typename Trait::string_t & name,
        bool is_mandatory = false )
        :   tag_t< Trait >( name, is_mandatory )
        ,   m_value( T() )
        ,   m_constraint( nullptr )
    {
    }
 
    tag_scalar_t( tag_t< Trait > & owner, const typename Trait::string_t & name,
        bool is_mandatory = false )
        :   tag_t< Trait >( owner, name, is_mandatory )
        ,   m_value( T() )
        ,   m_constraint( nullptr )
    {
    }
 
    ~tag_scalar_t()
    {
    }
 
    const T &
    value() const
    {
        return m_value;
    }
 
    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_value = v;
 
        this->set_defined();
    }
 
    void
    query_opt_value( T & receiver )
    {
        if( this->is_defined() )
            receiver = m_value;
    }
 
    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() );
            result.push_back( const_t< Trait >::c_space );
 
            typename Trait::string_t value =
                format_t< T, Trait >::to_string( m_value );
            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 );
 
            QString value = format_t< T, Trait >::to_string( m_value );
            value = to_cfgfile_format< Trait >( value );
 
            QDomText data = doc.createTextNode( value );
 
            this_element.appendChild( data );
 
            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
    {
        if( !this->is_defined_member_value() )
            throw exception_t< Trait >(
                Trait::from_ascii( "Undefined value of 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( "." ) );
 
        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_defined_member_value() )
        {
            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( "." ) );
 
            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_value = value;
 
            this->set_defined();
        }
        else
            throw exception_t< Trait >(
                Trait::from_ascii( "Value for the tag \"" ) +
                this->name() +
                Trait::from_ascii( "\" already defined. In file \"" ) +
                info.file_name() + Trait::from_ascii( "\" on line " ) +
                Trait::to_string( info.line_number() ) +
                Trait::from_ascii( "." ) );
    }
 
private:
    T m_value;
    constraint_t< T > * m_constraint;
}; // class tag_scalar_t
 
 
//
// tag_scalar_t< bool >
//
 
template< typename Trait >
class tag_scalar_t< bool, Trait >
    :   public tag_t< Trait >
{
public:
    explicit tag_scalar_t( const typename Trait::string_t & name,
        bool is_mandatory = false )
        :   tag_t< Trait >( name, is_mandatory )
        ,   m_value( false )
    {
    }
 
    tag_scalar_t( tag_t< Trait > & owner, const typename Trait::string_t & name,
        bool is_mandatory = false )
        :   tag_t< Trait >( owner, name, is_mandatory )
        ,   m_value( false )
    {
    }
 
    ~tag_scalar_t()
    {
    }
 
    const bool &
    value() const
    {
        return m_value;
    }
 
    void
    set_value( const bool & v )
    {
        m_value = v;
 
        this->set_defined();
    }
 
    void
    query_opt_value( bool & receiver )
    {
        if( this->is_defined() )
            receiver = m_value;
    }
 
    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() );
            result.push_back( const_t< Trait >::c_space );
 
            typename Trait::string_t value =
                format_t< bool, Trait >::to_string( m_value );
            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 Trait::string_t value =
                format_t< bool, Trait >::to_string( m_value );
            value = to_cfgfile_format< Trait >( value );
 
            QDomText data = doc.createTextNode( value );
 
            this_element.appendChild( data );
 
            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
    {
        if( !this->is_defined_member_value() )
            throw exception_t< Trait >(
                Trait::from_ascii( "Undefined value of 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( "." ) );
 
        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_defined_member_value() )
        {
            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( "." ) );
 
            m_value = format_t< bool, Trait >::from_string( info, str );
 
            this->set_defined();
        }
        else
            throw exception_t< Trait >(
                Trait::from_ascii( "Value for the tag \"" ) +
                this->name() +
                Trait::from_ascii( "\" already defined. In file \"" ) +
                info.file_name() + Trait::from_ascii( "\" on line " ) +
                Trait::to_string( info.line_number() ) +
                Trait::from_ascii( "." ) );
    }
 
private:
    bool m_value;
}; // class tag_scalar_t
 
 
//
// tag_scalar_t< Trait::string_t >
//
 
template< typename Trait >
class tag_scalar_t< typename Trait::string_t, Trait >
    :   public tag_t< Trait >
{
    static const typename Trait::pos_t c_max_string_length = 80;
 
public:
    explicit tag_scalar_t( const typename Trait::string_t & name,
        bool is_mandatory = false )
        :   tag_t< Trait >( name, is_mandatory )
        ,   m_value( typename Trait::string_t() )
        ,   m_constraint( nullptr )
    {
    }
 
    tag_scalar_t( tag_t< Trait > & owner, const typename Trait::string_t & name,
        bool is_mandatory = false )
        :   tag_t< Trait >( owner, name, is_mandatory )
        ,   m_value( typename Trait::string_t() )
        ,   m_constraint( nullptr )
    {
    }
 
    ~tag_scalar_t()
    {
    }
 
    const typename Trait::string_t &
    value() const
    {
        return m_value;
    }
 
    void
    set_value( const typename Trait::string_t & v )
    {
        if( m_constraint )
        {
            if( !m_constraint->check( v ) )
                throw exception_t< Trait >(
                    Trait::from_ascii( "Invalid value: \"" ) +
                    format_t< typename Trait::string_t, Trait >::to_string( v ) +
                    Trait::from_ascii( "\". Value must match to the "
                        "constraint in tag \"" ) +
                    this->name() + Trait::from_ascii( "\"." ) );
        }
 
        m_value = v;
 
        this->set_defined();
    }
 
    void
    query_opt_value( typename Trait::string_t & receiver )
    {
        if( this->is_defined() )
            receiver = m_value;
    }
 
    void
    set_constraint( constraint_t< typename Trait::string_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() );
            result.push_back( const_t< Trait >::c_space );
 
            typename Trait::string_t value =
                format_t< typename Trait::string_t, Trait >::to_string( m_value );
 
            const typename Trait::pos_t sections =
                ( value.length() / c_max_string_length +
                ( value.length() % c_max_string_length > 0 ? 1 : 0 ) );
 
            if( sections )
            {
                const typename Trait::string_t spaces =
                    typename Trait::string_t( this->name().length() + 2,
                        const_t< Trait >::c_space );
 
                for( typename Trait::pos_t i = 0; i < sections; ++i )
                {
                    if( i > 0 )
                    {
                        result.push_back( const_t< Trait >::c_carriage_return );
 
                        result.append( typename Trait::string_t( indent,
                            const_t< Trait >::c_tab ) );
 
                        result.append( spaces );
                    }
 
                    const typename Trait::string_t tmp =
                        to_cfgfile_format< Trait > (
                            value.substr( i * c_max_string_length,
                                c_max_string_length ) );
 
                    result.append( tmp );
                }
            }
            else
            {
                result.push_back( const_t< Trait >::c_quotes );
                result.push_back( const_t< Trait >::c_quotes );
            }
 
            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 Trait::string_t value =
                format_t< typename Trait::string_t, Trait >::to_string( m_value );
            value = to_cfgfile_format< Trait >( value );
 
            QDomText data = doc.createTextNode( value );
 
            this_element.appendChild( data );
 
            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
    {
        if( !this->is_defined_member_value() )
            throw exception_t< Trait >(
                Trait::from_ascii( "Undefined value of 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( "." ) );
 
        if( m_constraint )
        {
            if( !m_constraint->check( m_value ) )
                throw exception_t< Trait >(
                    Trait::from_ascii( "Invalid value: \"" ) +
                    m_value +
                    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( "." ) );
        }
 
        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 typename Trait::string_t value =
            format_t< typename Trait::string_t, Trait >::from_string( info, str );
 
        m_value.append( value );
 
        this->set_defined();
    }
 
private:
    typename Trait::string_t m_value;
    constraint_t< typename Trait::string_t > * m_constraint;
}; // class tag_scalar_t
 
 
#ifdef CFGFILE_QT_SUPPORT
 
//
// tag_scalar_t< QString >
//
 
template< typename Trait >
class tag_scalar_t< QString, Trait >
    :   public tag_t< Trait >
{
    static const typename Trait::pos_t c_max_string_length = 80;
 
public:
    explicit tag_scalar_t( const typename Trait::string_t & name,
        bool is_mandatory = false )
        :   tag_t< Trait >( name, is_mandatory )
        ,   m_value( QString() )
        ,   m_constraint( nullptr )
    {
    }
 
    tag_scalar_t( tag_t< Trait > & owner, const typename Trait::string_t & name,
        bool is_mandatory = false )
        :   tag_t< Trait >( owner, name, is_mandatory )
        ,   m_value( QString() )
        ,   m_constraint( nullptr )
    {
    }
 
    ~tag_scalar_t()
    {
    }
 
    const QString &
    value() const
    {
        return m_value;
    }
 
    void
    set_value( const QString & v )
    {
        if( m_constraint )
        {
            if( !m_constraint->check( v ) )
                throw exception_t< Trait >(
                    Trait::from_ascii( "Invalid value: \"" ) +
                    typename Trait::string_t(
                        format_t< QString, Trait >::to_string( v ) ) +
                    Trait::from_ascii( "\". Value must match to the constraint "
                        "in tag \"" ) +
                    this->name() + Trait::from_ascii( "\"." ) );
        }
 
        m_value = v;
 
        this->set_defined();
    }
 
    void
    query_opt_value( QString & receiver )
    {
        if( this->is_defined() )
            receiver = m_value;
    }
 
    void
    set_constraint( constraint_t< QString > * 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() );
            result.push_back( const_t< Trait >::c_space );
 
            QString value = format_t< QString, Trait >::to_string( m_value );
 
            const typename Trait::pos_t sections =
                ( value.length() / c_max_string_length +
                ( value.length() % c_max_string_length > 0 ? 1 : 0 ) );
 
            if( sections )
            {
                const typename Trait::string_t spaces = typename Trait::string_t(
                    this->name().length() + 2, const_t< Trait >::c_space );
 
                for( typename Trait::pos_t i = 0; i < sections; ++i )
                {
                    if( i > 0 )
                    {
                        result.push_back( const_t< Trait >::c_carriage_return );
 
                        result.append( typename Trait::string_t( indent,
                            const_t< Trait >::c_tab ) );
 
                        result.append( spaces );
                    }
 
                    const typename Trait::string_t tmp =
                        to_cfgfile_format< Trait >(
                            value.mid( i * c_max_string_length,
                                c_max_string_length ) );
 
                    result.append( tmp );
                }
            }
            else
            {
                result.push_back( const_t< Trait >::c_quotes );
                result.push_back( const_t< Trait >::c_quotes );
            }
 
            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;
    }
 
#ifdef 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 Trait::string_t value =
                format_t< typename Trait::string_t, Trait >::to_string( m_value );
            value = to_cfgfile_format< Trait >( value );
 
            QDomText data = doc.createTextNode( value );
 
            this_element.appendChild( data );
 
            if( !this->children().empty() )
            {
                for( const tag_t< Trait > * tag : this->children() )
                    tag->print( doc, &this_element );
            }
        }
    }
#endif // CFGFILE_XML_SUPPORT
 
    void on_finish( const parser_info_t< Trait > & info ) override
    {
        if( m_constraint )
        {
            if( !m_constraint->check( m_value ) )
                throw exception_t< Trait >(
                    Trait::from_ascii( "Invalid value: \"" ) +
                    typename Trait::string_t( m_value ) +
                    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( "." ) );
        }
 
        if( !this->is_defined_member_value() )
            throw exception_t< Trait >(
                Trait::from_ascii( "Undefined value of 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( "." ) );
 
        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 QString value = format_t< QString, Trait >::from_string( info, str );
 
        m_value.append( value );
 
        this->set_defined();
    }
 
private:
    QString m_value;
    constraint_t< QString > * m_constraint;
}; // class tag_scalar_t< QString >
 
#endif // CFGFILE_QT_SUPPORT
 
} /* namespace cfgfile */
 
#endif // CFGFILE__TAG_SCALAR_HPP__INCLUDED