base_set.h

#pragma once
 
#include "system/object.h"
#include "system/array.h"
#include <system/exceptions.h>
#include "system/collections/iset.h"
#include "system/collections/base_enumerator.h"
#include "system/cycles_detection.h"
#include "system/collections/iequality_comparer.h"
 
namespace System {
namespace Collections {
namespace Generic {
 
template<typename T, typename SET_T>
class ASPOSECPP_SHARED_CLASS BaseSet
    : virtual public System::Object
    , public ICollection<T>
{
    ASPOSE_COLLECTION_POINTER_MODE_CONTROL(T)
 
public:
    using ThisType = System::Collections::Generic::BaseSet<T, SET_T>;
    using ThisPtr = SharedPtr<ThisType>;
    using set_t = SET_T;
    using iterator = typename set_t::iterator;
    using const_iterator = typename set_t::const_iterator;
    RTTI_INFO_TEMPLATE_CLASS(ThisType, System::BaseTypesInfo<System::Object>);
 
protected:
    set_t m_data;
 
public:
    using ValueType = T;
    using BaseType = ICollection<T>;
    using IEnumerablePtr = SharedPtr<IEnumerable<T>>;
    using IEnumeratorPtr = SharedPtr<IEnumerator<T>>;
 
    class Enumerator : public SimpleEnumerator<set_t>
    {
        using ThisType = System::Collections::Generic::BaseSet<T, SET_T>::Enumerator;
 
    public:
        Enumerator(const ThisPtr& set) : SimpleEnumerator<set_t>(set, set->m_data) { }
        RTTI_INFO_TEMPLATE_CLASS(ThisType, System::BaseTypesInfo<System::Object>);
    };
 
protected:
    BaseSet() : ASPOSE_COLLECTION_INIT_ALLOCATOR() {}
 
    BaseSet(int capacity) : ASPOSE_COLLECTION_INIT_ALLOCATOR() 
    {
        if (capacity < 0)
        {
            throw ArgumentOutOfRangeException(u"capacity");
        }
        m_data.reserve(capacity);
    }         
 
    BaseSet(const EqualityComparerHashAdapter<T>& hashAdapter, const EqualityComparerAdapter<T>& comparerAdapter)
        : m_data(8, hashAdapter, comparerAdapter, ASPOSE_COLLECTION_ALLOCATOR)
    {
    }
 
    BaseSet(const ComparerAdapter<T>& comparerAdapter)
        : m_data(comparerAdapter, ASPOSE_COLLECTION_ALLOCATOR)
    {
    }
 
    BaseSet(const SharedPtr<IEnumerable<T>>& items) : ASPOSE_COLLECTION_INIT_ALLOCATOR()
    {
        auto e = items->GetEnumerator();
        while (e->MoveNext())
            m_data.insert(e->get_Current());
    }
 
public:
    const_iterator begin() const noexcept { return m_data.begin(); }
    const_iterator end() const noexcept { return m_data.end(); }
 
    const_iterator cbegin() const noexcept { return m_data.cbegin(); }
    const_iterator cend() const noexcept { return m_data.cend(); }
 
    IEnumeratorPtr GetEnumerator() override
    {
        return MakeObject<Enumerator>(MakeSharedPtr(this));
    }
 
    int get_Count() const override { return ASPOSECPP_CHECKED_CAST(int, m_data.size()); }
 
    void Add(const T& item) override
    {
        TryAdd(item);
    }
    bool TryAdd(const T& item)
    {
        if (m_data.find(item) != m_data.end())
            return false;
 
        m_data.insert(item);
        return true;
    }
    bool Remove(const T& item) override
    {
        auto it = m_data.find(item);
        if (it == m_data.end())
            return false;
 
        m_data.erase(it);
        return true;
    }
    void Clear() override
    {
        m_data.clear();
    }
    bool Contains(const T& item) const override
    {
        return m_data.find(item) != m_data.end();
    }
 
    set_t& data() { return m_data; }
    const set_t& data() const { return m_data; }
    void _add_range(std::initializer_list<T> list)
    {
        std::for_each(list.begin(), list.end(), [this](const T &v) { m_data.insert(v); });
    }
 
    using BaseType::get_Count;
        
    void CopyTo(ArrayPtr<T> arr, int index) override
    {
        if (!arr)
            throw ArgumentNullException();
 
        if (index < 0)
            throw ArgumentOutOfRangeException();
 
        if (index + get_Count() > arr->get_Length())
            throw ArgumentException();
 
        SharedPtr<IEnumerator<T>> e = this->GetEnumerator();
        while (e->MoveNext())
            (*arr)[index++] = e->get_Current();
    }
 
    System::Details::VirtualizedIteratorBase<T>* virtualizeBeginIterator() override
    {
        return new System::Details::NativeIteratorWrapper<T, iterator>(m_data.begin(), m_data.end());
    }
    System::Details::VirtualizedIteratorBase<T>* virtualizeEndIterator() override
    {
        return new System::Details::NativeIteratorWrapper<T, iterator>(m_data.end(), m_data.end());
    }
    System::Details::VirtualizedIteratorBase<T>* virtualizeBeginConstIterator() const override
    {
        return new System::Details::NativeConstIteratorWrapper<T, const_iterator>(m_data.begin(), m_data.end());
    }
    System::Details::VirtualizedIteratorBase<T>* virtualizeEndConstIterator() const override
    {
        return new System::Details::NativeConstIteratorWrapper<T, const_iterator>(m_data.end(), m_data.end());
    }
 
#ifdef __DBG_FOR_EACH_MEMBER
public:
    void DBG_for_each_member(DBG::for_each_member_visitor &visitor) const override
    {
        visitor.add_self(this);
        DBG::for_each_of_Object(this, m_data, visitor);
    }
    const char* DBG_class_name() const override { return "BaseSet<T>"; }
#endif
 
protected:
    ~BaseSet() override {}
#ifdef ASPOSE_GET_SHARED_MEMBERS
    DEFINE_GET_SHARED_MEMBERS(m_data);
#endif
};
 
} // namespace Generic
} // namespace Collections
} // namespace System