source: trunk/c++_tools/utility/stl_utility.h @ 675

#ifndef _theplu_utility_stl_utility_
#define _theplu_utility_stl_utility_ 

// $Id: stl_utility.h 675 2006-10-10 12:08:45Z jari $

/*
  Copyright (C) 2004 Jari Häkkinen
  Copyright (C) 2005 Jari Häkkinen, Peter Johansson, Markus Ringnér
  Copyright (C) 2006 Jari Häkkinen

  This file is part of the yat library, http://lev.thep.lu.se/trac/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 2 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 this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  02111-1307, USA.
*/

///
/// \file stl_utility.h
///
/// There are a number of useful functionality missing in the Standard
/// Template Library, STL. This file is an effort to provide
/// extensions to STL functionality.
///

#include <ostream>
#include <string>
#include <utility>
#include <vector>

namespace std {

  ///
  /// Print out a pair 
  ///
  // This is in namespace std because we have not figured out how to have
  // pair and its operator<< in different namespaces
  template <class T1, class T2>  
  std::ostream& operator<<(std::ostream& out, const std::pair<T1,T2>& p) 
  { out << p.first << "\t" << p.second; return out; }

}

namespace theplu {
namespace utility {


  ///
  /// STL provides operator< for the pair.first element, but none for
  /// pair.second. This template provides this and can be used as the
  /// comparison object in generic functions such as the STL sort.
  ///
  template <class T1,class T2>
  struct pair_value_compare
  {
    ///
    /// @return true if x.second<y.second or (x.second==y.second and
    /// x.first<y.first)
    ///
    inline bool operator()(const std::pair<T1,T2>& x,
                           const std::pair<T1,T2>& y) {
      return ((x.second<y.second) ||
              (!(y.second<x.second) && (x.first<y.first))); 
    }
  };

  ///
  /// Function reading from istream to vector of doubles. Function
  /// reads the line until next '\\n'. The line is splitted with
  /// respect to whitespaces and push_backed into the vector. The
  /// vector is emptied before the reading starts. Unexpected
  /// characters are currently skipped with a warning message.
  /// NaN is supported to be a double (case-insensitive)
  ///
  /// @return false if end of stream
  ///
  /// @note The functionality of this function will change in the
  /// future. The overall functionality will be the same but the
  /// outcome of unexpected events will change.
  ///
  bool read_to_double(std::istream&, std::vector<double>&);

  ///
  /// Function reading from istream to vector of ints. Function
  /// reads the line until next '\\n'. The line is splitted with
  /// respect to whitespaces and push_backed into the vector. The
  /// vector is emptied before the reading starts. Unexpected
  /// characters are currently skipped with a warning message.
  /// NaN is supported to be an int (case-insensitive)
  ///
  /// @return false if end of stream
  ///
  /// @note The functionality of this function will change in the
  /// future. The overall functionality will be the same but the
  /// outcome of unexpected events will change.
  ///
  bool read_to_int(std::istream&, std::vector<int>&);

  ///
  /// Function reading from istream to vector of strings. Function
  /// reads the line until next '\\n'. The line is splitted with
  /// respect to whitespaces and push_backed into the vector. The
  /// vector is emptied before the reading starts.
  ///
  /// @return false if end of stream
  ///
  bool read_to_string(std::istream&, std::vector<std::string>&);

  ///
  /// Function converting a string to lower case
  ///
  inline void to_lower(std::string& s) {
    transform(s.begin(),s.end(), s.begin(), tolower);
  }

  ///
  /// Function converting a string to upper case
  ///
  inline void to_upper(std::string& s) {
    transform(s.begin(),s.end(), s.begin(), toupper);
  }


}} // of namespace utility and namespace theplu

#endif