fio_reader.hpp

Go to the documentation of this file.

//
// (c) Copyright 2011 DESY, Eugen Wintersberger <eugen.wintersberger@desy.de>
//
// This file is part of libpniio.
//
// libpniio 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.
//
// libpniio 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 libpniio.  If not, see <http://www.gnu.org/licenses/>.
//============================================================================
//
// Created on: Apr 30, 2012
//     Author: Eugen Wintersberger <eugen.wintersberger@desy.de>
//
//
#pragma once

#include <iostream>
#include <sstream>
#include <map>
#include <boost/regex.hpp>
#include <boost/current_function.hpp>

#include <pni/core/arrays.hpp>
#include "../spreadsheet_reader.hpp"

namespace pni{
namespace io{
   
    class fio_reader:public spreadsheet_reader
    {
        private:
            std::map<pni::core::string,std::streampos> _param_map;
            std::streampos _data_offset; 

            //====================private member methods=======================
            void _parse_file(std::ifstream &stream);

            //-----------------------------------------------------------------
            void _parse_parameters(std::ifstream &stream);

            //-----------------------------------------------------------------
            void _parse_data(std::ifstream &stream);

            //-----------------------------------------------------------------
            static pni::core::type_id_t _typestr2id(const pni::core::string &tstr);

            //-----------------------------------------------------------------
            static column_info _read_column_info(const pni::core::string &line);
          
            //------------------------------------------------------------------
            static std::vector<pni::core::string> _read_data_line(const pni::core::string &line);

            //-----------------------------------------------------------------
            template<typename T>
                void _get_parameter_data(std::ifstream &stream,T &value) const;

            //------------------------------------------------------------------
            void _get_parameter_data(std::ifstream &stream,pni::core::string &value) const;

            //-------------------------------------------------------------------
            template<typename CTYPE> 
                void _read_column(size_t index,CTYPE &array) const;

        public:
            //==============constructor and destructor=========================
            fio_reader();

            fio_reader(const fio_reader &r) = delete;

            fio_reader(fio_reader &&r);

            fio_reader(const pni::core::string &n);

            ~fio_reader();

            //===================assignment operators==========================
            fio_reader &operator=(const fio_reader &r) = delete;

            fio_reader &operator=(fio_reader &&r);

            //=================public member methods===========================
            size_t nparameters() const;

            //-----------------------------------------------------------------
            std::vector<pni::core::string> parameter_names() const;

            //-----------------------------------------------------------------
            template<typename T> 
            T parameter(const pni::core::string &name) const;
           
            //-----------------------------------------------------------------
            template<typename CTYPE> 
            CTYPE column(const pni::core::string &n) const;

            //-----------------------------------------------------------------
            template<typename CTYPE> 
                void column(const pni::core::string &n,CTYPE &c) const;

    };
    
    //==========implementation of private template methods=====================
    template<typename T> 
        void fio_reader::_get_parameter_data(std::ifstream &stream,T &value) const
    {
        stream>>value;
    }

    //======================template implementation============================
    template<typename T> 
    T fio_reader::parameter(const pni::core::string &name) const
    {
        std::ifstream &stream = this->_get_stream();
        std::streampos opos = stream.tellg(); //backup old stream position
    
        //obtain stream offset
        stream.seekg(this->_param_map.find(name)->second,std::ios::beg);

        //read data
        T value;

        this->_get_parameter_data(stream,value);

        //reset stream position
        stream.seekg(opos,std::ios::beg);
    
        return value;
    }

    //-------------------------------------------------------------------------
    template<typename CTYPE> 
        void fio_reader::column(const pni::core::string &n,CTYPE &c) const
    {
        using namespace pni::core;
        size_t cindex = 0; //column index

        try
        {
            cindex = this->column_index(n);
        }
        catch(key_error &error)
        {
            //append a new issuer to the exception
            error.append(EXCEPTION_RECORD);
            throw error;
        }

        try
        {
            this->_read_column(cindex,c);
        }
        catch(file_error &error)
        {
            error.append(EXCEPTION_RECORD);
            throw error;
        }
    }


    //-------------------------------------------------------------------------
    template<typename CTYPE> 
    CTYPE fio_reader::column(const pni::core::string &n) const
    {
        //create the container 
        //allocate a new array
        std::vector<size_t> s{this->nrecords()};
        CTYPE data(this->nrecords());

        this->column(n,data);

        return data;
    }

    //-------------------------------------------------------------------------
    template<typename CTYPE> 
    void fio_reader::_read_column(size_t index,CTYPE &c) const
    {
        using namespace pni::core;
        std::ifstream &stream = this->_get_stream();
        std::streampos orig_pos = stream.tellg();
        //move stream to data section
        stream.seekg(_data_offset,std::ios::beg);

        pni::core::string linebuffer;
#ifdef NOFOREACH
        for(auto iter = c.begin();iter!=c.end();++iter)
        {
            typename CTYPE::value_type &v = *iter;
#else
        for(typename CTYPE::value_type &v: c)
        {
#endif
            //read a single data line
            try
            {
                std::getline(stream,linebuffer);
            }
            catch(...)
            {
                //set file stream back to its original position
                stream.seekg(orig_pos,std::ios::beg); 
                //throw FileError if reading data form the file failed
                throw file_error(EXCEPTION_RECORD,"Error reading data from file!"); 
            }
            //split data line
            std::vector<pni::core::string> string_data = this->_read_data_line(linebuffer);
            //set requested element to the string buffer
            std::stringstream ss(string_data[index]);

            //write element to the container
            ss>>v;
        }
        

        //reset the stream 
        stream.seekg(orig_pos,std::ios::beg);
    }

//end of namespace
}
}