---

xstl.H

Go to the documentation of this file.

#ifndef _XSTL_H
#define _XSTL_H

#include <functional>
#include <Vector.H>

using namespace std;

namespace xchen
{

  typedef vector<int> intvector;
  typedef vector<char> charvector;
  typedef vector<double> doublevector;

  typedef set<int, less<int> > intset;
  typedef set<char, less<char> > charset;
  typedef set<double, less<double> > doubleset;


  template<class T>
  inline ostream& print(T const& v, ostream& os = cout, char* delimiter = " ")
  {
    copy(v.begin(), v.end(), ostream_iterator<T>(os, delimiter));
    return os;
  }

  inline char* cpystr(const char* from) 
  {
    char* to = new char[strlen(from)+1];
    int i = 0;
    while( to[i]=from[i] ) i++;
    return to;
  }

  template<class T>
  inline typename vector<T>::iterator findInVector(const T& e, vector<T>& v)
  {
    typename vector<T>::iterator itr = v.begin();
    for(; itr != v.end(); itr++)
    {
      if( (*itr) == e ) break;
    }
    return itr;
  }

  template<class T>
  inline typename vector<T>::const_iterator findInVector(const T& e, const vector<T>& v)
  {
    typename vector<T>::const_iterator itr = v.begin();
    for(; itr != v.end(); itr++)
      if( (*itr) == e )
        break;
    return itr;
  }

  template<class T>
  inline int eraseInVector(vector<T>& v, const T& e)
  {
    typename vector<T>::iterator itr = v.begin();
    for(; itr != v.end() && (*itr) != e; itr++);

    if( itr != v.end() ) { v.erase(itr); return 1; }

    return 0;
  }



  template<typename T>
  class iota
  {
      T val;
  public:
      iota(T const& v) : val(v) { }
      T operator()() { return val++; }
  };

  template<typename T>
  struct AffineCombineT1T2 : public binary_function<T, T const&, T const&>
  {
      AffineCombineT1T2(double t_1, double t_2) : t1(t_1), t2(t_2) { }
      T operator()(T const& p1, T const& p2) { return (p1 * t1 + p2 * t2) / (t1 + t2); }
      double t1, t2;
  };
  template<typename T>
  struct AffineCombine : public binary_function<T, T const&, T const&>
  {
      AffineCombine(double t_) : t(t_) { }
      T operator()(T const& p1, T const& p2) { return p1 * (1-t) + p2 * t; }
      double t;
  };

  template<typename T>
  struct Average : public binary_function<T, T const&, T const&>
  {
      T operator()(T const& p1, T const& p2) { return (p1 + p2) / 2.0; }
  };



  struct cross_product : public binary_function<dVector3D const&, dVector3D const&, dVector3D> 
  {
     dVector3D operator()(dVector3D const& x, dVector3D const& y) 
      { 
        return x ^ y;
      }
  };


  template<typename T>
  struct ScaleAll : public unary_function<T const&, T> 
  {
      ScaleAll(double s_) : s(s_) { }
      T operator()(T const& e) { return s * e; }
      double s;
  };

  template<typename T>
  struct Scale1stAdd : public binary_function<T const&, T const&, T> 
  {
      Scale1stAdd(double s_) : s(s_) { }
      T operator()(T const& e1, T const& e2) { return s * e1 + e2; }
      double s;
  };





}//end namespace xchen


#endif

---