mockpp-commits

[Ewald A. <ewa...@us...>]

Update of /cvsroot/mockpp/mockpp/3party/ministl
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv30919/3party/ministl

Modified Files:
	Makefile.am defalloc.h map map.h pair set string vector 
Added Files:
	multimap raw_iterator.h reverse_iterator.h 
Log Message:
ministl basically working

Index: map
===================================================================
RCS file: /cvsroot/mockpp/mockpp/3party/ministl/map,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- map	30 Nov 2005 21:46:34 -0000	1.3
+++ map	1 Dec 2005 18:15:08 -0000	1.4
@@ -30,6 +30,7 @@
 #include <ministl/simplevec.h>
 #include <ministl/functional>
 #include <ministl/pair>
+#include <ministl/multimap>
 
 //#include <ministl/bool.h>
 
@@ -59,36 +60,43 @@
     mapIterator ()
         : n (0)
     {}
+
     bool operator== (const my_type &it) const
     {
       return it.n == n;
     }
+
     bool operator!= (const my_type &it) const
     {
       return !(it.n == n);
     }
+
     my_type operator++ ()
     {
       ++n;
       return *this;
     }
+
     my_type operator++ (int)
     {
       my_type tmp = *this;
       ++n;
       return tmp;
     }
+
     my_type operator-- ()
     {
       --n;
       return *this;
     }
+
     my_type operator-- (int)
     {
       my_type tmp = *this;
       --n;
       return tmp;
     }
+
     value_type &operator* ()
     {
       return **n;
@@ -108,43 +116,52 @@
     mapConstIterator (repiterator _n)
         : n (_n)
     {}
+
   public:
     mapConstIterator ()
         : n (0)
     {}
+
     mapConstIterator (const mapIterator<kT,vT,cT> &i)
         : n (i.n)
     {}
+
     bool operator== (const my_type &it) const
     {
       return it.n == n;
     }
+
     bool operator!= (const my_type &it) const
     {
       return !(it.n == n);
     }
+
     my_type operator++ ()
     {
       ++n;
       return *this;
     }
+
     my_type operator++ (int)
     {
       my_type tmp = *this;
       ++n;
       return tmp;
     }
+
     my_type operator-- ()
     {
       --n;
       return *this;
     }
+
     my_type operator-- (int)
     {
       my_type tmp = *this;
       --n;
       return tmp;
     }
+
     const value_type &operator* () const
     {
       return **n;
@@ -155,6 +172,7 @@
 class map
 {
   public:
+
     typedef keyT key_type;
     typedef pair<const keyT, valT> value_type;
     typedef std::size_t size_type;
@@ -163,39 +181,51 @@
     typedef mapConstIterator<keyT, valT, cmpT> const_iterator;
     // XXX typedefs done to work around g++ bug
     typedef pair<iterator, bool> pair_iterator_bool;
+
   private:
+
     rep_type _ents;
     cmpT _comp;
+
   public:
+
     iterator begin ()
     {
       return iterator (_ents.begin());
     }
+
     const_iterator begin () const
     {
       return const_iterator (_ents.begin());
     }
+
     iterator end ()
     {
       return iterator (_ents.end());
     }
+
+
     const_iterator end () const
     {
       return const_iterator (_ents.end());
     }
+
     map (const cmpT &comp = cmpT())
         : _comp (comp)
     {}
+
     map (const_iterator first, const_iterator last, const cmpT &comp = cmpT())
         : _comp (comp)
     {
       insert (first, last);
     }
+
     map (const map<keyT, valT, cmpT> &m)
         : _comp (m._comp)
     {
       insert (m.begin(), m.end());
     }
+
     map<keyT, valT, cmpT> &operator= (const map<keyT, valT, cmpT> &m)
     {
       if (this != &m)
@@ -206,27 +236,34 @@
       }
       return *this;
     }
+
     ~map ()
     {
       erase (begin(), end());
     }
+
     bool empty () const
     {
       return _ents.empty ();
     }
+
     size_type size () const
     {
       return _ents.size ();
     }
+
   private:
     // find the iterator position where k should be inserted ...
     bool lookup (const key_type &k, iterator &it);
+
   public:
+
     pair_iterator_bool insert (const value_type &v)
     {
       iterator i = end();
       if (size() > 0 && lookup (v.first, i))
         return pair_iterator_bool (i, false);
+
       i = iterator (_ents.insert (i.n, new value_type (v)));
       return pair_iterator_bool (i, true);
     }
@@ -240,11 +277,13 @@
       for ( ; first != last; ++first)
         insert (*first);
     }
+
     void insert (const value_type *first, const value_type *last)
     {
       for ( ; first != last; ++first)
         insert (*first);
     }
+
     void erase (iterator pos)
     {
       if (pos != end())
@@ -253,6 +292,7 @@
         _ents.erase (pos.n);
       }
     }
+
     size_type erase (const key_type &k)
     {
       iterator i = find (k);
@@ -261,16 +301,19 @@
       erase (i);
       return 1;
     }
+
     void erase (iterator first, iterator last)
     {
       for (iterator i = first; i != last; ++i)
         delete *(i.n);
       _ents.erase (first.n, last.n);
     }
+
     void clear ()
     {
       erase (begin(), end());
     }
+
     iterator find (const key_type &k)
     {
       if (size() > 0)
@@ -296,6 +339,7 @@
       }
       return end();
     }
+
     const_iterator find (const key_type &k) const
     {
       if (size() > 0)
@@ -321,10 +365,12 @@
       }
       return end();
     }
+
     size_type count (const key_type &k) const
     {
       return find (k) != end() ? 1 : 0;
     }
+
     valT &operator[] (const key_type &k)
     {
       iterator i = insert(value_type (k, valT())).first;

Index: set
===================================================================
RCS file: /cvsroot/mockpp/mockpp/3party/ministl/set,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- set	30 Nov 2005 21:46:34 -0000	1.3
+++ set	1 Dec 2005 18:15:08 -0000	1.4
@@ -150,7 +150,7 @@
     }
 };
 
-template<class valT, class cmpT>
+template<class valT, class cmpT = ministl::less<valT> >
 class set
   {
   public:

Index: string
===================================================================
RCS file: /cvsroot/mockpp/mockpp/3party/ministl/string,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- string	30 Nov 2005 21:46:34 -0000	1.4
+++ string	1 Dec 2005 18:15:08 -0000	1.5
@@ -577,6 +577,12 @@
     remove (size_t pos = 0, size_t n = NPOS) _THROW_ALLOC_OUTRANGE ;
 
     basic_string<charT>&
+    erase (size_t pos = 0, size_t n = NPOS) _THROW_ALLOC_OUTRANGE
+    {
+      return remove(pos, n);
+    }
+
+    basic_string<charT>&
     replace (size_t pos1, size_t n1, const basic_string<charT>& str, size_t pos2 = 0,
              size_t n2 = NPOS) _THROW_ALLOC_LENGTH_OUTRANGE ;
 

--- NEW FILE: multimap ---
// -*- c++ -*-
/*
 *  MICO --- a free CORBA implementation
 *  Copyright (C) 1997-98 Kay Roemer & Arno Puder
 *
 *  Copyright (C) 2005 Ewald Arnold mockpp at ewald-arnold dot de
 *  Generated by extending map.h
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Library General Public
 *  License as published by the Free Software Foundation; either
 *  version 2 of the License, or (at your option) any later version.
 *
 *  This 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
 *  Library General Public License for more details.
 *
 *  You should have received a copy of the GNU Library General Public
 *  License along with this library; if not, write to the Free
 *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 *  Send comments and/or bug reports to:
 *                 mi...@in...
 */

#ifndef __ministl_multimap_h__
#define __ministl_multimap_h__

#include <ministl/ministl.h>
#include <ministl/simplevec.h>
#include <ministl/functional>
#include <ministl/pair>

//#include <ministl/bool.h>


namespace ministl
{


template<class kT, class vT, class cT> class multimap;
template<class kT, class vT, class cT> class multimapConstIterator;

template<class kT, class vT, class cT>
class multimapIterator
{
    friend class multimap<kT,vT,cT>;
    friend class multimapConstIterator<kT,vT,cT>;
    typedef multimapIterator<kT,vT,cT> my_type;
    typedef pair<const kT, vT> value_type;
    typedef simplevec<value_type *> rep_type;
    typedef typename rep_type::iterator repiterator;
    repiterator n;

    multimapIterator (repiterator _n)
        : n (_n)
    {}
  public:
    multimapIterator ()
        : n (0)
    {}

    bool operator== (const my_type &it) const
    {
      return it.n == n;
    }

    bool operator!= (const my_type &it) const
    {
      return !(it.n == n);
    }

    my_type operator++ ()
    {
      ++n;
      return *this;
    }

    my_type operator++ (int)
    {
      my_type tmp = *this;
      ++n;
      return tmp;
    }

    my_type operator-- ()
    {
      --n;
      return *this;
    }

    my_type operator-- (int)
    {
      my_type tmp = *this;
      --n;
      return tmp;
    }

    value_type &operator* ()
    {
      return **n;
    }
};

template<class kT, class vT, class cT>
class multimapConstIterator
{
    friend class multimap<kT,vT,cT>;
    typedef multimapConstIterator<kT,vT,cT> my_type;
    typedef pair<const kT, vT> value_type;
    typedef simplevec<value_type *> rep_type;
    typedef typename rep_type::const_iterator repiterator;
    repiterator n;

    multimapConstIterator (repiterator _n)
        : n (_n)
    {}

  public:
    multimapConstIterator ()
        : n (0)
    {}

    multimapConstIterator (const multimapIterator<kT,vT,cT> &i)
        : n (i.n)
    {}

    bool operator== (const my_type &it) const
    {
      return it.n == n;
    }

    bool operator!= (const my_type &it) const
    {
      return !(it.n == n);
    }

    my_type operator++ ()
    {
      ++n;
      return *this;
    }

    my_type operator++ (int)
    {
      my_type tmp = *this;
      ++n;
      return tmp;
    }

    my_type operator-- ()
    {
      --n;
      return *this;
    }

    my_type operator-- (int)
    {
      my_type tmp = *this;
      --n;
      return tmp;
    }

    const value_type &operator* () const
    {
      return **n;
    }
};

template<class keyT, class valT, class cmpT = ministl::less<keyT> >
class multimap
{
  public:

    typedef keyT key_type;
    typedef pair<const keyT, valT> value_type;
    typedef std::size_t size_type;
    typedef simplevec<value_type *> rep_type;
    typedef multimapIterator<keyT, valT, cmpT> iterator;
    typedef multimapConstIterator<keyT, valT, cmpT> const_iterator;
    // XXX typedefs done to work around g++ bug

  private:

    rep_type _ents;
    cmpT _comp;

  public:

    iterator begin ()
    {
      return iterator (_ents.begin());
    }

    const_iterator begin () const
    {
      return const_iterator (_ents.begin());
    }

    iterator end ()
    {
      return iterator (_ents.end());
    }


    const_iterator end () const
    {
      return const_iterator (_ents.end());
    }

    multimap (const cmpT &comp = cmpT())
        : _comp (comp)
    {}

    multimap (const_iterator first, const_iterator last, const cmpT &comp = cmpT())
        : _comp (comp)
    {
      insert (first, last);
    }

    multimap (const multimap<keyT, valT, cmpT> &m)
        : _comp (m._comp)
    {
      insert (m.begin(), m.end());
    }

    multimap<keyT, valT, cmpT> &operator= (const multimap<keyT, valT, cmpT> &m)
    {
      if (this != &m)
      {
        _comp = m._comp;
        erase (begin(), end());
        insert (m.begin(), m.end());
      }
      return *this;
    }

    ~multimap ()
    {
      erase (begin(), end());
    }

    bool empty () const
    {
      return _ents.empty ();
    }

    size_type size () const
    {
      return _ents.size ();
    }

  private:
    // find the iterator position where k should be inserted ...
    bool lookup (const key_type &k, iterator &it);

  public:

    iterator insert (const value_type &v)
    {
      iterator i = end();
      if (size() > 0 && lookup (v.first, i))
        return i;

      i = iterator (_ents.insert (i.n, new value_type(v)));
      return i;
    }

#if 0
    iterator insert (iterator pos, const value_type &v)
  {}
#endif

    void insert (const_iterator first, const_iterator last)
    {
      for ( ; first != last; ++first)
        insert (*first);
    }

    void insert (const value_type *first, const value_type *last)
    {
      for ( ; first != last; ++first)
        insert (*first);
    }

    iterator
    lower_bound(const key_type& x)
    {
      return find(x);
    }

    const_iterator
    lower_bound(const key_type& x) const
    {
      return find(x);
    }

    iterator
    upper_bound(const key_type& x)
    {
      iterator it = find(x);
      if (it == end())
        return it;
      while (*it++ == x)
        /**/;
      return it;
    }

    const_iterator
    upper_bound(const key_type& x) const
    {
      iterator it = find(x);
      if (it == end())
        return it;
      while (*it++ == x)
        /**/;
      return it;
    }

    void erase (iterator pos)
    {
      if (pos != end())
      {
        delete *(pos.n);
        _ents.erase (pos.n);
      }
    }

    size_type erase (const key_type &k)
    {
      iterator i = find (k);
      if (i == end())
        return 0;

      erase (i);
      return 1;
    }

    void erase (iterator first, iterator last)
    {
      for (iterator i = first; i != last; ++i)
        delete *(i.n);
      _ents.erase (first.n, last.n);
    }

    void clear ()
    {
      erase (begin(), end());
    }

    iterator find (const key_type &k)
    {
      if (size() > 0)
      {
        int l = 0;
        int r = size()-1;
        do
        {
          int m = (l+r) >> 1;
          if (_comp (_ents[m]->first, k))
          {
            l = m+1;
          }
          else
          {
            // if (k == _ents[m]->first)
            if (!_comp (k, _ents[m]->first))
              return iterator (_ents.begin()+m);
            r = m-1;
          }
        }
        while (l <= r);
      }
      return end();
    }

    const_iterator find (const key_type &k) const
    {
      if (size() > 0)
      {
        int l = 0;
        int r = size()-1;
        do
        {
          int m = (l+r) >> 1;
          if (_comp (_ents[m]->first, k))
          {
            l = m+1;
          }
          else
          {
            // if (k == _ents[m]->first)
            if (!_comp (k, _ents[m]->first))
              return const_iterator (_ents.begin()+m);
            r = m-1;
          }
        }
        while (l <= r);
      }
      return end();
    }

    size_type count (const key_type &k) const
    {
      return find (k) != end() ? 1 : 0;
    }

    valT &operator[] (const key_type &k)
    {
      iterator i = insert(value_type (k, valT())).first;
      return (*i).second;
    }
};

template<class kT, class vT, class cT>
inline bool
multimap<kT,vT,cT>::lookup (const kT &k, multimapIterator<kT,vT,cT> &it)
{
  int l = 0;
  int r = size();
  while (l < r)
  {
    int m = (l+r) >> 1;
    ministl_assert (m < r);
    if (_comp (_ents[m]->first, k))
    {
      l = m+1;
    }
    else
    {
      // if (k == _ents[m]->first) {
      if (!_comp (k, _ents[m]->first))
      {
        it = multimapIterator<kT,vT,cT> (_ents.begin()+m);
        return true;
      }
      r = m;
    }
  }
  ministl_assert (l == r);
  it = multimapIterator<kT,vT,cT> (_ents.begin()+l);
  return l < (int)size() &&
         // (*it).first == k;
         !_comp ((*it).first, k) && !_comp (k, (*it).first);
}

template<class kT, class vT, class cT>
bool operator== (const multimap<kT,vT,cT> &v1, const multimap<kT,vT,cT> &v2)
{
  if (v1.size() != v2.size())
    return false;
  typename multimap<kT,vT,cT>::const_iterator i1 = v1.begin();
  typename multimap<kT,vT,cT>::const_iterator i2 = v2.begin();
  for ( ;i1 != v1.end() && i2 != v2.end(); ++i1, ++i2)
  {
    if (!(*i1 == *i2))
      return false;
  }
  return true;
}

template<class kT, class vT, class cT>
bool operator< (const multimap<kT,vT,cT> &v1, const multimap<kT,vT,cT> &v2)
{
  long minlast = _min_ (v1.size(), v2.size());
  typename multimap<kT,vT,cT>::const_iterator i1 = v1.begin();
  typename multimap<kT,vT,cT>::const_iterator i2 = v2.begin();
  for ( ;i1 != v1.end() && i2 != v2.end(); ++i1, ++i2)
  {
    if (*i1 < *i2)
      return true;

    if (*i2 < *i1)
      return false;
  }
  return v1.size() < v2.size();
}


} // namespace ministl


#endif // __ministl_multimap_h__

Index: vector
===================================================================
RCS file: /cvsroot/mockpp/mockpp/3party/ministl/vector,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- vector	30 Nov 2005 21:46:34 -0000	1.3
+++ vector	1 Dec 2005 18:15:08 -0000	1.4
@@ -33,6 +33,8 @@
 //#include <ministl/bool.h>
 
 #include <ministl/defalloc.h>
+#include <ministl/raw_iterator.h>
+#include <ministl/reverse_iterator.h>
 
 
 namespace ministl
@@ -43,35 +45,67 @@
 class vector
 {
   public:
-    typedef T* iterator;
-    typedef const T* const_iterator;
+
+    typedef T*          iterator;
+    typedef const T*    const_iterator;
+
+    typedef ministl::reverse_iterator<raw_iterator<T> >        reverse_iterator;
+    typedef ministl::reverse_iterator<raw_iterator<const T> >  const_reverse_iterator;
+
     typedef std::size_t size_type;
 
   private:
+
     size_type _last, _size;
     T *_buf;
 
   public:
+
     const_iterator begin () const
     {
       return &_buf[0];
     }
+
     iterator begin ()
     {
       return &_buf[0];
     }
+
     const_iterator end () const
     {
       return &_buf[_last];
     }
+
     iterator end ()
     {
       return &_buf[_last];
     }
+
+    const_reverse_iterator rbegin () const
+    {
+      return reverse_iterator(end());
+    }
+
+    reverse_iterator rbegin ()
+    {
+      return reverse_iterator(end());
+    }
+
+    const_reverse_iterator rend () const
+    {
+      return reverse_iterator(begin());
+    }
+
+    reverse_iterator rend ()
+    {
+      return reverse_iterator(begin());
+    }
+
     size_type capacity () const
     {
       return _size;
     }
+
     size_type size () const
     {
       return _last;

Index: defalloc.h
===================================================================
RCS file: /cvsroot/mockpp/mockpp/3party/ministl/defalloc.h,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- defalloc.h	30 Nov 2005 21:46:34 -0000	1.3
+++ defalloc.h	1 Dec 2005 18:15:08 -0000	1.4
@@ -13,8 +13,7 @@
  *
  */
 
-//#include <new>
-
+#include <new>
 
 #ifndef MINISTL_DEFALLOC_H
 #define MINISTL_DEFALLOC_H

Index: map.h
===================================================================
RCS file: /cvsroot/mockpp/mockpp/3party/ministl/map.h,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- map.h	29 Nov 2005 23:18:05 -0000	1.2
+++ map.h	1 Dec 2005 18:15:08 -0000	1.3
@@ -23,4 +23,6 @@
  */
 
 #include <ministl/map>
+#include <ministl/multimap>
 using ministl::map;
+using ministl::multimap;

--- NEW FILE: reverse_iterator.h ---
#ifndef __ministl__reverse_iterator_h
#define __ministl__reverse_iterator_h


namespace ministl
{


template<typename ITER>
class reverse_iterator
{
  public:

    typedef  typename ITER::difference_type  difference_type;
    typedef  typename ITER::pointer          pointer;
    typedef  typename ITER::reference        reference;
    typedef  ITER                            iterator_type;
    typedef  typename ITER::value_type       value_type;

    reverse_iterator()
        : current()
    { }

    explicit
    reverse_iterator(iterator_type x)
        : current(x)
    { }

    explicit
    reverse_iterator(pointer x)
        : current(raw_iterator<value_type>(x))
    { }

    reverse_iterator(const reverse_iterator& x)
        : current(x.current)
    { }

    template<typename IT>
    reverse_iterator(const reverse_iterator<IT>& x)
        : current(x.current)
    { }

    iterator_type base() const
    {
      return current;
    }

    reference
    operator*() const
    {
      pointer tmp = current.base()-1;
      return *tmp;
    }

    pointer
    operator->() const
    {
      return &(operator*());
    }

    reverse_iterator&
    operator++()
    {
      --current;
      return *this;
    }

    reverse_iterator
    operator++(int)
    {
      reverse_iterator tmp = *this;
      --current;
      return tmp;
    }

    reverse_iterator&
    operator--()
    {
      ++current;
      return *this;
    }

    reverse_iterator operator--(int)
    {
      reverse_iterator tmp = *this;
      ++current;
      return tmp;
    }

    reverse_iterator
    operator+(difference_type n) const
    {
      return reverse_iterator(current - n);
    }

    reverse_iterator&
    operator+=(difference_type n)
    {
      current -= n;
      return *this;
    }

    reverse_iterator
    operator-(difference_type n) const
    {
      return reverse_iterator(current + n);
    }

    reverse_iterator&
    operator-=(difference_type n)
    {
      current += n;
      return *this;
    }

    reference
    operator[](difference_type n) const
    {
      return *(*this + n);
    }

  private:

    ITER current;
};

template<typename ITER>
inline bool
operator==(const reverse_iterator<ITER>& x,
           const reverse_iterator<ITER>& y)
{
  return x.base() == y.base();
}


template<typename ITER>
inline bool
operator<(const reverse_iterator<ITER>& x,
          const reverse_iterator<ITER>& y)
{
  return y.base() < x.base();
}


template<typename ITER>
inline bool
operator!=(const reverse_iterator<ITER>& x,
           const reverse_iterator<ITER>& y)
{
  return !(x == y);
}


}

#endif // __ministl__reverse_iterator_h



Index: pair
===================================================================
RCS file: /cvsroot/mockpp/mockpp/3party/ministl/pair,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- pair	29 Nov 2005 23:18:05 -0000	1.2
+++ pair	1 Dec 2005 18:15:08 -0000	1.3
@@ -27,14 +27,24 @@
 {
   T1 first;
   T2 second;
+
 #if defined(_AIX) && !defined(__GNUG__)
   // if T? is const xlC goofes about first/second not beeing inited
   pair() : first (T1()), second (T2()) {}
 #else
   pair() {}
 #endif
-  pair(const T1& a, const T2& b) : first(a), second(b) {}}
-;
+  pair(const T1& a, const T2& b)
+    : first(a)
+    , second(b)
+  {}
+
+  template<class U1, class U2>
+  pair(const pair<U1, U2>& p)
+    : first(p.first)
+    , second(p.second)
+  { }
+};
 
 template <class T1, class T2>
 inline bool operator==(const pair<T1, T2>& x, const pair<T1, T2>& y)
@@ -49,7 +59,8 @@
 }
 
 template <class T1, class T2>
-inline pair<T1, T2> make_pair(const T1& x, const T2& y)
+inline pair<T1, T2>
+make_pair(const T1 &x, const T2 &y)
 {
   return pair<T1, T2>(x, y);
 }

--- NEW FILE: raw_iterator.h ---
#ifndef __ministl__raw_iterator_h
#define __ministl__raw_iterator_h

namespace ministl
{

template<typename T>
class raw_iterator
{
  public:

    typedef  std::size_t   difference_type;
    typedef  T*            pointer;
    typedef  const T*      const_pointer;
    typedef  T&            reference;
    typedef  const T&      const_reference;
    typedef  T             value_type;

    raw_iterator ()
        : current()
    { }

    //    explicit
    raw_iterator (pointer x)
        : current(x)
    { }

    raw_iterator (const raw_iterator & x)
        : current(x.current)
    { }

    template<typename IT>
    raw_iterator (const raw_iterator <IT>& x)
        : current(x.base())
    { }

    pointer base() const
    {
      return current;
    }

    pointer
    operator*() const
    {
      return current;
    }

    pointer
    operator->() const
      { return &(operator*()); }

    raw_iterator &
    operator++()
    {
      ++current;
      return *this;
    }

    raw_iterator
    operator++(int)
    {
      raw_iterator  tmp = *this;
      ++current;
      return tmp;
    }

    raw_iterator &
    operator--()
    {
      --current;
      return *this;
    }

    raw_iterator  operator--(int)
    {
      raw_iterator  tmp = *this;
      --current;
      return tmp;
    }

    raw_iterator
    operator+(difference_type n) const
    {
      return raw_iterator (current + n);
    }

    raw_iterator &
    operator+=(difference_type n)
    {
      current += n;
      return *this;
    }

    raw_iterator
    operator-(difference_type n) const
    {
      return raw_iterator (current - n);
    }

    raw_iterator &
    operator-=(difference_type n)
    {
      current -= n;
      return *this;
    }

    reference
    operator[](difference_type n) const
    {
      return *(*this + n);
    }

  private:

    pointer  current;
};


template<typename T>
inline bool
operator==(const raw_iterator <T>& x,
           const raw_iterator <T>& y)
{
  return x.base() == y.base();
}

template<typename T>
inline bool
operator<(const raw_iterator <T>& x,
          const raw_iterator <T>& y)
{
  return y.base() < x.base();
}

template<typename T>
inline bool
operator!=(const raw_iterator <T>& x,
           const raw_iterator <T>& y)
{
  return !(x == y);
}


} // ministl

#endif // __ministl__raw_iterator_h

Index: Makefile.am
===================================================================
RCS file: /cvsroot/mockpp/mockpp/3party/ministl/Makefile.am,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- Makefile.am	29 Nov 2005 23:30:31 -0000	1.2
+++ Makefile.am	1 Dec 2005 18:15:08 -0000	1.3
@@ -16,6 +16,7 @@
 	list \
 	map.h \
 	map \
+	multimap \
 	ministl.h \
 	pair.h \
 	pair \