csv_stream_parser.hpp

#ifndef HAVE_TOM__CSV_STREAM_PARSER_HPP
#define HAVE_TOM__CSV_STREAM_PARSER_HPP
 
#include <tom-util/defines.hpp>
#include <tom-util/scalar.hpp>
#include <boost/tokenizer.hpp>
 
#include <iosfwd>
#include <string>
#include <iostream> // needed for debug stmt only
#include <vector>
#include <cctype>
 
//TOM_NAMESPACE_BEGIN;
namespace tom {
 
    class csv_stream_parser
    {
    public:
        typedef std::vector< tom::String>                                       token_vector;
        typedef token_vector::const_iterator                                    const_iterator;
        typedef token_vector::iterator                                          iterator;
 
        typedef boost::tokenizer< boost::escaped_list_separator<char> >         escaped_list_tokenizer;
        typedef boost::tokenizer< boost::char_separator<char> >                 char_tokenizer;
        typedef boost::tokenizer< boost::offset_separator >                     offset_tokenizer;
 
        csv_stream_parser( std::istream & , char delim = ',', char escape = '\\', char quote = '\"');
        virtual ~csv_stream_parser() {}
 
        void init();
        void init(char delim);
        void init(const std::vector<int> &offsets);
 
        virtual bool 
            nextLine();
 
        bool
        eof() const { return m_stream.eof(); }
 
        bool
        good() const { return m_stream.good(); }
 
        virtual const_iterator 
        begin() const { return m_tokens.begin(); }
 
        virtual iterator 
        begin() { return m_tokens.begin(); }
 
        virtual const_iterator 
        end() const { return m_tokens.end(); }
 
        virtual iterator 
        end() { return m_tokens.end(); }
 
        virtual size_t
        size() { return m_tokens.size(); }
 
        virtual const String &
            operator[]( int i )
        {
            return m_tokens[i]; 
        }
 
    protected:
        token_vector m_tokens;
        std::istream &m_stream;
        boost::escaped_list_separator<char> m_escapedListSeparator;
        boost::offset_separator m_OffsetSeparator;
        bool m_fixedLength;
        bool m_Initialized;
        char m_delim;
        char m_escape;
        char m_quote;
 
    private:
        static void 
        trimToken( std::string &s );
 
        void 
        reset() { m_tokens.clear(); m_line.clear(); }
 
        csv_stream_parser( const csv_stream_parser & );
        csv_stream_parser &operator=( const csv_stream_parser & );
 
        std::string m_line;
 
        struct whitespace {
            whitespace() : m_stop(false) {}
            bool operator()( const char & val )
            {
                if ( m_stop ) return false;
                if ( std::isspace( val ) != 0 )
                    return true;
                else
                {
                    m_stop = true;
                    return false;
                }
            }
            void reset() { m_stop = false; }
            bool m_stop;
        };
 
    public:
        bool
        initialized() const { return m_Initialized; }
    };
 
//TOM_NAMESPACE_END;
} // end tom namespace
 
#endif