getvector.h

#ifndef _theplu_yat_utility_getvector_
#define _theplu_yat_utility_getvector_

// $Id: getvector.h 4207 2022-08-26 04:36:28Z peter $

/*
  Copyright (C) 2017, 2020, 2021, 2022 Peter Johansson

  This file is part of the yat library, http://dev.thep.lu.se/yat

  The yat library 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.

  The yat library 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 yat. If not, see <http://www.gnu.org/licenses/>.
*/

#include <yat/utility/split.h>
#include <yat/utility/utility.h>

#include <boost/algorithm/string/classification.hpp>
#include <boost/type_traits/is_same.hpp>

#include <istream>
#include <string>
#include <utility>
#include <vector>

namespace theplu {
namespace yat {
namespace utility {

  template<typename T>
  std::istream& getvector(std::istream& is, std::vector<T>& result,
                          char delim, char newlinedelim='\n');

  template<typename T>
  std::istream& getvector(std::istream& is, std::vector<T>& result,
                          const std::string& delim, char newlinedelim='\n');


  // private stuff
  namespace detail {

    template<typename T>
    void convert(std::vector<std::string>&& vec,
                 std::vector<T>& result, boost::true_type is_string)
    {
      result = std::move(vec);
    }


    template<typename T>
    void convert(const std::vector<std::string>& vec,
                 std::vector<T>& result, boost::false_type is_string)
    {
      result.clear();
      result.reserve(vec.size());
      for (const std::string& v : vec)
        result.push_back(utility::convert<T>(v));
    }


    template<typename Predicate, typename T>
    std::istream& getvector(std::istream& is, std::vector<T>& result,
                            Predicate pred, char delim)
    {
      if (is.good() == false)
        return is;
      std::vector<std::string> vec;
      char c;
      std::string word;
      while (is.get(c)) {
        if (pred(c)) {
          vec.push_back(std::move(word));
          word = "";
        }
        else if (c == delim)
          break;
        else
          word += c;
      }
      // if is contained no characters, not even delim, leave result empty
      if (vec.empty() && word=="" && is.good()==false)
        return is;
      vec.push_back(std::move(word));

      typename boost::is_same<T, std::string> is_string;
      convert(std::move(vec), result, is_string);
      return is;
    }

  } // end namespace detail

  // implementation of public API
  template<typename T>
  std::istream& getvector(std::istream& is, std::vector<T>& result,
                          char delim, char newlinedelim)
  {
    return detail::getvector(is, result, [delim](char c) { return c==delim; },
                             newlinedelim);
  }


  template<typename T>
  std::istream& getvector(std::istream& is, std::vector<T>& result,
                          const std::string& delim, char newlinedelim)
  {
    return detail::getvector(is, result, boost::is_any_of(delim), newlinedelim);
  }

}}} // of namespace utility, yat, and theplu

#endif