getvector.h

#ifndef _theplu_yat_utility_getvector_
#define _theplu_yat_utility_getvector_

// $Id: getvector.h 3639 2017-04-26 02:12:08Z peter $

/*
  Copyright (C) 2017 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/type_traits/is_same.hpp>

#include <istream>
#include <string>
#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)
    {
      // swap only swaps couple pointers, hence almost free. Do not us
      // vec after this point.
      std::swap(vec, result);
    }


    template<typename T>
    void convert(std::vector<std::string>& vec,
                 std::vector<T>& result, boost::false_type is_string)
    {
      result.reserve(vec.size());
      for (size_t i=0; i<vec.size(); ++i)
        result.push_back(utility::convert<T>(vec[i]));
    }


    template<typename DELIM, typename T>
    std::istream& getvector(std::istream& is, std::vector<T>& result,
                            DELIM delim, char nl_delim)
    {
      std::string line;
      if (!getline(is, line, nl_delim))
        return is;
      std::vector<std::string> vec;
      split(vec, line, delim);
      typename boost::is_same<T, std::string> is_string;
      convert(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, 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, delim, newlinedelim);
  }

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

#endif