parser.h

Go to the documentation of this file.

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef SP_PARSER_H
#define SP_PARSER_H
#include <map>
 
namespace sp
{
 
class parser
{
  private:
    std::map<std::string, std::string> par_map; 
 
    bool valid_key( const std::string& key )
    {
        if( par_map.find( key ) == par_map.end() )
        {
            std::cout << "SigPack: Parameter " + key + " not found!" << std::endl;
            return false;
        }
        return true;
    }
 
    std::complex<double> parse_cx( std::string str )
    {
        double            re, im;
        char              i_ch;
        std::stringstream iss( str );
 
        // Parse full ...
        if( iss >> re >> im >> i_ch && ( i_ch == 'i' || i_ch == 'j' ) )
            return std::complex<double>( re, im );
 
        // ... or only imag
        iss.clear();
        iss.seekg( 0, iss.beg );
        if( iss >> im >> i_ch && ( i_ch == 'i' || i_ch == 'j' ) )
            return std::complex<double>( 0.0, im );
 
        // .. or only real
        iss.clear();
        iss.seekg( 0, iss.beg );
        if( iss >> re )
            return std::complex<double>( re, 0.0 );
 
        // ... otherwise
        err_handler( "Could not parse complex number!" );
    }
 
  public:
    parser( const std::string& fname )
    {
        std::ifstream fh;
        std::string   line;
        size_t        mark = 0;
 
        // Clear parameter map
        par_map.clear();
 
        // Open file
        fh.open( fname.c_str() );
        if( !fh )
        {
            wrn_handler( "Could not find " + fname );
        }
        else
        {
            // Parse
            while( std::getline( fh, line ) )
            {
                std::string keyS  = "";
                std::string dataS = "";
 
                // Skip empty lines
                if( line.empty() )
                    continue;
 
                // Skip lines with only whitespace
                if( line.find_first_not_of( "\t " ) == std::string::npos )
                    continue;
 
                // Remove comment
                mark = line.find( "%" );
                if( mark != std::string::npos )
                    line.erase( mark, line.length() );
 
                // Do we have a '='
                mark = line.find( "=" );
                if( mark != std::string::npos )
                {
                    // Find key
                    keyS = line.substr( line.find_first_not_of( "\t " ), mark - line.find_first_not_of( "\t " ) );
                    keyS = keyS.substr( 0, keyS.find_last_not_of( "\t " ) + 1 );
 
                    // Find data
                    dataS = line.substr( mark + 1, line.length() );
                    dataS = dataS.substr( 0, dataS.find_last_not_of( "\t " ) + 1 );
 
                    // Do we have a string
                    mark = dataS.find( "\"" );
                    if( mark != std::string::npos )
                    {
                        dataS = dataS.substr( mark + 1, dataS.length() );
                        dataS = dataS.substr( 0, dataS.find_last_of( "\"" ) );
                    }
                    // Do we have a vector/matrix
                    mark = dataS.find( "[" );
                    if( mark != std::string::npos )
                    {
                        dataS = dataS.substr( mark + 1, dataS.length() );
                        dataS = dataS.substr( 0, dataS.find_last_of( "]" ) );
                    }
 
                    // Insert to map
                    par_map.insert( std::pair<std::string, std::string>( keyS, dataS ) );
                }
            }
 
            // Close file
            fh.close();
        }
    }
 
    ~parser()
    {
    }
 
    template <typename T> T getParam( const std::string key, const T def_val )
    {
        if( !valid_key( key ) )
        {
            std::cout << "Setting default " << def_val << std::endl;
            return def_val;
        }
        std::istringstream iss( par_map.find( key )->second );
        T                  out;
        iss >> out;
        return out;
    }
 
    std::string getString( const std::string key, const std::string def_val )
    {
        if( !valid_key( key ) )
        {
            std::cout << "Setting default " << def_val << std::endl;
            return def_val;
        }
        return par_map.find( key )->second;
    }
 
    template <typename T> arma::Col<T> getCol( const std::string key, const arma::Col<T> def_val )
    {
        if( !valid_key( key ) )
        {
            std::cout << "Setting default \n" << def_val << std::endl;
            return def_val;
        }
 
        std::string        row, str = par_map.find( key )->second;
        std::istringstream full_str( str );
        int                K = static_cast<int>( std::count( str.begin(), str.end(), ';' ) + 1 );
        arma::Col<T>       x( K );
        for( int k = 0; k < K; k++ )
        {
            std::getline( full_str, row, ';' );
            std::stringstream iss( row );
            iss >> x( k );
        }
        return x;
    }
 
    arma::cx_vec getCxCol( const std::string key, const arma::cx_vec def_val )
    {
        if( !valid_key( key ) )
        {
            std::cout << "Setting default \n" << def_val << std::endl;
            return def_val;
        }
 
        std::string        row, str = par_map.find( key )->second;
        std::istringstream full_str( str );
        int                K = static_cast<int>( std::count( str.begin(), str.end(), ';' ) + 1 );
        arma::cx_vec       x( K );
        for( int k = 0; k < K; k++ )
        {
            std::getline( full_str, row, ';' );
            x( k ) = parse_cx( row );
        }
        return x;
    }
 
    template <typename T> arma::Row<T> getRow( const std::string key, const arma::Row<T> def_val )
    {
        if( !valid_key( key ) )
        {
            std::cout << "Setting default \n" << def_val << std::endl;
            return def_val;
        }
 
        std::string        col, str = par_map.find( key )->second;
        std::istringstream full_str( str );
        int                K = static_cast<int>( std::count( str.begin(), str.end(), ',' ) + 1 );
        arma::Row<T>       x( K );
        for( int k = 0; k < K; k++ )
        {
            std::getline( full_str, col, ',' );
            std::stringstream iss( col );
            iss >> x( k );
        }
        return x;
    }
 
    arma::cx_rowvec getCxRow( const std::string key, const arma::cx_rowvec def_val )
    {
        if( !valid_key( key ) )
        {
            std::cout << "Setting default \n" << def_val << std::endl;
            return def_val;
        }
 
        std::string        col, str = par_map.find( key )->second;
        std::istringstream full_str( str );
        int                K = static_cast<int>( std::count( str.begin(), str.end(), ',' ) + 1 );
        arma::cx_rowvec    x( K );
        for( int k = 0; k < K; k++ )
        {
            std::getline( full_str, col, ',' );
            x( k ) = parse_cx( col );
        }
        return x;
    }
 
    template <typename T> arma::Mat<T> getMat( const std::string key, const arma::Mat<T> def_val )
    {
        if( !valid_key( key ) )
        {
            std::cout << "Setting default \n" << def_val << std::endl;
            return def_val;
        }
        std::string        full_str, row, col;
        std::istringstream iss_full;
 
        full_str = par_map.find( key )->second;
        int R    = static_cast<int>( std::count( full_str.begin(), full_str.end(), ';' ) + 1 );
 
        iss_full.str( full_str );
        std::getline( iss_full, row, ';' );
        int C = static_cast<int>( std::count( row.begin(), row.end(), ',' ) + 1 );
 
        arma::Mat<T> x( R, C );
 
        iss_full.seekg( 0, iss_full.beg );
        for( int r = 0; r < R; r++ )
        {
            std::getline( iss_full, row, ';' );
            std::istringstream iss_row( row );
            for( int c = 0; c < C; c++ )
            {
                std::getline( iss_row, col, ',' );
                std::istringstream iss_col( col );
                iss_col >> x( r, c );
            }
        }
        return x;
    }
 
    arma::cx_mat getCxMat( const std::string key, const arma::cx_mat def_val )
    {
        if( !valid_key( key ) )
        {
            std::cout << "Setting default \n" << def_val << std::endl;
            return def_val;
        }
        std::string        full_str, row, col;
        std::istringstream iss_full;
 
        full_str = par_map.find( key )->second;
        int R    = static_cast<int>( std::count( full_str.begin(), full_str.end(), ';' ) + 1 );
 
        iss_full.str( full_str );
        std::getline( iss_full, row, ';' );
        int C = static_cast<int>( std::count( row.begin(), row.end(), ',' ) + 1 );
 
        arma::cx_mat x( R, C );
 
        iss_full.seekg( 0, iss_full.beg );
        for( int r = 0; r < R; r++ )
        {
            std::getline( iss_full, row, ';' );
            std::istringstream iss_row( row );
            for( int c = 0; c < C; c++ )
            {
                std::getline( iss_row, col, ',' );
                x( r, c ) = parse_cx( col );
            }
        }
        return x;
    }
 
}; // end Class
 
} // namespace sp
#endif