collection_base.h

#pragma once
 
#include <system/scope_guard.h>
#include <system/exceptions.h>
#include <system/details/pointer_collection_helpers.h>
#include <system/collections/list.h>
#include <system/collections/ienumerator.h>
#include <system/collections/ienumerable.h>
#include <system/array.h>
#include <cstdint>
 
 
namespace System {
 
namespace Collections {
 
template<typename T>
class CollectionBase : public virtual Generic::IEnumerable<T>
{
    typedef CollectionBase<T> ThisType;
    typedef Generic::IEnumerable<T> BaseType;
 
    typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo;
    RTTI_INFO_TEMPLATE_CLASS(ThisType, ThisTypeBaseTypesInfo);
 
public:
 
    using Ptr = SharedPtr<CollectionBase>;
 
    class ASPOSECPP_SHARED_CLASS ListImpl : public System::Object
    {
        typedef ListImpl ThisType;
        typedef System::Object BaseType;
 
        typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo;
        RTTI_INFO_TEMPLATE_CLASS(ThisType, ThisTypeBaseTypesInfo);
 
    public:
 
        using Ptr = SharedPtr<ListImpl>;
 
    private:
        template<typename FT0> friend class CollectionBase;
 
    public:
 
        ASPOSECPP_SHARED_API void CopyTo(const ArrayPtr<T>& array, int32_t index)
        {
            _base->get_InnerList()->CopyTo(array, index);
        }
 
        ASPOSECPP_SHARED_API T idx_get(int32_t index)
        {
            if (index < 0 || index >= _base->get_Count())
            {
                throw ArgumentOutOfRangeException(u"index");
            }
 
            return _base->get_InnerList()->idx_get(index);
        }
 
        ASPOSECPP_SHARED_API void idx_set(int32_t index, T value)
        {
            if (index < 0 || index >= _base->get_Count())
            {
                throw ArgumentOutOfRangeException(u"index");
            }
 
            _base->OnValidate(value);
            T temp = _base->get_InnerList()->idx_get(index);
            _base->OnSet(index, temp, value);
            _base->get_InnerList()->idx_set(index, value);
            try
            {
                _base->OnSetComplete(index, temp, value);
            }
            catch (...)
            {
                _base->get_InnerList()->idx_set(index, temp);
                throw;
            }
 
        }
 
        ASPOSECPP_SHARED_API bool Contains(const T& value)
        {
            return _base->get_InnerList()->Contains(value);
        }
 
        ASPOSECPP_SHARED_API int32_t Add(const T& value)
        {
            _base->OnValidate(value);
            _base->OnInsert(_base->get_InnerList()->get_Count(), value);
            _base->get_InnerList()->Add(value);
            int32_t index = _base->get_InnerList()->get_Count() - 1;
            try
            {
                _base->OnInsertComplete(index, value);
            }
            catch (...)
            {
                _base->get_InnerList()->RemoveAt(index);
                throw;
            }
 
            return index;
        }
 
        ASPOSECPP_SHARED_API void Remove(const T& value)
        {
            _base->OnValidate(value);
            int32_t index = _base->get_InnerList()->IndexOf(value);
            if (index < 0)
            {
                throw ArgumentException();
            }
            _base->OnRemove(index, value);
            _base->get_InnerList()->RemoveAt(index);
            try
            {
                _base->OnRemoveComplete(index, value);
            }
            catch (...)
            {
                _base->get_InnerList()->Insert(index, value);
                throw;
            }
 
        }
 
        ASPOSECPP_SHARED_API int32_t IndexOf(const T& value)
        {
            return _base->get_InnerList()->IndexOf(value);
        }
 
        ASPOSECPP_SHARED_API void Insert(int32_t index, const T& value)
        {
            if (index < 0 || index > _base->get_Count())
            {
                throw ArgumentOutOfRangeException(u"index");
            }
 
            _base->OnValidate(value);
            _base->OnInsert(index, value);
            _base->get_InnerList()->Insert(index, value);
            try
            {
                _base->OnInsertComplete(index, value);
            }
            catch (...)
            {
                _base->get_InnerList()->RemoveAt(index);
                throw;
            }
 
        }
 
 
    protected:
 
        virtual ASPOSECPP_SHARED_API ~ListImpl()
        {
        }
 
        ListImpl(const SharedPtr<CollectionBase<T>>& base_)
            : _base(base_.get())
        {
        }
 
        MEMBER_FUNCTION_MAKE_OBJECT(ListImpl, CODEPORTING_ARGS(const SharedPtr<CollectionBase<T>>& base_), CODEPORTING_ARGS(base_));
 
        #ifdef ASPOSE_GET_SHARED_MEMBERS
        void GetSharedMembers(System::Object::shared_members_type& result) const override
        {
            System::Object::GetSharedMembers(result);
 
            result.Add("System::Collections::CollectionBase::ListImpl::_base", this->_base);
        }
        #endif
 
        #ifdef __DBG_FOR_EACH_MEMBER
    public:
        ASPOSECPP_SHARED_API void DBG_for_each_member(DBG::for_each_member_visitor& visitor) const override
        {
            System::Object::DBG_for_each_member(visitor);
 
            visitor.add_self(this);
 
            visitor.add_member(this, _base, "_base");
        }
        const char* DBG_class_name() const override { return "ListImpl"; }
    #endif
 
    private:
 
        CollectionBase<T>* const _base;
 
    };
 
 
public:
 
    int32_t get_Capacity()
    {
        return get_InnerList()->get_Capacity();
    }
 
    void set_Capacity(int32_t value)
    {
        get_InnerList()->set_Capacity(value);
    }
 
    int32_t get_Count()
    {
        return _list->get_Count();
    }
 
    void Clear()
    {
        OnClear();
        get_InnerList()->Clear();
        OnClearComplete();
    }
 
    void RemoveAt(int32_t index)
    {
        if (index < 0 || index >= get_Count())
        {
            throw ArgumentOutOfRangeException(u"index");
        }
 
        T temp = get_InnerList()->idx_get(index);
        OnValidate(temp);
        OnRemove(index, temp);
        get_InnerList()->RemoveAt(index);
        try
        {
            OnRemoveComplete(index, temp);
        }
        catch (...)
        {
            get_InnerList()->Insert(index, temp);
            throw;
        }
 
    }
 
    SharedPtr<Generic::IEnumerator<T>> GetEnumerator() override
    {
        return get_InnerList()->GetEnumerator();
    }
 
    void SetTemplateWeakPtr(uint32_t argument) override
    {
        switch (argument)
        {
            case 0:
                System::Details::CollectionHelpers::SetWeakPointer(0, _list);
                System::Details::CollectionHelpers::SetWeakPointer(0, _impl);
                break;
 
        }
    }
 
protected:
 
    SharedPtr<System::Collections::Generic::List<T>> get_InnerList()
    {
        return _list;
    }
 
    SharedPtr<ListImpl> get_List()
    {
        return _impl;
    }
 
    CollectionBase()
    {
        System::Details::ThisProtector __local_self_ref(this);
 
        _list = System::MakeObject<System::Collections::Generic::List<T>>();
        _impl = ListImpl::MakeObject(MakeSharedPtr(this));
    }
 
    CollectionBase(int32_t capacity)
    {
        System::Details::ThisProtector __local_self_ref(this);
 
        _list = System::MakeObject<System::Collections::Generic::List<T>>(capacity);
        _impl = ListImpl::MakeObject(MakeSharedPtr(this));
    }
 
    virtual void OnSet(int32_t index, const T& oldValue, const T& newValue)
    {
        ASPOSE_UNUSED(index);
        ASPOSE_UNUSED(oldValue);
        ASPOSE_UNUSED(newValue);
    }
 
    virtual void OnInsert(int32_t index, const T& value)
    {
        ASPOSE_UNUSED(index);
        ASPOSE_UNUSED(value);
    }
 
    virtual void OnClear()
    {
    }
 
    virtual void OnRemove(int32_t index, const T& value)
    {
        ASPOSE_UNUSED(index);
        ASPOSE_UNUSED(value);
    }
 
    virtual void OnValidate(const T& value)
    {
        if (value == nullptr)
        {
            throw ArgumentNullException(u"value");
        }
    }
 
    virtual void OnSetComplete(int32_t index, const T& oldValue, const T& newValue)
    {
        ASPOSE_UNUSED(index);
        ASPOSE_UNUSED(oldValue);
        ASPOSE_UNUSED(newValue);
    }
 
    virtual void OnInsertComplete(int32_t index, const T& value)
    {
        ASPOSE_UNUSED(index);
        ASPOSE_UNUSED(value);
    }
 
    virtual void OnClearComplete()
    {
    }
 
    virtual void OnRemoveComplete(int32_t index, const T& value)
    {
        ASPOSE_UNUSED(index);
        ASPOSE_UNUSED(value);
    }
 
    virtual ~CollectionBase()
    {
    }
 
    #ifdef ASPOSE_GET_SHARED_MEMBERS
    void GetSharedMembers(System::Object::shared_members_type& result) const override
    {
        System::Object::GetSharedMembers(result);
 
        result.Add("System::Collections::CollectionBase::_list", this->_list);
        result.Add("System::Collections::CollectionBase::_impl", this->_impl);
    }
    #endif
 
    #ifdef __DBG_FOR_EACH_MEMBER
public:
    ASPOSECPP_SHARED_API void DBG_for_each_member(DBG::for_each_member_visitor& visitor) const override
    {
        System::Object::DBG_for_each_member(visitor);
 
        visitor.add_self(this);
 
        visitor.add_member(this, _list, "_list");
        visitor.add_member(this, _impl, "_impl");
    }
    const char* DBG_class_name() const override { return "CollectionBase"; }
    #endif
private:
 
    SharedPtr<System::Collections::Generic::List<T>> _list;
    SharedPtr<ListImpl> _impl;
 
};
 
} // namespace Collections
} // namespace System