root/library/bdm/base/user_info.cpp @ 416

//
// C++ Implementation: user_info.cpp
//
// Description: UI (user info) class for loading/saving objects from/to configuration files.
//
//
// Author: smidl <smidl@utia.cas.cz>, (C) 2009
//
// Copyright: See COPYING file that comes with this distribution
//
//

#include "user_info.h"

namespace bdm
{
///////////////////////////// Class UIFile /////////////////////////////////////////////

UIFile::UIFile()
{
}

UIFile::UIFile ( const string &file_name )
{
    try
    {
        readFile( file_name.c_str()  );
                // this flag has to be set AFTER each file load, that is why it is right here
                setAutoConvert( true );
    }
    catch ( FileIOException f )
    {
        it_error ( "UI error: file " + file_name + " not found." );
    }
    catch ( ParseException& P )
    {
        stringstream msg;
        msg << "UI error: parsing error """ << P.getError() << """ in file " << file_name << " on line " <<  P.getLine() << ".";
        it_error ( msg.str() );
    }
}


void UIFile::save(const string &file_name )
{
    try
    {
        writeFile ( file_name.c_str()  );
    }
    catch ( FileIOException f )
    {
        it_error( "UI error: file " + file_name + " is inacessible." );
    }
}

UIFile::operator Setting&()
{
    return getRoot();
}

///////////////////////////// Class UI::MappedUI /////////////////////////////////////////////

UI::MappedUI::StringToUIMap& UI::MappedUI::mapped_strings()
{
        // this way it is ensured that there is only one instance of StringTpUIMap, and 
        // what is more, this declaration leaves its allocation/deallocation on the compiler
    static StringToUIMap var;
    return var;
}

UI::MappedUI::TypeInfoToStringMap& UI::MappedUI::mapped_type_infos()
{
        // this way it is ensured that there is only one instance of TypeInfoToStringMap, and 
        // what is more, this declaration leaves its allocation/deallocation on the compiler
    static TypeInfoToStringMap var;
    return var;
}

void UI::MappedUI::add_class( const string &class_name, const type_info * const class_type_info, const UI* const ui )
{
    pair< const string, const UI* const > new_pair = make_pair( class_name, ui );
    mapped_strings().insert( new_pair );
    mapped_type_infos().insert( make_pair( class_type_info, new_pair.first ) );
}

void UI::MappedUI::unregistered_class_error( const string &unregistered_class_name )
{
        stringstream msg;
    msg << "UI error: class " + unregistered_class_name + " was not properly registered. Use the macro ""UIREGISTER([class name]);"" within your code." << endl;

        if( mapped_strings().size() )
        {
            StringToUIMap::const_iterator iter = mapped_strings().begin();
                msg << "These classes are already registered: " << iter->first;
                for(; iter != mapped_strings().end(); iter++)
                        msg << ", " << iter->first;
                msg << "." << endl;
        }                       
        else
                msg << "There is not any registered class yet!" << endl;
        
    it_error ( msg.str() );             
}

const UI& UI::MappedUI::retrieve_ui( const string &class_name )
{
    StringToUIMap::const_iterator iter = mapped_strings().find( class_name );
    if ( iter == mapped_strings().end())
                unregistered_class_error( class_name );
            
        return *iter->second;
}

const string& UI::MappedUI::retrieve_class_name( const type_info * const class_type_info )
{
    TypeInfoToStringMap::const_iterator iter = mapped_type_infos().find( class_type_info );
    if ( iter == mapped_type_infos().end())
                unregistered_class_error( "with RTTI name " + string(class_type_info->name()) );
    return iter->second;
}

///////////////////////////// Class SettingResolver /////////////////////////////////////////////

SettingResolver::SettingResolver( const Setting &potential_link )
        : result( initialize_reference( file, potential_link ) )
{
}

const Setting& SettingResolver::initialize_reference(UIFile *&file, const Setting &potential_link)
{
        file = NULL;

    if ( potential_link.getType() !=  Setting::TypeString )
            return potential_link;
        
        string link = (const char*) potential_link;
    size_t aerobase = link.find('@');

        const Setting *result;
    if ( aerobase != string::npos )
    {
        string file_name = link.substr( aerobase + 1, link.length() );
        file = new UIFile( file_name );
        result = &(Setting&)(*file);
        link = link.substr( 0, aerobase );
    }
    else
        {
                result = &potential_link;
        while ( !result->isRoot() )
            result = &result->getParent();
        }

    if ( !result->exists( link ) )
        throw UIException( "linked setting was not found", potential_link );

    return (*result)[link];
}

SettingResolver::~SettingResolver()
{
    if ( file ) delete file;
}

///////////////////////////// Class UI /////////////////////////////////////////////

void UI::assert_type( const Setting &element, Setting::Type type )
{
        if( element.getType()!=type)
                throw UIException("wrong setting type", element);
}

const Setting& UI::to_child_setting( const Setting &element, const int index )
{
    if ( !element.isList())
        throw UIException( "only TypeList elements could be indexed by integers", element );

    if ( element.getLength() <= index )
        throw UIException( "there is not any child with index " + index, element );

    return element[index];
}

const Setting& UI::to_child_setting( const Setting &element, const string &name )
{
    if ( !element.isGroup())
        throw UIException( "only TypeGroup elements could be indexed by strings", element );

    if ( !element.exists( name ) )
        throw UIException( "there is not any child named """ + name, element );

    return element[name];
}

void UI::save( const int &integer, Setting &element, const string &name)
{
    Setting &set = (name == "") ? element.add( Setting::TypeInt )
                                            : element.add( name, Setting::TypeInt );
    set = integer;
}

void UI::save( const double &real, Setting &element, const string &name)
{
    Setting &set = (name == "") ? element.add( Setting::TypeFloat )
                                            : element.add( name, Setting::TypeFloat );
    set = real;
}

void UI::save( const string &str, Setting &element, const string &name)
{
    Setting &set = (name == "") ? element.add( Setting::TypeString )
                                            : element.add( name, Setting::TypeString );
    set = str;
}

void UI::save( const mat &matrix, Setting &element, const string &name)
{
    Setting &set = (name == "") ? element.add( Setting::TypeList )
                                            : element.add( name, Setting::TypeList );

    Setting &cols = set.add( Setting::TypeInt );
    cols = matrix.cols();

    Setting &rows = set.add( Setting::TypeInt );
    rows = matrix.rows();

    Setting &elements = set.add( Setting::TypeArray );

    // build matrix row-wise
    for ( int i=0; i<matrix.rows(); i++ )
        for ( int j=0; j<matrix.cols(); j++)
        {
            Setting &new_field = elements.add(Setting::TypeFloat);
            new_field = matrix(i,j);
        }
}

void UI::save( const ivec &vector, Setting &element, const string &name)
{
    Setting &set = (name == "") ? element.add( Setting::TypeArray )
                    : element.add( name, Setting::TypeArray );
    for ( int i=0; i<vector.length(); i++ )
    {
        Setting &new_field = set.add(Setting::TypeInt);
        new_field = vector(i);
    }
}

void UI::save( const vec &vector, Setting &element, const string &name)
{
    Setting &set = (name == "") ? element.add( Setting::TypeArray )
                    : element.add( name, Setting::TypeArray );
    for ( int i=0; i<vector.length(); i++ )
    {
                Setting &new_field = set.add(Setting::TypeFloat);
        new_field = vector(i);
    }
}

void UI::from_setting( mat& matrix, const Setting &element )
{
    const SettingResolver link( element );

    if ( link.result.isNumber() )
    {
        matrix.set_size( 1, 1 );
        matrix(0,0) = link.result;
        return;
    }

    if ( link.result.isList() )
    {
                int data_offset;

                if ( link.result.getLength() == 3 )
                        data_offset = 0;
                else if ( link.result.getLength() == 4 )
                {
                assert_type(link.result[0],Setting::TypeString);
                        const char* elem1=(const char*)link.result[0];
                        if( (strcmp(elem1, "matrix") ))
                                throw UIException( "the setting supposed to represent a matrix element has wrong syntax", link.result );

                        data_offset = 1;
                }
                else
                        throw UIException( "the setting supposed to represent a matrix element has wrong syntax", link.result );

        Setting &rows_setting = link.result[0 + data_offset];
        Setting &cols_setting = link.result[1 + data_offset];
        Setting &elements = link.result[2 + data_offset];

        assert_type(cols_setting,Setting::TypeInt);
        assert_type(rows_setting,Setting::TypeInt);
        assert_type(elements,Setting::TypeArray);

        int cols = cols_setting;
        int rows = rows_setting;

        if ( cols < 0 || rows < 0 )
            throw UIException( "the dimensions of a matrix has to be non-negative", link.result );

        if ( elements.getLength() != cols * rows )
            throw UIException( "the count of the matrix elements is incompatible with matrix dimension", elements );

        matrix.set_size( rows, cols );

        if ( cols == 0 || rows == 0 )
            return;

        if ( !elements[0].isNumber() )
            throw UIException( "matrix elements have to be numbers", elements[0] );

        // build matrix row-wise
        int k = 0;
        for ( int i=0; i<rows; i++ )
            for ( int j=0; j<cols; j++)
                matrix(i,j) = elements[k++];
        return;
    }

    throw UIException( "only numeric types or TypeList are supported as matrix values", link.result );
}

void UI::from_setting( vec &vector, const Setting &element )
{
    const SettingResolver link( element );

    if ( link.result.isNumber() )
    {
        vector.set_length( 1 );
        vector(0) = link.result;
        return;
    }

    if ( link.result.isList() )
    {
                mat matrix;
                from_setting( matrix, link.result );

        if ( matrix.cols() != 1 && matrix.rows() !=1)
                        throw UIException( "the vector length is invalid, it seems to be rather a matrix", link.result );

        int len = matrix.rows() * matrix.cols();
        vector.set_length ( len );
        if ( len == 0 ) return;

        if ( matrix.cols() == 1 )
                        for ( int i=0; i<len; i++ )
                                vector(i) = matrix(i,0);
                else
                        for ( int i=0; i<len; i++ )
                                vector(i) = matrix(0,i);
        return;
    }

    if ( link.result.isArray() )
    {
        int len = link.result.getLength();
        vector.set_length( len );
        if ( len == 0 ) return;

        if ( !link.result[0].isNumber())
            throw UIException("a vector element has to be a number", link.result[0]);

        for ( int i=0; i < len; i++ ) 
            vector(i) = link.result[i];

                return;
    }

    throw UIException( "only numeric types, TypeArray or TypeList are supported as vector values", link.result );
}

void UI::from_setting( ivec &vector, const Setting &element )
{
        vec double_vector;
        from_setting( double_vector, element ); 
    int len = double_vector.length();
    vector.set_length ( len );
        for( int i = 0; i< len; i++ )
                vector(i) = (int) double_vector(i);
}

void UI::from_setting( string &str, const Setting &element )
{
    assert_type(element,Setting::TypeString);
    str = (const char*) element;
}

void UI::from_setting( int &integer, const Setting &element )
{
    assert_type(element,Setting::TypeInt);
    integer = element;
}

void UI::from_setting( double &real, const Setting &element )
{
    assert_type(element,Setting::TypeFloat);
    real = element;
}

}