ObservableCollection.h

#pragma once
 
#include "INotifyCollectionChanged.h"
#include "List.h"
#include "ObservableObject.h"
#include <initializer_list>
#include <stdexcept>
 
namespace sw
{
    template <typename T>
    class ObservableCollection : public ObservableObject,
                                 public IListT<T>,
                                 public INotifyCollectionChanged,
                                 public IToString<ObservableCollection<T>>
    {
    private:
        List<T> _items;
 
        NotifyCollectionChangedEventHandler _collectionChanged;
 
    public:
        ObservableCollection() = default;
 
        // 删除拷贝构造函数
        ObservableCollection(const ObservableCollection<T> &) = delete;
 
        // 删除移动构造函数
        ObservableCollection(ObservableCollection<T> &&) = delete;
 
        // 删除拷贝赋值运算符
        ObservableCollection<T> &operator=(const ObservableCollection<T> &) = delete;
 
        // 删除移动赋值运算符
        ObservableCollection<T> &operator=(ObservableCollection<T> &&) = delete;
 
        ObservableCollection(std::initializer_list<T> list)
            : _items(list)
        {
        }
 
        explicit ObservableCollection(int capacity)
            : _items(capacity)
        {
        }
 
    protected:
        virtual NotifyCollectionChangedEventHandler &GetCollectionChangedEventDelegate() override final
        {
            return _collectionChanged;
        }
 
        virtual void OnCollectionChanged(NotifyCollectionChangedEventArgs &args)
        {
            if (_collectionChanged) {
                _collectionChanged(*this, args);
            }
        }
 
    public:
        int Capacity() const noexcept
        {
            return _items.Capacity();
        }
 
        void Reserve(int newCapacity)
        {
            _items.Reserve(newCapacity);
        }
 
        void Refresh()
        {
            NotifyCollectionChangedEventArgs args{};
            args.action = NotifyCollectionChangedAction::Reset;
            args.list   = this;
            OnCollectionChanged(args);
        }
 
        void Clear()
        {
            if (_items.Count() == 0) {
                return;
            }
 
            _items.Clear();
 
            NotifyCollectionChangedEventArgs args{};
            args.action = NotifyCollectionChangedAction::Reset;
            args.list   = this;
            OnCollectionChanged(args);
        }
 
        void Add(const T &value)
        {
            int index = _items.Count();
            _items.Add(value);
 
            NotifyCollectionChangedEventArgs args{};
            args.action = NotifyCollectionChangedAction::Add;
            args.list   = this;
            args.index  = index;
            OnCollectionChanged(args);
        }
 
        void Add(T &&value)
        {
            int index = _items.Count();
            _items.Add(std::move(value));
 
            NotifyCollectionChangedEventArgs args{};
            args.action = NotifyCollectionChangedAction::Add;
            args.list   = this;
            args.index  = index;
            OnCollectionChanged(args);
        }
 
        void RemoveAt(int index)
        {
            _items.RemoveAt(index);
 
            NotifyCollectionChangedEventArgs args{};
            args.action = NotifyCollectionChangedAction::Remove;
            args.list   = this;
            args.index  = index;
            OnCollectionChanged(args);
        }
 
        void Insert(int index, const T &value)
        {
            _items.Insert(index, value);
 
            NotifyCollectionChangedEventArgs args{};
            args.action = NotifyCollectionChangedAction::Add;
            args.list   = this;
            args.index  = index;
            OnCollectionChanged(args);
        }
 
        void Insert(int index, T &&value)
        {
            _items.Insert(index, std::move(value));
 
            NotifyCollectionChangedEventArgs args{};
            args.action = NotifyCollectionChangedAction::Add;
            args.list   = this;
            args.index  = index;
            OnCollectionChanged(args);
        }
 
        void Move(int oldIndex, int newIndex)
        {
            int count = _items.Count();
            if (oldIndex < 0 || oldIndex >= count || newIndex < 0 || newIndex >= count) {
                throw std::out_of_range("Index out of range in ObservableCollection::Move.");
            }
 
            if (oldIndex == newIndex) {
                return;
            }
 
            auto &items = _items.GetInternalVector();
 
            T value = std::move(items[static_cast<size_t>(oldIndex)]);
            items.erase(items.begin() + static_cast<size_t>(oldIndex));
            items.insert(items.begin() + static_cast<size_t>(newIndex), std::move(value));
 
            NotifyCollectionChangedEventArgs args{};
            args.action   = NotifyCollectionChangedAction::Move;
            args.list     = this;
            args.index    = newIndex;
            args.oldIndex = oldIndex;
            OnCollectionChanged(args);
        }
 
        int IndexOf(const T &value) const
        {
            return _items.IndexOf(value);
        }
 
        int LastIndexOf(const T &value) const
        {
            return _items.LastIndexOf(value);
        }
 
        bool Contains(const T &value) const
        {
            return _items.Contains(value);
        }
 
        bool Remove(const T &value)
        {
            int index = _items.IndexOf(value);
            if (index == -1) {
                return false;
            }
 
            _items.RemoveAt(index);
 
            NotifyCollectionChangedEventArgs args{};
            args.action = NotifyCollectionChangedAction::Remove;
            args.list   = this;
            args.index  = index;
            OnCollectionChanged(args);
 
            return true;
        }
 
        std::wstring ToString() const
        {
            return _items.ToString();
        }
 
        std::vector<T> &GetInternalVector() noexcept
        {
            return _items.GetInternalVector();
        }
 
        const std::vector<T> &GetInternalVector() const noexcept
        {
            return _items.GetInternalVector();
        }
 
    public:
        virtual int Count() const noexcept override final
        {
            return _items.Count();
        }
 
        virtual T &GetAt(int index) override final
        {
            return _items.GetAt(index);
        }
 
        virtual const T &GetAt(int index) const override final
        {
            return _items.GetAt(index);
        }
 
        virtual void SetAt(int index, const T &value) override final
        {
            _items.SetAt(index, value);
 
            NotifyCollectionChangedEventArgs args{};
            args.action = NotifyCollectionChangedAction::Replace;
            args.list   = this;
            args.index  = index;
            OnCollectionChanged(args);
        }
 
        virtual void SetAt(int index, T &&value) override final
        {
            _items.SetAt(index, std::move(value));
 
            NotifyCollectionChangedEventArgs args{};
            args.action = NotifyCollectionChangedAction::Replace;
            args.list   = this;
            args.index  = index;
            OnCollectionChanged(args);
        }
    };
}