#ifndef __JIO__JSTDIO__
#define __JIO__JSTDIO__

#include <string>

#include "JLang/JSTDTypes.hh"
#include "JIO/JSerialisable.hh"


/**
 * \file
 * STD extensions for binary I/O.
 * \author mdejong
 */
namespace JIO {}
namespace JPP { using namespace JIO; }

namespace JIO {

  /**
   * Read template std::string from input.
   *
   * \param  in            reader
   * \param  object        object
   * \return               reader
   */
  inline JReader& operator>>(JReader& in, std::string& object) 
  { 
    unsigned int n = 0;

    object.clear();
    
    in.read((char*) &n, sizeof(unsigned int));
    
    for (char c; n != 0; --n, object += c) {
      in.read(&c, sizeof(char));
    }
    
    return in; 
  }


  /**
   * Write template std::string to output.
   *
   * \param  out           writer
   * \param  object        object
   * \return               writer
   */
  inline JWriter& operator<<(JWriter& out, const std::string& object) 
  { 
    unsigned int n = object.size();
    
    out.write((const char*) &n, sizeof(unsigned int));
    out.write((const char*) object.c_str(), n);
    
    return out;
  }


  /**
   * Read template std::vector from input.
   *
   * \param  in            reader
   * \param  object        object
   * \return               reader
   */
  template<class JElement_t, class JAllocator_t>
  inline JReader& operator>>(JReader& in, std::vector<JElement_t, JAllocator_t>& object)
  {
    int n = 0;

    in >> n;

    object.resize(n);
    
    for (typename std::vector<JElement_t, JAllocator_t>::iterator i = object.begin(); i != object.end(); ++i) {
      in >> *i;
    }
    
    return in;
  }
  
  
  /**
   * Write template std::vector to output.
   *
   * \param  out           writer
   * \param  object        object
   * \return               writer
   */
  template<class JElement_t, class JAllocator_t>
  inline JWriter& operator<<(JWriter& out, const std::vector<JElement_t, JAllocator_t>& object)
  {
    int n = object.size();
    
    out << n;
    
    for (typename std::vector<JElement_t, JAllocator_t>::const_iterator i = object.begin(); i != object.end(); ++i) {
      out << *i;
    }
   
    return out;
  }


  /**
   * Read template std::list from input.
   *
   * \param  in            reader
   * \param  object        object
   * \return               reader
   */
  template<class JElement_t, class JAllocator_t>
  inline JReader& operator>>(JReader& in, std::list<JElement_t, JAllocator_t>& object)
  {
    int n = 0;

    in >> n;

    typename std::list<JElement_t, JAllocator_t>::value_type element;
    
    object.clear();

    for (int i = 0; i != n; ++i) {
      
      in >> element;
      
      object.push_back(element);
    }
    
    return in;
  }
  
  
  /**
   * Write template std::list to output.
   *
   * \param  out           writer
   * \param  object        object
   * \return               writer
   */
  template<class JElement_t, class JAllocator_t>
  inline JWriter& operator<<(JWriter& out, const std::list<JElement_t, JAllocator_t>& object)
  {
    int n = object.size();
    
    out << n;
    
    for (typename std::list<JElement_t, JAllocator_t>::const_iterator i = object.begin(); i != object.end(); ++i) {
      out << *i;
    }
   
    return out;
  }


  /**
   * Read template std::set from input.
   *
   * \param  in            reader
   * \param  object        object
   * \return               reader
   */
  template<class JElement_t, class JComparator_t, class JAllocator_t>
  inline JReader& operator>>(JReader& in, std::set<JElement_t, JComparator_t, JAllocator_t>& object)
  {
    int n = 0;
    
    in >> n;
    
    typename std::set<JElement_t, JComparator_t, JAllocator_t>::value_type element;
    
    object.clear();

    for (int i = 0; i != n; ++i) {
      
      in >> element;
      
      object.insert(element);
    }

    return in;
  }
  

  /**
   * Write template std::set to output.
   *
   * \param  out           writer
   * \param  object        object
   * \return               writer
   */
  template<class JElement_t, class JComparator_t, class JAllocator_t>
  inline JWriter& operator<<(JWriter& out, const std::set<JElement_t, JComparator_t, JAllocator_t>& object)
  {
    int n = object.size();
    
    out << n;
    
    for (typename std::set<JElement_t, JComparator_t,JAllocator_t>::const_iterator i = object.begin(); i != object.end(); ++i) {
      out << *i;
    }
    
    return out;
  }


  /**
   * Read template std::multiset from input.
   *
   * \param  in            reader
   * \param  object        object
   * \return               reader
   */
  template<class JElement_t, class JComparator_t, class JAllocator_t>
  inline JReader& operator>>(JReader& in, std::multiset<JElement_t, JComparator_t, JAllocator_t>& object)
  {
    int n = 0;
    
    in >> n;
    
    typename std::multiset<JElement_t, JComparator_t, JAllocator_t>::value_type element;
    
    object.clear();

    for (int i = 0; i != n; ++i) {
      
      in >> element;
      
      object.insert(element);
    }

    return in;
  }
  

  /**
   * Write template std::multiset to output.
   *
   * \param  out           writer
   * \param  object        object
   * \return               writer
   */
  template<class JElement_t, class JComparator_t, class JAllocator_t>
  inline JWriter& operator<<(JWriter& out, const std::multiset<JElement_t, JComparator_t, JAllocator_t>& object)
  {
    int n = object.size();
    
    out << n;
    
    for (typename std::multiset<JElement_t, JComparator_t,JAllocator_t>::const_iterator i = object.begin(); i != object.end(); ++i) {
      out << *i;
    }
    
    return out;
  }


  /**
   * Read template std::pair from input.
   *
   * \param  in            reader
   * \param  object        object
   * \return               reader
   */
  template<class JKey_t, class JValue_t>
  inline JReader& operator>>(JReader& in, std::pair<JKey_t, JValue_t>& object)
  {
    in >> object.first;
    in >> object.second;

    return in;
  }
  

  /**
   * Write template std::pair to output.
   *
   * \param  out           writer
   * \param  object        object
   * \return               writer
   */
  template<class JKey_t, class JValue_t>
  inline JWriter& operator<<(JWriter& out, const std::pair<JKey_t, JValue_t>& object)
  {
    out << object.first;
    out << object.second;
    
    return out;
  }


  /**
   * Read template std::map from input.
   *
   * \param  in            reader
   * \param  object        object
   * \return               reader
   */
  template<class JKey_t, class JValue_t, class JComparator_t, class JAllocator_t>
  inline JReader& operator>>(JReader& in, std::map<JKey_t, JValue_t, JComparator_t, JAllocator_t>& object)
  {
    int n = 0;
    
    in >> n;

    typename std::map<JKey_t, JValue_t, JComparator_t, JAllocator_t>::key_type    key;  
    typename std::map<JKey_t, JValue_t, JComparator_t, JAllocator_t>::mapped_type value;      

    object.clear();

    for (int i = 0; i != n; ++i) {
      
      in >> key >> value;      

      object[key]=value;
    }

    return in;
  }
  

  /**
   * Write template std::map to output.
   *
   * \param  out           writer
   * \param  object        object
   * \return               writer
   */
  template<class JKey_t, class JValue_t, class JComparator_t, class JAllocator_t>
  inline JWriter& operator<<(JWriter& out, const std::map<JKey_t, JValue_t, JComparator_t, JAllocator_t>& object)
  {
    int n = object.size();
    
    out << n;
    
    for (typename std::map<JKey_t, JValue_t, JComparator_t, JAllocator_t>::const_iterator i = object.begin(); i != object.end(); ++i) {
      out << *i;
    }
    
    return out;
  }


  /**
   * Read template std::multimap from input.
   *
   * \param  in            reader
   * \param  object        object
   * \return               reader
   */
  template<class JKey_t, class JValue_t, class JComparator_t, class JAllocator_t>
  inline JReader& operator>>(JReader& in, std::multimap<JKey_t, JValue_t, JComparator_t, JAllocator_t>& object)
  {
    int n = 0;
    
    in >> n;

    typename std::multimap<JKey_t, JValue_t, JComparator_t, JAllocator_t>::key_type    key;  
    typename std::multimap<JKey_t, JValue_t, JComparator_t, JAllocator_t>::mapped_type value;      
    
    object.clear();

    for (int i = 0; i != n; ++i) {
      
      in >> key >> value;      

      object[key]=value;
    }

    return in;
  }
  

  /**
   * Write template std::multimap to output.
   *
   * \param  out           writer
   * \param  object        object
   * \return               writer
   */
  template<class JKey_t, class JValue_t, class JComparator_t, class JAllocator_t>
  inline JWriter& operator<<(JWriter& out, const std::multimap<JKey_t, JValue_t, JComparator_t, JAllocator_t>& object)
  {
    int n = object.size();
    
    out << n;
    
    for (typename std::multimap<JKey_t, JValue_t, JComparator_t, JAllocator_t>::const_iterator i = object.begin(); i != object.end(); ++i) {
      out << *i;
    }
    
    return out;
  }
}

#endif