Question

I want to provide a generic line based IO for containers of std::string in a library.
Line based since the strings may contain spaces.
The following code seems to work fine but I’m not sure whether this is the best way to go or whether it creates some ambiguities, I’m failing to grasp.

#define boostForeach BOOST_FOREACH

template< template<typename ELEM, typename ALLOC=std::allocator<ELEM> > class Container >
std::ostream& operator<< (std::ostream& o, Container<std::string>const & container){
  boostForeach(std::string const& str, container) {
    o << str << "\n";
  }
  return o;
}

template< template<typename ELEM, typename ALLOC=std::allocator<ELEM> > class Container >
std::istream& operator>> (std::istream& in, Container<std::string>& container){
  container.clear();
  std::string buf;
  while(getline(in, buf)) {
    if(buf.empty()) break; //stop if empty line found to separate map from other data
    container.insert(container.end(),buf);
  }
  return in;
}

So the question is: Is this safe and sound ?

Answer 1

You can write the output algorithm using std::copy():

std::copy(container.begin(),
    container.end(),
    std::ostream_iterator<std::string>(o, "\n"));

You might use an input iterator for paragraph input, i.e., multiple lines separated by blank lines:

class istream_paragraph_iterator: public std::iterator<std::forward_iterator_tag,std::string>{
    std::istream* stream;
    std::string line;
public:

    istream_paragraph_iterator() : stream(0) {}

    istream_paragraph_iterator(std::istream& stream) : stream(&stream) {++*this; //get the first element
    }

    std::string operator*() const {
        return line;
    }

    const std::string* operator->() const {
        return &line;
    }

    istream_paragraph_iterator& operator++() {
        if (stream && (!std::getline(*stream, line) || line.empty()))
            stream = 0;
        return *this;
    }

    istream_paragraph_iterator operator++(int) {
        istream_paragraph_iterator previous(*this);
        ++*this;
        return previous;
    }

    bool operator==(const istream_paragraph_iterator& other) const {
        return stream == other.stream;
    }

    bool operator!=(const istream_paragraph_iterator& other) const {
        return !(*this == other);
    }

};

Then you can write the input algorithm using std::copy() as well:

std::copy(istream_paragraph_iterator(in),
    istream_paragraph_iterator(),
    std::back_inserter(container));

Separating the logic into an iterator type lets you make the input and output algorithms parameterisable, and thus more general. In a template library, that’s typically a good thing. I would avoid adding overloads for standard containers, because you cannot know that they do the right thing on every platform; iterator-based algorithms are more portable, and you don’t have to write all the template<template<...> class ...> cruft.