clear_allocator.cc test for map.

[Dhruv Matani <dhruvbird at gmx dot net>]

Hello,
	Here is the similar file for std::map. Multimap is the same, so,
I guess it's not required.



-- 
        -Dhruv Matani.
http://www.geocities.com/dhruvbird/

Proud to be a Vegetarian.
http://www.vegetarianstarterkit.com/
http://www.vegkids.com/vegkids/index.html

Attachment: ChangeLog
Description: Text document

// Copyright (C) 2004 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This 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, 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 General Public License for more details.
 
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING.  If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.

#include <map>
#include <memory>

using namespace std;

template<typename T>
  class clear_alloc : public std::allocator<T> 
  {
    typedef typename std::allocator<T> Base_type;

  public:
    template <typename T1>
      struct rebind 
      { typedef clear_alloc<T1> other; };

    virtual void clear()
    { }

    clear_alloc()
    { }
    
    clear_alloc(clear_alloc const& _wa)
    { }
    
    template<typename T1>
      clear_alloc(clear_alloc<T1> const& _wa)
      { }

    virtual ~clear_alloc()
    { this->clear(); }

    T* allocate(typename Base_type::size_type n, const void *hint = 0)
    {
      this->clear();
      return Base_type::allocate(n, hint);
    }
    
    void deallocate(T *ptr, typename Base_type::size_type n)
    {
      this->clear();
      Base_type::deallocate(ptr, n);
    }
  };

template<typename Container>
  void Check_Container()
  {
    Container* pic = new Container;
    int x = 230;
    
    while (x--)
      {
	pic->insert(std::make_pair(x, x));
      }
    
    pic->get_allocator();
    
    // The following has led to infinite recursions or cores.
    pic->clear();

    delete pic;
  }


int main()
{
  Check_Container<std::map<int, int, std::less<int>, clear_alloc<std::pair<int, int> > > >();
  return 0;
}