/* Copyright (c) 1997-2009
   Ewgenij Gawrilow, Michael Joswig (Technische Universitaet Darmstadt, Germany)
   http://www.polymake.de

   This program 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: http://www.gnu.org/licenses/gpl.txt.

   This program 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.
--------------------------------------------------------------------------------
   $Project: polymake $$Id: assoc.h 9298 2009-09-02 23:10:56Z gawrilow $
*/

#ifndef _POLYMAKE_PERL_ASSOC_H
#define _POLYMAKE_PERL_ASSOC_H

#ifndef _POLYMAKE_ITERATORS_H
#  include <iterators.h>
#endif
#ifndef _POLYMAKE_VALUE_H
#  include <perl/Value.h>
#endif

namespace pm { namespace perl {

   template <typename Container, bool _simple=check_iterator_feature<typename container_traits<Container>::iterator, end_sensitive>::value>
   class element_finder_helper {
   protected:
      typename container_traits<Container>::iterator pos;
   public:
      element_finder_helper(Container&, typename container_traits<Container>::iterator where)
	 : pos(where) {}
   };

   template <typename Container>
   class element_finder_helper<Container, false> {
   protected:
      typename Entire<Container>::iterator pos;
   public:
      element_finder_helper(Container& c, typename container_traits<Container>::iterator where)
	 : pos(entire(c)) { pos=where; }
   };

   template <typename Container>
   class element_finder : protected element_finder_helper<const Container>,
			  public MaybeUndefined< element_finder<Container> > {
   public:
      template <typename Key>
      element_finder(const Container& c, const Key& key)
	 : element_finder_helper<const Container>(c, c.find(key)) {}

      bool defined() const { return !this->pos.at_end(); }

      typename attrib<typename iterator_traits<typename Container::const_iterator>::value_type::second_type>::plus_const_ref
      operator* () const { return this->pos->second; }
   };

   template <typename Container, typename Key> inline
   element_finder<Container> find_element(const Container& c, const Key& key)
   {
      return element_finder<Container>(c,key);
   }

   template <typename Container>
   class delayed_eraser : protected element_finder_helper<Container>,
			  public MaybeUndefined< delayed_eraser<Container> > {
      Container& c;
   public:
      template <typename Key>
      delayed_eraser(Container& c_arg, const Key& key)
	 : element_finder_helper<Container>(c_arg, c_arg.find(key)), c(c_arg) {}

      bool defined() const { return !this->pos.at_end(); }

      typename attrib<typename iterator_traits<typename Container::const_iterator>::value_type::second_type>::plus_const_ref
      operator* () const { return this->pos->second; }

      ~delayed_eraser()
      {
	 if (defined()) c.erase(this->pos);
      }
   };

   template <typename Container, typename Key> inline
   delayed_eraser<Container> delayed_erase(Container& c, const Key& key)
   {
      return delayed_eraser<Container>(c,key);
   }

} }

#endif // _POLYMAKE_PERL_ASSOC_H

// Local Variables:
// mode:C++
// End:
