sorted_set.h

#pragma once
 
#include "system/collections/base_set.h"
 
#include <set>
 
namespace System {
namespace Collections {
namespace Generic {
 
template<typename T> class SortedSet;
 
template<typename T>
class ASPOSECPP_SHARED_CLASS SortedSetPtr : public SharedPtr<SortedSet<T>>
{
public:
    SortedSetPtr() {}
    SortedSetPtr(const SharedPtr<SortedSet<T>>& obj) : SharedPtr<SortedSet<T>>(obj) { }
};
 
template<typename T>
class ASPOSECPP_SHARED_CLASS SortedSet : public BaseSet<T, std::set<T, ComparerAdapter<T>, typename System::Details::CollectionHelpers::ContainerPointerMode<T>::allocator_type>>
{
public:
    using ThisType = System::Collections::Generic::SortedSet<T>;
    using BaseType = BaseSet<T, std::set<T, ComparerAdapter<T>, typename System::Details::CollectionHelpers::ContainerPointerMode<T>::allocator_type>>;
    using ThisPtr = SharedPtr<ThisType>;
 
private:
    RTTI_INFO_TEMPLATE_CLASS(ThisType, System::BaseTypesInfo<System::Object>);
 
public:
    SortedSet() : BaseType() {}
 
    SortedSet(int capacity) : BaseType(capacity) {}
 
    SortedSet(const SharedPtr<IComparer<T>>& comparer)
        : BaseType(ComparerAdapter<T>(comparer))
    {
    }
 
    SortedSet(const SharedPtr<IEnumerable<T>>& items) : BaseType(items) {}
 
    T get_Max() const
    {
        if (BaseType::m_data.empty())
            throw ArgumentOutOfRangeException(u"SortedSet is empty");
        return *BaseType::m_data.rbegin();
    }
 
#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 "SortedSet<T>"; }
#endif
 
protected:
    ~SortedSet() override {}
#ifdef ASPOSE_GET_SHARED_MEMBERS
    DEFINE_GET_SHARED_MEMBERS(BaseType::m_data);
#endif
};
 
} // namespace Generic
} // namespace Collections
} // namespace System