readColumns.hpp

Go to the documentation of this file.

/** \file readColumns.hpp
 * \author Jared R. Males
 * \brief A utility to read in columns from a text file.
 * \ingroup asciiutils
 */
 
//***********************************************************************//
// Copyright 2015, 2016, 2017 Jared R. Males (jaredmales@gmail.com)
//
// This file is part of mxlib.
//
// mxlib 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 3 of the License, or
// (at your option) any later version.
//
// mxlib 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 mxlib.  If not, see <http://www.gnu.org/licenses/>.
//***********************************************************************//
 
#ifndef __readColumns_hpp__
#define __readColumns_hpp__
 
#include <fstream>
#include <string>
#include <cstring>
#include <iostream>
 
#include "../mxlib.hpp"
#include "../mxError.hpp"
 
#include "stringUtils.hpp"
 
#define MX_READCOL_MISSINGVALSTR "-99"
 
namespace mx
{
namespace ioutils
{
 
template <char delim = ' ', char eol = '\n'>
void readcol( char *sin, int sz )
{
    static_cast<void>( sin );
    static_cast<void>( sz );
 
    return;
}
 
template <char delim = ' ', char eol = '\n', typename arrT, typename... arrTs>
void readcol( char *sin, int sz, arrT &array, arrTs &...arrays )
{
    // static const unsigned short int nargs = sizeof...(arrTs);
    std::string str;
 
    int i = 0;
    int l = strlen( sin );
 
    if( l < 1 )
        return;
 
    // Eat white space
    while( isspace( sin[i] ) && sin[i] != eol && i < l )
        ++i;
    sin = sin + i;
    sz = sz - i;
 
    // If there's nothing here, we still need to populate the vector
    if( sz <= 1 )
    {
        array.push_back( convertFromString<typename arrT::value_type>( "" ) );
        return;
    }
 
    std::stringstream sinstr( sin );
 
    std::getline( sinstr, str, delim );
 
    // Last entry in line might contain eol
    if( str[str.size() - 1] == eol )
    {
        str.erase( str.size() - 1 );
    }
 
    if( str.size() == 0 )
    {
        array.push_back( convertFromString<typename arrT::value_type>( MX_READCOL_MISSINGVALSTR ) );
    }
    else
    {
        array.push_back( convertFromString<typename arrT::value_type>( str ) );
    }
 
    sin += ( str.size() + 1 ) * sizeof( char );
    sz -= ( str.size() + 1 ) * sizeof( char );
 
    readcol<delim, eol>( sin, sz, arrays... );
}
 
/// Read in columns from a text file
/** This function opens a file containing data formatted in columns and reads in the data row by row.
 * The data are stored in std::vectors, which should not be pre-allocated (though they could be reserve()-ed).
 *
 * Example:
 * \code
 * std::vector<int> i1;
 * std::vector<float> f1;
 * std::vector<double> d1;
 *
 * readColumns("data_file.txt", i1, f1, d1);
 * \endcode
 *
 * Note that the types of the vectors do not need to be specified as template arguments.
 *
 * The format of the file can be specified with template arguments like
 * \code
 * readColumns<',', ';', '\r'>("data_file.csv", i1, f1, d1);
 * \endcode
 * which sets the delimmiter to comma, the comment character to ;, and the end-of-line to \\r.
 *
 * Columns can be skipped using mx::ioutils::skipCol.
 *
 * \tparam delim is the character separating columns,  by default this is space.
 * \tparam comment is the character starting a comment.  by default this is #
 * \tparam eol is the end of line character.  by default this is \n
 * \tparam arrTs a variadic list of array types. this is not specified by the user.
 *
 * \todo lineSize should be configurable
 *
 * \ingroup asciiutils
 */
template <char delim = ' ', char comment = '#', char eol = '\n', typename... arrTs>
int readColumns( const std::string &fname, ///< [in] is the file name to read from
                 arrTs &...arrays ///< [out] a variadic list of std::vectors. Any number with mixed value_type can be
                                  ///< specified. Neither allocated nor cleared, so repeated calls will append data.
)
{
    // open file
    errno = 0;
    std::ifstream fin;
    fin.open( fname );
 
    if( !fin.good() )
    {
        if( errno != 0 )
        {
            mxPError( "readColumns", errno, "Occurred while opening " + fname + " for reading." );
        }
        else
        {
            mxError( "readColumns", MXE_FILEOERR, "Occurred while opening " + fname + " for reading." );
        }
        return -1;
    }
 
    int lineSize = 4096;
    char *line = new char[lineSize];
 
    while( fin.good() )
    {
        // Save one space for adding eol
        fin.getline( line, lineSize - 1, eol );
 
        int i = 0;
        int l = strlen( line );
 
        if( l <= 0 )
            break;
 
        // std::cerr << line << "\n";
 
        // Find start of comment and end line at that point.
        while( line[i] != comment )
        {
            ++i;
            if( i == l )
                break;
        }
 
        if( i <= l - 1 )
        {
            line[i] = '\0';
        }
 
        l = strlen( line );
 
        if( l == 0 )
            continue;
 
        // Make sure line ends with eol
        line[l] = eol;
        ++l;
        line[l] = '\0';
 
        readcol<delim, eol>( line, strlen( line ), arrays... );
    }
 
    delete[] line;
 
    // getline will have set fail if there was no new line on the last line.
    if( fin.bad() && !fin.fail() )
    {
        if( errno != 0 )
        {
            mxPError( "readColumns", errno, "Occurred while reading from " + fname + "." );
        }
        else
        {
            mxError( "readColumns", MXE_FILERERR, "Occurred while reading from " + fname + "." );
        }
        return -1;
    }
 
    fin.clear(); // Clear the fail bit which may have been set by getline
    fin.close();
 
    if( fin.fail() )
    {
        if( errno != 0 )
        {
            mxPError( "readColumns", errno, "Occurred while closing " + fname + "." );
        }
        else
        {
            mxError( "readColumns", MXE_FILECERR, "Occurred while closing " + fname + "." );
        }
        return -1;
    }
 
    return 0;
}
 
/// A dummy class to allow mx::readColumns to skip a column(s) in a file without requiring memory allocation.
/** The alternative is to use dummy vectors, which result in excess memory allocations and deallocations.
  * Usage:
  \code
  std::vector<T> col1, col5;
  skipCol sk;
  readColumns("filename.txt", col1, sk, sk, sk, col5); //This results in only columns 1 and 5 being stored.
  \endcode
  *
  * \ingroup asciiutils
  */
struct skipCol
{
    typedef std::string value_type; ///< value_type is defined as std::string so that no conversions take place.
 
    template <typename T>
    void push_back( const T &arg )
    {
        return;
    }
};
 
} // namespace ioutils
} // namespace mx
 
#endif //__readColumns_hpp__