CTextFileLinesParser.h

Go to the documentation of this file.

/* +---------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)               |
   |                          http://www.mrpt.org/                             |
   |                                                                           |
   | Copyright (c) 2005-2017, Individual contributors, see AUTHORS file        |
   | See: http://www.mrpt.org/Authors - All rights reserved.                   |
   | Released under BSD License. See details in http://www.mrpt.org/License    |
   +---------------------------------------------------------------------------+ */
#ifndef CTextFileLinesParser_H
#define CTextFileLinesParser_H

#include <mrpt/utils/utils_defs.h>
#include <mrpt/system/string_utils.h>
#include <fstream>
#include <iosfwd>

namespace mrpt
{
    namespace utils
    {
                        /** A class for parsing text files, returning each non-empty and non-comment line, along its line number.
                          *  Lines are strip out of leading and trailing whitespaces.
                          *  By default, lines starting with either "#", "//" or "%" are skipped (comment lines),
                          *   unless this behavior is explicitly disabled with  \a enableCommentFilters
                          * \ingroup mrpt_base_grp
                          */
                        class BASE_IMPEXP CTextFileLinesParser
                        {
                        public:
                                /** Default constructor; should call \a open() at some moment later. */
                                CTextFileLinesParser() : m_curLineNum(0), m_filter_MATLAB_comments(true), m_filter_C_comments(true), m_filter_SH_comments(true), m_in{ NULL }, m_in_ownership{ true } { }

                                /** Constructor for opening a file  \exception std::exception On error opening file */
                                explicit CTextFileLinesParser(const std::string &fil) : m_filter_MATLAB_comments(true), m_filter_C_comments(true), m_filter_SH_comments(true), m_in{ NULL }, m_in_ownership{ true } {
                                        open(fil);
                                }

                                explicit CTextFileLinesParser(std::istream& in) : m_filter_MATLAB_comments(true), m_filter_C_comments(true), m_filter_SH_comments(true), m_in{ NULL }, m_in_ownership{ true } {
                                        open(in);
                                }

                                /** Open a file (an alternative to the constructor with a file name) */
                                void open(const std::string &fil)
                                {
                                        m_curLineNum = 0;
                                        m_fileName = fil;
                                        this->close();
                                        std::ifstream *ifs = new std::ifstream;
                                        m_in = ifs;
                                        ifs->open(fil.c_str());
                                        if (!ifs->is_open())
                                                THROW_EXCEPTION_FMT("Error opening file '%s' for reading",fil.c_str());
                                }

                                void open(std::istream& in)
                                {
                                        m_curLineNum = 0;
                                        m_fileName = "{std::istream}";
                                        this->close();
                                        m_in = &in;
                                        m_in_ownership = false;
                                }


                                /** Close the file (no need to call it normally, the file is closed upon destruction) */
                                void close() {
                                        if (!m_in) return;
                                        if (m_in_ownership) delete m_in;
                                        m_in = NULL;
                                }

                                /** Reset the read pointer to the beginning of the file */
                                void rewind()
                                {
                                        m_curLineNum = 0;
                                        m_in->clear();
                                        m_in->seekg(0);
                                }

                                /** Reads from the file and return the next (non-comment) line, as a std::string
                                  * \return false on EOF.
                                  */
                                inline bool getNextLine(std::string &out_str)
                                {
                                        std::istringstream buf;
                                        if (getNextLine(buf))
                                        {
                                                out_str = buf.str();
                                                return true;
                                        }
                                        else
                                        {
                                                out_str.clear();
                                                return false;
                                        }
                                }

                                /** Reads from the file and stores the next (non-comment) line into the given stream buffer.
                                  * \return false on EOF.
                                  */
                                bool getNextLine( std::istringstream &buf )
                                {
                                        ASSERT_(m_in != NULL);
                                        while (!m_in->fail())
                                        {
                                                std::string lin;
                                                std::getline(*m_in,lin);
                                                m_curLineNum++;
                                                lin = mrpt::system::trim(lin);
                                                if (lin.empty()) continue; // Ignore empty lines.
                                                // Ignore comments lines, starting with "#" or "//".
                                                if ( (m_filter_SH_comments && mrpt::system::strStarts(lin,"#"))
                                                  || (m_filter_C_comments  && mrpt::system::strStarts(lin,"//"))
                                                  || (m_filter_MATLAB_comments && mrpt::system::strStarts(lin,"%")) )
                                                        continue;
                                                // Parse the line as a string stream:
                                                buf.str(lin);
                                                buf.clear();
                                                return true;
                                        };
                                        return false;
                                }

                                /** Return the line number of the last line returned with \a getNextLine */
                                inline size_t getCurrentLineNumber() const { return m_curLineNum; }

                                /** Enable/disable filtering of lines starting with "%", "//" or "#", respectively. */
                                inline void enableCommentFilters(
                                        bool filter_MATLAB_comments,
                                        bool filter_C_comments,
                                        bool filter_SH_comments
                                        )
                                {
                                        m_filter_MATLAB_comments = filter_MATLAB_comments;
                                        m_filter_C_comments = filter_C_comments;
                                        m_filter_SH_comments = filter_SH_comments;
                                }

                        private:
                                std::string   m_fileName;
                                size_t        m_curLineNum;
                                bool              m_filter_MATLAB_comments;
                                bool              m_filter_C_comments;
                                bool              m_filter_SH_comments;
                                std::istream *m_in;
                                bool m_in_ownership;

                        };  // end of CTextFileLinesParser
        } // End of namespace
} // end of namespace
#endif