csv.hpp

Go to the documentation of this file.

/*
  CSV.hpp  -  Parser and Encoder for CSV data

   Copyright (C)
     2022,            Hermann Vosseler <Ichthyostega@web.de>

  **Lumiera** 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. See the file COPYING for further details.

*/


#ifndef LIB_STAT_CSV_H
#define LIB_STAT_CSV_H

#include "lib/error.hpp"
#include "lib/null-value.hpp"
#include "lib/meta/tuple-helper.hpp"
#include "lib/format-string.hpp"
#include "lib/regex.hpp"

#include <limits>
#include <string>
#include <vector>

namespace lib {
namespace stat {
  
  namespace error = lumiera::error;

  using util::_Fmt;
  using util::toString;
  using std::string;
  using std::regex;
  
  
  namespace { // Implementation details...
  
    const string MATCH_SINGLE_TOKEN { R"~(([^,;"\s]*)\s*)~"};
    const string MATCH_QUOTED_TOKEN { R"~("([^"]*)"\s*)~" };
    const string MATCH_DELIMITER    { R"~((?:^|,|;)\s*)~" };
    
    const regex FIND_DELIMITER_TOKEN{"[,;]"};
    
    const regex ACCEPT_FIELD{ MATCH_DELIMITER + "(?:"+ MATCH_QUOTED_TOKEN +"|"+ MATCH_SINGLE_TOKEN +")"
                            , regex::optimize};
    
    template<typename VAL>
    inline string
    format4Csv (VAL const& val)
    {
      if constexpr (std::is_floating_point_v<VAL>)
        return util::showDecimal (val);
                  //   standard textual rendering
      auto res = util::toString (val);
      if constexpr (std::is_arithmetic_v<VAL>)
        return res;   // includes bool
      else
        return '"'+res+'"';
    }
  }//(End)Implementation
  
  
  template<typename VAL>
  inline void
  appendCsvField (string& csv, VAL const& val)
  {
    csv += (0 == csv.length()? "":",")
         + format4Csv(val);
  }
  
  
  struct CSVLine
    : std::string
    {
      using value_type = string;
      
      template<typename...ELMS,                 typename = meta::disable_if_self<CSVLine,ELMS...>>
      CSVLine (ELMS&& ...items)
        {
          meta::forEach (std::make_tuple (items...)
                        ,[this](auto const& it){ *this += it; }
                        );
        }
      // Standard copy acceptable
      
      
      template<typename X>
      CSVLine&
      operator+= (X const& x)
      {
        stat::appendCsvField (*this, x);
        return *this;
      }
    };
  
  struct CSVData
    : std::vector<CSVLine>
    {
      using VecCSV = std::vector<CSVLine>;
      
      CSVData (std::initializer_list<string> lines)
        : VecCSV(detectHeader(lines))
        { }
      
      CSVData (std::initializer_list<string> header
              ,std::initializer_list<CSVLine> data)
        {
          reserve (data.size()+1);
          appendHeaderLine(*this, header);
          for (CSVLine const& line : data)
            emplace_back (line);
        }
      
      // standard copy operations acceptable
      
      
      operator string()  const
        {
          std::ostringstream buffer;
          for (string const& line : *this)
            buffer << line << '\n';
          return buffer.str();
        }
      
      
    private:
      static bool
      containsCSV (string const& line)
        {
          return std::regex_search (line, FIND_DELIMITER_TOKEN);
        }
      
      static void
      appendHeaderLine (VecCSV& data, std::initializer_list<string> const& input)
        {
          CSVLine header;
          for (string const& s : input)
            header += s;
          data.emplace_back (move(header));
        }
      
      static VecCSV
      detectHeader (std::initializer_list<string> input)
        {
          VecCSV csv;
          if (input.size() > 0 and containsCSV(*input.begin()))
            {// the first line is a header => slurp in all as lines
              csv.reserve (input.size());
              for (string const& s : input)
                csv.emplace_back (s);
            }
          else // combine all strings into a single header line
            appendHeaderLine (csv, input);
          return csv;
        }
    };
  
  
  
  template<typename TAR>
  inline TAR
  parseAs (string const& encodedVal)
  {
      std::istringstream converter{encodedVal};
      TAR value;
      converter >> value;
      if (converter.fail())
          throw error::Invalid{_Fmt{"unable to parse \"%s\""} % encodedVal};
      return value;
  }
  
  template<>
  inline bool
  parseAs (string const& encodedBool)
  {
      return util::boolVal(encodedBool);
  }
  template<>
  inline string
  parseAs (string const& string)
  {
      return string; // pass-through (even if empty)
  }
  
  
  
  
  class CsvParser
    : public util::RegexSearchIter
    {
      string const& line_{};
      size_t   field_{0};
      size_t   pos_{0};
      
      util::RegexSearchIter const& curr() const { return *this; }
      util::RegexSearchIter        end()  const { return util::RegexSearchIter{}; }

    public:
      CsvParser()
        : line_{lib::NullValue<string>::get()}
        { }
      
      CsvParser (string& line) // NOTE: string and reg-exp must exist elsewhere
        : RegexSearchIter(line, ACCEPT_FIELD)
        , line_{line}
        { }
      
      explicit operator bool()  const
        {
          return isValid();
        }

      ENABLE_USE_IN_STD_RANGE_FOR_LOOPS (CsvParser);
      
      
      string operator*()  const
        {
          if (not isValid()) fail();
          auto& mat = *curr();
          return mat[2].matched? mat[2]
                               : mat[1];
        }
      
      void
      operator++()
        {
          if (not isValid())
            fail();
          pos_ = curr()->position() + curr()->length();
          util::RegexSearchIter::operator ++();
          if (pos_ < line_.length() and not isValid())
            fail ();
          ++field_;
        }
      
      size_t
      getParsedFieldCnt()
        {
          return field_;
        }
      
      bool
      isValid()  const
        {
          return curr() != end()
             and pos_ == size_t(curr()->position())
             and not curr()->empty();
        }
      
      bool
      isParseFail()  const
        {
          return curr() != end()
             and not isValid();
        }
      
      void
      fail()  const
        {
          if (curr() == end())
              if (pos_ >= line_.length())
                  throw error::Invalid{_Fmt{"Only %d data fields. Line:%s"}
                                           % field_ % line_};
              else
                  throw error::Invalid{_Fmt{"Garbage after last field. Line:%s|↯|%s"}
                                           % line_.substr(0,pos_) % line_.substr(pos_)};
          else
          if (pos_ != size_t(curr()->position()))
                  throw error::Invalid{_Fmt{"Garbage before field(%d):%s|↯|%s"}
                                           % (field_+1)
                                           % line_.substr(0,pos_) % line_.substr(pos_)};
          
          throw error::Invalid{_Fmt{"CSV parse floundered. Line:%s"} % line_};
        }
    };
  
}} // namespace lib::stat
#endif /*LIB_STAT_CSV_H*/