lineparser.h

/*************************************************************************************
 * MechSys - A C++ library to simulate (Continuum) Mechanical Systems                *
 * Copyright (C) 2005 Dorival de Moraes Pedroso <dorival.pedroso at gmail.com>       *
 * Copyright (C) 2005 Raul Dario Durand Farfan  <raul.durand at gmail.com>           *
 *                                                                                   *
 * This file is part of MechSys.                                                     *
 *                                                                                   *
 * MechSys is free software; you can redistribute it and/or modify it under the      *
 * terms of the GNU General Public License as published by the Free Software         *
 * Foundation; either version 2 of the License, or (at your option) any later        *
 * version.                                                                          *
 *                                                                                   *
 * MechSys is distributed in the hope that it will be useful, but WITHOUT ANY        *
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A   *
 * PARTICULAR PURPOSE. See the GNU General Public License for more details.          *
 *                                                                                   *
 * You should have received a copy of the GNU General Public License along with      *
 * MechSys; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, *
 * Fifth Floor, Boston, MA 02110-1301, USA                                           *
 *************************************************************************************/

#ifndef MECHSYS_LINEPARSER_H
#define MECHSYS_LINEPARSER_H

#include <string>
#include <fstream>
#include <sstream>
#include <algorithm>

#include "util/array.h"
#include "util/string.h"
#include "util/exception.h"

class LineParser : public std::istringstream
{
public:
    LineParser(std::string const & Line) : std::istringstream(Line)          {}
    LineParser(     String const & Line) : std::istringstream(Line.GetSTL()) {}
    void Reset(     String const & Line) { Reset(Line.GetSTL()); }
    void Reset(std::string const & Line)
    {
        (*this).clear();
        (*this).str(Line);
    }
    void ReplaceAllChars(char OldChar, char NewChar)
    {
        std::string tmp(std::istringstream::str());
        std::replace(tmp.begin(), tmp.end(), OldChar, NewChar);
        std::istringstream::str(tmp);
    }

    void Set(String const & S)
    {
        this->str(S.GetSTL());
    }

    template<typename Type>
    void ToArray(Array<Type> & A);

    template<typename Type>
    void StructuredLine(int & A, int & B, Array< Array<Type> > & C);

    void SeparatedLine(std::string const & Separator, Array<std::string> & Res);
    void SeparatedLine(     String const & Separator, Array<     String> & Res);

    template<typename Type1, typename Type2>
    bool BreakExpressions(Array<Type1> & lvalue, Array<Type2> & rvalue);
private:
}; // class LineParser




template<typename Type>
inline void LineParser::ToArray(Array<Type> & A) // {{{
{
    // Fill A array with iss.str() values
    A.resize(0);
    Type tmp;
    while ((*this)>>tmp)
    {
        A.push_back(tmp);
    }
} // }}}

template<typename Type>
inline void LineParser::StructuredLine(int & A, int & B, Array< Array<Type> > & C) // {{{
{
    // Ex.:
    //      7  5  { 1 2 3 } { 4 5 6 8 0 1 }
    //      A  B     C[0]        C[1]

    C.resize(0);
    std::string str_open_key;
    (*this) >> A >> B >> str_open_key;
    if (str_open_key[0]!='{')
        throw new Fatal(_("LineParser::StructuredLine: Line is not corrected formatted. Line=< %s >"),this->str().c_str());
    
    Array<Type> a_inner;
    std::string str_tmp;
    while ((*this)>>str_tmp)
    {
        if (str_tmp[0]=='}')
        {
            (*this)>>str_open_key; // read next '{'
            C.push_back(a_inner);
            a_inner.resize(0);
        }
        else
        {
            std::istringstream iss(str_tmp);
            Type tmp; iss>>tmp;
            a_inner.push_back(tmp);
        }
    }
} // }}}

inline void LineParser::SeparatedLine(std::string const & Separator, Array<std::string> & Res) // {{{
{
    /* Ex.:
     *         /home/dorival/teste/An File.txt 
     *          R[0]  R[1]   R[2]     R[3]
     *
     *         ->1234->456a->789as
     *           R[0]  R[1]  R[2]
     */

    // Clear result array
    Res.resize(0);

    // Fill result array
    if (Separator.empty())
        Res.push_back(this->str());
    else if (!this->str().empty())
    {
        // Loop along the line
        size_t start = 0;
        size_t end   = this->str().find(Separator, start);
        while (end!=std::string::npos)
        {
            Res.push_back(this->str().substr(start, end - start));
            start = end + Separator.size();
              end = this->str().find(Separator, start);
        }
        Res.push_back(this->str().substr(start));
        // Clear the line (all extracted)
        this->clear(); this->str("");
    }
} // }}}

inline void LineParser::SeparatedLine(String const & Separator, Array<String> & Res) // {{{
{
    std::string        sep = Separator.GetSTL();
    Array<std::string> arr;
    SeparatedLine(sep,arr);
    size_t len = arr.size();
    Res.resize(len);
    for (size_t i=0; i<len; ++i)
        Res[i] = String(arr[i]);
} // }}}

template<typename Type1, typename Type2>
inline bool LineParser::BreakExpressions(Array<Type1> & Lvalue, Array<Type2> & Rvalue) // {{{
{
    /* For:  this->str() == "var1=value1 var2=value3 var3=value4"
     *
     * with:  var1,   var2   and var3   of Type1
     * and    value1, value2 and value3 of Type2
     *
     * result:
     *           Lvalue={var1,var2,var3}
     *      and  Rvalue={value1,value2,value3}
     * return:
     *           false if some problem occurred with istringstream, i.e: format is invalid
     */

    Lvalue.resize(0);
    Rvalue.resize(0);
    ReplaceAllChars('=',' ');

    // Parse bry marks
    Type1 lval;
    Type2 rval;
    while ((*this)>>lval)
    {
        if (((*this)>>rval))
        {
            Lvalue.push_back(lval);
            Rvalue.push_back(rval);
        }
        else return false;
    }
    if (Lvalue.size()==Rvalue.size()) return true;
    else                              return false;
} // }}}

#endif //MECHSYS_FILEPARSER

// vim:fdm=marker

---