Collection.h

Go to the documentation of this file.

 
#pragma once
 
#pragma warning(error: 4239)
 
#include <vector>
#include <stdexcept>
#include <algorithm>
 
#include "Iterator.h"
 
namespace Gorgon { 
    namespace Containers {
 
        template <class T_>
        class Collection {
    
            template<class P_>
            struct sorter {
                sorter(const P_ &predicate) : predicate(predicate) {}
 
                bool operator ()(const T_ *left, const T_*right) const {
                    if(left==NULL || right==NULL)
                        return false;
 
                    return predicate(*left,*right);
                }
 
                const P_ &predicate;
            };
 
            template<class O_, class C_>
            class Iterator_ : public Containers::Iterator<Iterator_<O_, C_>, O_> {
                friend class Containers::Iterator<Iterator_, O_>;
                friend class Collection;
 
            public:
                Iterator_() : col(NULL), offset(-1) {
                }
                Iterator_(const Iterator_ &it) : col(it.col), offset(it.offset) {
                }
 
                void Remove() {
                    col->Remove(offset);
                    offset--;
                }
 
                void Delete() {
                    col->Delete(offset);
                    offset--;
                }
 
            protected:
                Iterator_(C_ &c, long offset=0) : col(&c), offset(offset) {
                }
 
            protected:
                O_ &current() const {
                    if(!isvalid())
                        throw std::out_of_range("Iterator is not valid.");
 
                    return *col->list[offset];
                }
 
                bool isvalid() const {
                    return offset>=0 && offset<(col->GetCount());
                }
 
                bool isinrange() const {
                    return offset>=0 || offset<(col->GetCount());
                }
 
                bool moveby(long amount) {
                    //sanity check
                    if(amount==0)  return isvalid();
 
                    offset+=amount;
 
                    return isvalid();
                }
 
                bool compare(const Iterator_ &it) const {
                    if(!it.isvalid() && !isvalid()) return true;
                    return it.offset==offset;
                }
 
                void set(const Iterator_ &it) {
                    col=it.col;
                    offset=it.offset;
                }
 
                long distance(const Iterator_ &it) const {
                    return it.offset-offset;
                }
 
                bool isbefore(const Iterator_ &it) const {
                    return offset<it.offset;
                }
 
            public:
 
                Iterator_ &operator =(const Iterator_ &iterator) {
                    set(iterator);
 
                    return *this;
                }
 
            private:
                C_ *col;
                long offset;
            };
 
        public:
            typedef Iterator_<T_, Collection> Iterator;
 
            class ConstIterator : public Iterator_<T_,const Collection> {
                friend class Collection;
            public:
                ConstIterator(const Iterator &it) {
                    this->col=it.col;
                    this->offset=it.offset;
                }
 
            private:
                ConstIterator(const Collection &c, long offset=0) : Iterator_<T_,const Collection>(c, offset) {
                }
 
                void Remove() {}
                void Delete() {}
            };
 
            class Adder {
                friend class Collection;
                Adder(Collection &col) : col(col) { }
                Collection &col;
            public:
 
                Adder &operator ,(T_ &item) {
                    col.Add(item);
                    return *this;
                }
 
                Adder &operator ,(T_ *item) {
                    col.Add(item);
                    return *this;
                }
 
                Adder &operator =(Adder &) =delete;
            };
 
        public:
            Collection() = default;
 
            template<typename... Args_>
            Collection(T_ &t, Args_ &... args) {
                list.reserve(sizeof...(Args_)+1);
                Add(t, args...);
            }
 
            template<typename... Args_>
            Collection(T_ *t, Args_ *... args) {
                list.reserve(sizeof...(Args_)+1);
                Add(t, args...);
            }
 
            Collection(const Collection &) = delete;
 
            Collection &operator =(const Collection &) = delete;
 
            Collection(Collection &&col) : list(std::move(col.list)) { 
            }
 
            Collection &operator=(Collection &&col) {
                Collapse();
                list.swap(col.list);
 
                return *this;
            }
 
            void Swap(Collection &col) {
                list.swap(col.list);
            }
 
            Collection Duplicate() const {
                Collection c;
                c.list=list;
 
                return c;
            }
 
            long GetCount() const {
                return (long)list.size();
            }
 
            long GetSize() const {
                return (long)list.size();
            }
 
 
            bool Add(T_* Data) {
                if(std::find(list.begin(), list.end(), Data)==list.end()) {
                    list.push_back(Data);
                    
                    return true;
                }
                
                return false;
            }
 
            bool Add(T_& data) {
                return Add(&data);
            }
 
            bool Push(T_* Data) {
                return Add(Data);
            }
 
            bool Push(T_& data) {
                return Add(data);
            }
            
            T_ &Pop() {
                if(!GetCount()) {
                    throw std::out_of_range("No items in the collection");
                }
                
                T_ &ret = Get(GetCount()-1);
                Remove(GetCount()-1);
                
                return ret;
            }
 
            template<typename... Args_>
            int Add(T_* Data, Args_ *... args) {
                int ret = Add(Data) ? 1 : 0;
                ret += Add(args...);
                
                return ret;
            }
 
            template<typename... Args_>
            int Add(T_& data, Args_ &... args) {
                int ret = Add(&data) ? 1 : 0;
                ret += Add(args...);
                
                return ret;
            }
 
            template<typename... Args_>
            T_ &AddNew(Args_&&... args) {
                auto t = new T_(std::forward<Args_>(args)...);
                Add(t);
 
                return *t;
            }
 
            bool Insert(T_* data, long before) {
                if(std::find(list.begin(), list.end(), data)!=list.end()) return false;
                
                if(before==-1)
                    before=(long)list.size();
 
                if(before<0 || before>(long)list.size())
                    throw std::out_of_range("Invalid location");
 
                if(before==list.size()) {
                    return Add(data);
                }
 
                list.resize(list.size()+1);
                
                for(long i=(long)list.size()-1;i>before;i--)
                    list[i]=list[i-1];
 
                list[before]=data;
                
                return true;
            }
 
            bool Insert(T_& data, long before) {
                return Insert(&data, before);
            }
 
            bool Insert(T_* data, const T_ &before) {
                return Insert(data, FindLocation(before));
            }
 
            bool Insert(T_& data, const T_ &before) {
                return Insert(&data, FindLocation(before));
            }
 
            template<typename... Args_>
            T_ &InsertNew(const T_ &before, Args_... args) {
                auto t=new T_(args...);
                Insert(t, before);
 
                return *t;
            }
 
            template<typename... Args_>
            T_ &InsertNew(long before, Args_... args) {
                auto t=new T_(args...);
                Insert(t, before);
 
                return *t;
            }
 
            void MoveBefore(long index, long before) {
                if(before == -1)
                    before = list.size();
                if(index>=list.size())
                    throw std::out_of_range("Invalid location");
                if(before>list.size())
                    throw std::out_of_range("Invalid location");
 
                if(index==before)
                    return;
 
                if(index>before) {
                    T_ *t=list[index];
                    for(long i=index; i>before; i--)
                        list[i]=list[i-1];
 
                    list[before]=t;
                }
                else if(before==list.size()) {
                    T_ *t=list[index];
 
                    for(long i=index; i<list.size()-1; i++)
                        list[i]=list[i+1];
 
                    list[list.size()-1]=t;
                }
                else {
                    T_ *t=list[index];
                    for(long i=index; i<before; i++)
                        list[i]=list[i+1];
 
                    list[before]=t;
                }
            }
 
            void MoveBefore(long index, const T_ &before) {
                MoveBefore(index, FindLocation(before));
            }
 
            void MoveBefore(const T_ &index, long before) {
                MoveBefore(FindLocation(index), before);
            }
 
            void MoveBefore(const T_ &index, const T_ &before) {
                MoveBefore(FindLocation(index), FindLocation(before));
            }
 
            Adder operator +=(T_* Data) {
                Add(Data);
 
                return Adder(*this);
            }
 
            Adder operator +=(T_& data) {
                Add(&data);
 
                return Adder(*this);
            }
 
            void Remove(long index) {
                list.erase(list.begin()+index);
            }
 
            void Remove(const T_ *item) {
                auto l=FindLocation(item);
                if(l==-1) return;
                
                Remove(l);
            }
 
            void Remove(const T_ &data) {
                Remove(&data);
            }
 
            void Remove(ConstIterator &it) {
                auto tmp = it;
                ++it;
                list.erase(list.begin() + tmp.offset);
            }
 
            void Remove(Iterator &it) {
                auto tmp = it;
                ++it;
                list.erase(list.begin() + tmp.offset);
            }
 
            void Delete(long index) {
                delete list[index];
 
                list.erase(list.begin()+index);
            }
 
            void Delete(const T_ *item) {
                auto l=FindLocation(item);
                if(l==-1) {
                    delete item;
                    return;
                }
                Delete(l);
            }
 
            void Delete(T_& data) {
                Delete(&data);
            }
 
            void Delete(ConstIterator &it) {
                auto tmp = it;
                ++it;
                delete tmp.CurrentPtr();
                list.erase(list.begin() + tmp.offset);
            }
 
            void Delete(Iterator &it) {
                auto tmp = it;
                ++it;
                delete tmp.CurrentPtr();
                list.erase(list.begin() + tmp.offset);
            }
 
            Iterator Find(const T_ *item) {
                return Iterator(*this, FindLocation(item));
            }
 
            Iterator Find(const T_ &item) {
                return Iterator(*this, FindLocation(item));;
            }
 
            ConstIterator Find(const T_ *item) const {
                return ConstIterator(*this, FindLocation(item));
            }
 
            ConstIterator Find(const T_ &item) const {
                return ConstIterator(*this, FindLocation(item));
            }
 
            long FindLocation(const T_ *item) const {
                auto it=find(list.begin(), list.end(), item);
 
                if(it==list.end())
                    return -1;
                else
                    return long(it-list.begin());
            }
 
            long FindLocation(const T_ &item) const {
                return FindLocation(&item);
            }
 
            template<class P_>
            void Sort(P_ predicate=P_()) {
                std::sort(list.begin(), list.end(), sorter<P_>(predicate));
            }
 
            void Sort() {
                std::sort(list.begin(), list.end(), sorter<std::less<T_>>(std::less<T_>()));
            }
 
            T_ &Get(long index) {
                T_ *r=get_(index);
 
                if(r==NULL)
                    throw std::out_of_range("Index out of range");
 
                return *r;
            }
 
            T_ &Get(long index) const {
                const T_ *r=get_(index);
 
                if(r==NULL)
                    throw std::out_of_range("Index out of range");
 
                return *r;
            }
 
            T_& operator [] (long index) {
                return *list[index];
            }
 
            T_& operator [] (long index) const  {
                return *list[index];
            }
 
            Iterator begin() {
                return Iterator(*this, 0);
            }
 
            Iterator end() {
                return Iterator(*this, (long)list.size());
            }
 
            Iterator First() {
                return Iterator(*this, 0);
            }
 
            Iterator Last() {
                return Iterator(*this, long(list.size()-1));
            }
 
            ConstIterator begin() const {
                return ConstIterator(*this, 0);
            }
 
            ConstIterator end() const {
                return ConstIterator(*this, (long)list.size());
            }
 
            ConstIterator First() const {
                return ConstIterator(*this, 0);
            }
 
            ConstIterator Last() const {
                return ConstIterator(*this, long(list.size()-1));
            }
 
            void Clear() {
                list.clear();
            }
 
            void Collapse() {
                std::vector<T_*> newlist;
                using std::swap;
                
                swap(newlist, list);    
            }
 
            void DeleteAll() {
                for(auto e : list)
                    delete e;
 
                list.clear();
            }
 
            void Destroy() {
                for(auto e : list)
                    delete e;
 
                std::vector<T_*> newlist;
                using std::swap;
 
                swap(newlist, list);
            }
 
            void Reserve(long amount) {
                list.reserve(amount);
            }
 
        protected:
            std::vector<T_ *> list;
 
            void removeat(long absolutepos) {
                Remove(absolutepos);
            }
 
            void deleteat(long absolutepos) {
                Delete(absolutepos);
            }
 
            T_ *get_(long Index) {
                if(Index<0 || Index>=(long)list.size())
                    return NULL;
 
                return list[Index];
            }
 
            const T_ *get_(long Index) const {
                if(Index<0 || Index>list.size())
                    return NULL;
 
                return list[Index];
            }
        };
 
        template<class T_>
        inline void swap(Collection<T_> &l, Collection<T_> &r) {
            l.Swap(r);
        }
    } 
}