/* Copyright (c) 1997-2018
   Ewgenij Gawrilow, Michael Joswig (Technische Universitaet Berlin, Germany)
   http://www.polymake.org

   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.
--------------------------------------------------------------------------------
*/

#ifndef POLYMAKE_HASH_SET_
#define POLYMAKE_HASH_SET_

#include <unordered_set>

#include "polymake/internal/hash_iterators.h"

namespace pm {

template <typename Key, typename... TParams>
class hash_set
   : public std::unordered_set<Key, hash_func<Key>, typename hash_table_cmp_adapter<Key, TParams...>::type> {
   typedef std::unordered_set<Key, hash_func<Key>, typename hash_table_cmp_adapter<Key, TParams...>::type> base_t;
public:
   hash_set() {}
   explicit hash_set(size_t start_cap) : base_t(start_cap) {}

   template <typename Iterator>
   hash_set(Iterator first, Iterator last) : base_t(first, last) {}

   template <typename Container,
             typename enabled=typename std::enable_if<isomorphic_to_container_of<Container, Key, allow_conversion>::value>::type>
   explicit hash_set(const Container& src)
      : base_t(src.begin(), src.end()) {}

   // let's make it at least partially compatible with Set

   hash_set& operator+= (const Key& k)
   {
      this->insert(k);
      return *this;
   }

   hash_set& operator+= (const hash_set& other)
   {
      for (const auto& k : other)
         this->insert(k);
      return *this;
   }

   hash_set& operator-= (const Key& k)
   {
      this->erase(k);
      return *this;
   }

   hash_set& operator-= (const hash_set& other)
   {
      for (const auto& k : other)
         this->erase(k);
      return *this;
   }

   hash_set& operator^= (const Key& k)
   {
      auto inserted=this->insert(k);
      if (!inserted.second) this->erase(inserted.first);
      return *this;
   }

   bool exists(const Key& k) const
   {
      return this->find(k) != this->end();
   }

   bool contains(const Key& k) const
   {
      return this->exists(k);
   }

   /// Add to the set, report true if existed formerly.
   bool collect(const Key& k)
   {
      return !this->insert(k).second;
   }
};

template <typename Key, typename... TParams>
struct choose_generic_object_traits< hash_set<Key, TParams...>, false, false >
   : spec_object_traits<is_container> {
   typedef void generic_type;
   typedef hash_set<Key, TParams...> persistent_type;
   typedef is_unordered_set generic_tag;
   static const IO_separator_kind IO_separator=IO_sep_inherit;
};

template <typename Key, typename... TParams>
struct spec_object_traits< hash_set<Key, TParams...> >
   : spec_object_traits<is_container> {
   static const IO_separator_kind IO_separator=IO_sep_inherit;
};

// can't be used as a search key in Set or Map!
template <typename Key, typename... TParams>
struct is_ordered< hash_set<Key, TParams...> >
   : std::false_type { };

} // end namespace pm

namespace polymake {
   using pm::hash_set;
}

#endif // POLYMAKE_HASH_SET_

// Local Variables:
// mode:C++
// c-basic-offset:3
// indent-tabs-mode:nil
// End:
