---

stltools.Vector.h

/*----------------------------------------------------------------------------
  SWORD 2000 - Software With Objects for Rapid Development
  Copyright (C) 2003 Eric NICOLAS
  ----------------------------------------------------------------------------
  SWORD is free software; you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  SWORD 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 Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with SWORD; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  --------------------------------------------------------------------------*/
#ifndef _SWORD_STLTOOLS_VECTOR_
#define _SWORD_STLTOOLS_VECTOR_

#include <vector>
#include <algorithm>
#include "sword/streams.IStream.h"
#include "sword/streams.OStream.h"

namespace std {

        template <class T>
        T sum(const std::vector<T>& vect)
        {
                T s = 0;

                for(std::vector<T>::const_iterator i = vect.begin(); i != vect.end(); ++i)
                        s += *i;

                return s;
        }

  // -- Traits for changing the way types are streamed to/from text

  // Generic traits
  template<class T>
  class stdStreamHelperTrait {
  public:
    static void send(std::ostream& oss, const T& t) { oss << t; }
    static void recv(std::istream& iss, T& t) { iss >> t; }
  };

  // Specialization for std::string with quotes
  template<>
  class stdStreamHelperTrait<std::string> {
  public:
    static void send(std::ostream& oss, const std::string& t) 
    { 
      oss << "\"";
      for(std::string::const_iterator i=t.begin(); i!=t.end(); ++i)
      {
        if (*i == '\"')
          oss << "\\\"";
        else
          oss << *i;
      }
      oss << "\"";
    }
    static void recv(std::istream& iss, std::string& t)
    { 
      char c = iss.get();
      if (c != '\"')
      {
        sword::estream << "When reading a string : opening \" expected";
        throw sword::Exception();
      }

      std::ostringstream oss;

      for(;;)
      {
        if (!iss)
        {
          sword::estream << "end of stream found while reading a string";
          throw sword::Exception();
        }
        c = iss.get();
        if (c == '\"')
        {
          // found the end quote we're done
          break;
        }
        else if (c == '\\')
        {
          char c1 = iss.get();
          if (c1 == '\"')
          {
            oss << c1;
          }
          else
          {
            oss << c << c1;
          }
        }
        else
          oss << c;
      }

      t = oss.str();
    }
  };

        // -- Implementation for : "cout << vector<T>"

        template<class T>
  std::ostream& operator<<(std::ostream& lhs, const std::vector<T>& rhs)
        {
                if (rhs.empty()) lhs << "<empty>";
                else
                {
                        lhs << "<";
                        for(std::vector<T>::const_iterator i=rhs.begin();i!=rhs.end();++i)
                        {
                                if (i!=rhs.begin()) lhs << ", ";
        stdStreamHelperTrait<T>::send(lhs, *i);
                        }
                        lhs << ">";
                }
                return lhs;
        }

  // -- Implementation for : "cin >> vector<T>"

  // eat whitespace
  // returns false if the end of stream has been found
  // returns true otherwise
  inline bool eatSpace_(std::istream& iss)
  {
    char c;
    do
    {
      c = iss.get();
      if (!iss) return false;
    }  while(isspace(c));
    iss.putback(c);

    return true;
  }

  template<class T>
  std::istream& operator>>(std::istream& lhs, std::vector<T>& rhs)
  {
    rhs.clear();
    
    // read the '<'
    {
      if (!eatSpace_(lhs)) return lhs;
      char c  = lhs.get();
      if (c != '<') return lhs;
    }

    // read the vector content until the '>'
    for(;;)
    {
      if (!eatSpace_(lhs)) return lhs;
      char c = lhs.get();
      if (c == '>') return lhs;
      lhs.putback(c);

      T t;
      stdStreamHelperTrait<T>::recv(lhs, t);

      rhs.push_back(t);

      if (!eatSpace_(lhs)) return lhs;
      c = lhs.get();
      if (c == '>') return lhs;
      if (c != ',') return lhs;
    }

    return lhs;
  }

        // Implementation for : "OStream << vector<T>"

        template<class T>
        sword::OStream& operator<<(sword::OStream& lhs, const std::vector<T>& rhs)
        {
                lhs << rhs.size();
                for(std::vector<T>::const_iterator i=rhs.begin(); i!=rhs.end(); ++i)
                {
                        lhs << *i;
                }
                return lhs;
        }

        // Implementation for : "IStream >> vector<T>"

        template<class T>
        sword::IStream& operator>>(sword::IStream& lhs, std::vector<T>& rhs)
        {
                size_t size;
                lhs >> size;
                rhs.resize(size);
                for(size_t i=0; i<size; ++i)
                {
                        lhs >> rhs[i];
                }
                return lhs;
        }

  // in<> on std::vector

        template<class T>
  bool in(const T& value, const std::vector<T>& v)
  {
    return std::find(v.begin(), v.end(), value) != v.end();
  }

} // namespace std

#endif // _SWORD_STLTOOLS_VECTOR_

---