#include <iostream>
#include <string>
#include <vector>
#include <utility>

///////////////////////////////////////////////////////////////////////////////
// Manipulators
///////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////
// basic_io_format
///////////////////////////////////////////////////////////////////////////////

template<class CharType,class T>
class basic_io_format
{
private:
  typedef std::basic_string<CharType> StringType;

public:
  basic_io_format(const StringType &s,const StringType &e,const StringType &d) :
    start(s),end(e),delimiter(d) {}

  template<class CharTraits>
  friend std::basic_ostream<CharType,CharTraits> &operator<<
    (std::basic_ostream<CharType,CharTraits> &stream,const basic_io_format &object)
  {
    format(stream)=object;

    return stream;
  }

  template<class CharTraits>
  static basic_io_format &format(std::basic_ostream<CharType,CharTraits> &stream)
  {
    void *&void_ptr=stream.pword(format_index());

    if(!void_ptr)
      void_ptr=new basic_io_format(StringType(),StringType(),StringType());

    return *static_cast<basic_io_format *>(void_ptr);
  }

private:
  static int format_index()
  {
    static int index=std::ios_base::xalloc();

    return index;
  }

public:
  StringType start;
  StringType end;
  StringType delimiter;
};

///////////////////////////////////////////////////////////////////////////////
// io_format
///////////////////////////////////////////////////////////////////////////////

template<class T>
struct io_format : basic_io_format<char,T>
{
  io_format(const std::string &start,const std::string &end,const std::string &delimiter) :
    basic_io_format<char,T>(start,end,delimiter) {}
};

///////////////////////////////////////////////////////////////////////////////
// wio_format
///////////////////////////////////////////////////////////////////////////////

template<class T>
struct wio_format : basic_io_format<wchar_t,T>
{
  wio_format(const std::wstring &start,const std::wstring &end,const std::wstring &delimiter) :
    basic_io_format<wchar_t,T>(start,end,delimiter) {}
};

template<class CharType,class CharTraits,class Element,class Allocator>
std::basic_ostream<CharType,CharTraits> &operator<<
  (std::basic_ostream<CharType,CharTraits> &,const std::vector<Element,Allocator> &);

template<class CharType,class CharTraits,class First,class Second>
std::basic_ostream<CharType,CharTraits> &operator<<
  (std::basic_ostream<CharType,CharTraits> &,const std::pair<First,Second> &);

namespace detail
{

  ///////////////////////////////////////////////////////////////////////////////
  // print_container
  ///////////////////////////////////////////////////////////////////////////////

  template<class CharType,class CharTraits,class Container>
  void print_container(std::basic_ostream<CharType,CharTraits> &stream,const Container &container)
  {
  typedef basic_io_format<CharType,Container> format_type;

  const format_type &format=format_type::format(stream);

  stream << format.start;

  const typename Container::const_iterator end=container.end();
  typename Container::const_iterator i=container.begin();

  if(i!=end)
    stream << *i;

  while(++i, i!=end)
    stream << format.delimiter << *i;

  stream << format.end;
  }
}

///////////////////////////////////////////////////////////////////////////////
// operator<<(stream,std::vector)
///////////////////////////////////////////////////////////////////////////////

template<class CharType,class CharTraits,class Element,class Allocator>
std::basic_ostream<CharType,CharTraits> &operator<<
  (std::basic_ostream<CharType,CharTraits> &stream,const std::vector<Element,Allocator> &v)
{
  detail::print_container(stream,v);

  return stream;
}

///////////////////////////////////////////////////////////////////////////////
// operator<<(stream,std::pair)
///////////////////////////////////////////////////////////////////////////////

template<class CharType,class CharTraits,class First,class Second>
std::basic_ostream<CharType,CharTraits> &operator<<
  (std::basic_ostream<CharType,CharTraits> &stream,const std::pair<First,Second> &p)
{
  typedef basic_io_format<CharType,std::pair<First,Second> > format_type;

  const format_type &format=format_type::format(stream);

  return stream << format.start << p.first << format.delimiter << p.second << format.end;
}

int main()
{
typedef std::pair<int,char> Map;
typedef std::vector<Map> MapList;

MapList list;

list.push_back(std::make_pair(1,'A'));
list.push_back(std::make_pair(2,'B'));
list.push_back(std::make_pair(3,'C'));

std::cout << io_format<Map>("[","]",",") << io_format<MapList>("","","\n") << list << '\n';
}