hashset.h

#pragma once
 
#include "system/collections/iequality_comparer.h"
#include "system/collections/base_set.h"
 
#include <unordered_set>
 
namespace System {
namespace Collections {
namespace Generic {
 
template<typename T> class HashSet;
 
template<typename T>
class ASPOSECPP_SHARED_CLASS HashSetPtr : public SharedPtr<HashSet<T> >
{
public:
    HashSetPtr() {}
    HashSetPtr(const SharedPtr<HashSet<T> >& obj) : SharedPtr<HashSet<T> >(obj) { }
};
 
template<typename T>
class ASPOSECPP_SHARED_CLASS HashSet : public BaseSet<T, std::unordered_set<T, EqualityComparerHashAdapter<T>, EqualityComparerAdapter<T>, typename System::Details::CollectionHelpers::ContainerPointerMode<T>::allocator_type>>
{
public:
    using ThisType = System::Collections::Generic::HashSet<T>;
    using BaseType = BaseSet<T, std::unordered_set<T, EqualityComparerHashAdapter<T>, EqualityComparerAdapter<T>, typename System::Details::CollectionHelpers::ContainerPointerMode<T>::allocator_type>>;
    using ThisPtr = SharedPtr<ThisType>;
 
private:
    RTTI_INFO_TEMPLATE_CLASS(ThisType, System::BaseTypesInfo<System::Object>)
 
public:
    HashSet() : BaseType() {}
 
    HashSet(int capacity) : BaseType(capacity) {}
 
    HashSet(const SharedPtr<IEqualityComparer<T>>& comparer)
        : BaseType(EqualityComparerHashAdapter<T>(comparer), EqualityComparerAdapter<T>(comparer))
    {
    }
 
    HashSet(const SharedPtr<IEnumerable<T>>& items) : BaseType(items) {}
 
#ifdef __DBG_FOR_EACH_MEMBER
public:
    void DBG_for_each_member(DBG::for_each_member_visitor &visitor) const override
    {
        BaseType::DBG_for_each_member(visitor);
        visitor.add_self(this);
    }
    const char* DBG_class_name() const override { return "HashSet<T>"; }
#endif
 
protected:
    ~HashSet() override {}
#ifdef ASPOSE_GET_SHARED_MEMBERS
    DEFINE_GET_SHARED_MEMBERS(BaseType::m_data);
#endif
};
 
} // namespace Generic
} // namespace Collections
} // namespace System