list

#ifndef __TYPETRAIT__H__#define __TYPETRAIT__H__#include <cstddef>namespace stc{class trueType{};class falseType{};template <typename type>class typeTrait{public:typedef trueTypethisDummyMemberMustBeFirst;typedef falseTypehasTrivalDefaultCtor;typedef falseTypehasTrivalCopyCtor;typedef falseTypehasTrivalAssignmentOperator;typedef falseTypehasTrivalDtor;typedef falseTypeisPODType;};template <> class typeTrait < signed char > {public:typedef trueTypehasTrivalDefaultCtor;typedef trueTypehasTrivalCopyCtor;typedef trueTypehasTrivalAssignmentOperator;typedef trueTypehasTrivalDtor;typedef trueTypeisPODType;};template <> class typeTrait < unsigned char > {public:typedef trueTypehasTrivalDefaultCtor;typedef trueTypehasTrivalCopyCtor;typedef trueTypehasTrivalAssignmentOperator;typedef trueTypehasTrivalDtor;typedef trueTypeisPODType;};template <> class typeTrait < wchar_t > {public:typedef trueTypehasTrivalDefaultCtor;typedef trueTypehasTrivalCopyCtor;typedef trueTypehasTrivalAssignmentOperator;typedef trueTypehasTrivalDtor;typedef trueTypeisPODType;};template <> class typeTrait < short > {public:typedef trueTypehasTrivalDefaultCtor;typedef trueTypehasTrivalCopyCtor;typedef trueTypehasTrivalAssignmentOperator;typedef trueTypehasTrivalDtor;typedef trueTypeisPODType;};template <> class typeTrait < unsigned short > {public:typedef trueTypehasTrivalDefaultCtor;typedef trueTypehasTrivalCopyCtor;typedef trueTypehasTrivalAssignmentOperator;typedef trueTypehasTrivalDtor;typedef trueTypeisPODType;};template <> class typeTrait < int > {public:typedef trueTypehasTrivalDefaultCtor;typedef trueTypehasTrivalCopyCtor;typedef trueTypehasTrivalAssignmentOperator;typedef trueTypehasTrivalDtor;typedef trueTypeisPODType;};template <> class typeTrait < unsigned int > {public:typedef trueTypehasTrivalDefaultCtor;typedef trueTypehasTrivalCopyCtor;typedef trueTypehasTrivalAssignmentOperator;typedef trueTypehasTrivalDtor;typedef trueTypeisPODType;};template <> class typeTrait < long > {public:typedef trueTypehasTrivalDefaultCtor;typedef trueTypehasTrivalCopyCtor;typedef trueTypehasTrivalAssignmentOperator;typedef trueTypehasTrivalDtor;typedef trueTypeisPODType;};template <> class typeTrait < long long> {public:typedef trueTypehasTrivalDefaultCtor;typedef trueTypehasTrivalCopyCtor;typedef trueTypehasTrivalAssignmentOperator;typedef trueTypehasTrivalDtor;typedef trueTypeisPODType;};template <> class typeTrait < unsigned long > {public:typedef trueTypehasTrivalDefaultCtor;typedef trueTypehasTrivalCopyCtor;typedef trueTypehasTrivalAssignmentOperator;typedef trueTypehasTrivalDtor;typedef trueTypeisPODType;};template <> class typeTrait < float > {public:typedef trueTypehasTrivalDefaultCtor;typedef trueTypehasTrivalCopyCtor;typedef trueTypehasTrivalAssignmentOperator;typedef trueTypehasTrivalDtor;typedef trueTypeisPODType;};template <> class typeTrait < double > {public:typedef trueTypehasTrivalDefaultCtor;typedef trueTypehasTrivalCopyCtor;typedef trueTypehasTrivalAssignmentOperator;typedef trueTypehasTrivalDtor;typedef trueTypeisPODType;};template <> class typeTrait < long double > {public:typedef trueTypehasTrivalDefaultCtor;typedef trueTypehasTrivalCopyCtor;typedef trueTypehasTrivalAssignmentOperator;typedef trueTypehasTrivalDtor;typedef trueTypeisPODType;};template <class type> class typeTrait < type* > {public:typedef trueTypehasTrivalDefaultCtor;typedef trueTypehasTrivalCopyCtor;typedef trueTypehasTrivalAssignmentOperator;typedef trueTypehasTrivalDtor;typedef trueTypeisPODType;};template <> class typeTrait < bool > {public:typedef trueTypehasTrivalDefaultCtor;typedef trueTypehasTrivalCopyCtor;typedef trueTypehasTrivalAssignmentOperator;typedef trueTypehasTrivalDtor;typedef trueTypeisPODType;};}#endif#ifndef __ITERATOR__TRAIT__H__#define __ITERATOR__TRAIT__H__#include <cstddef>namespace stc{class inputIteratorTag{};class outputIteratorTag{};class forwardIteratorTag{};class bidirectionalIteratorTag{};class randomAccessIteratorTag{};template < typename type,typename category = forwardIteratorTag,typename distance = std::ptrdiff_t,typename pointer = type*,typename reference = type& >class iterator{public:typedef typevalueType;typedef categoryiteratorCategory;typedef distancedifferenceType;typedef pointerpointer;typedef referencereference;};template <typename iterator>class iteratorTrait{public:typedef typename iterator::iteratorCategoryiteratorCategory;typedef typename iterator::valueTypevalueType;typedef typename iterator::differenceTypedifferenceType;typedef typename iterator::pointerpointer;typedef typename iterator::referencereference;};template <> class iteratorTrait < signed char > {public:typedef randomAccessIteratorTagiteratorCategory;typedef signed charvalueType;typedef std::ptrdiff_tdifferenceType;typedef signed char*pointer;typedef signed char&reference;};template <> class iteratorTrait < const signed char > {public:typedef randomAccessIteratorTagiteratorCategory;typedef const signed charvalueType;typedef std::ptrdiff_tdifferenceType;typedef const signed char*pointer;typedef const signed char&reference;};template <> class iteratorTrait < unsigned char > {public:typedef randomAccessIteratorTagiteratorCategory;typedef unsigned charvalueType;typedef std::ptrdiff_tdifferenceType;typedef unsigned char*pointer;typedef unsigned char&reference;};template <> class iteratorTrait < const unsigned char > {public:typedef randomAccessIteratorTagiteratorCategory;typedef const unsigned charvalueType;typedef std::ptrdiff_tdifferenceType;typedef const unsigned char*pointer;typedef const unsigned char&reference;};template <> class iteratorTrait < wchar_t > {public:typedef randomAccessIteratorTagiteratorCategory;typedef wchar_tvalueType;typedef std::ptrdiff_tdifferenceType;typedef wchar_t*pointer;typedef wchar_t&reference;};template <> class iteratorTrait < const wchar_t > {public:typedef randomAccessIteratorTagiteratorCategory;typedef const wchar_tvalueType;typedef std::ptrdiff_tdifferenceType;typedef const wchar_t*pointer;typedef const wchar_t&reference;};template <> class iteratorTrait < short > {public:typedef randomAccessIteratorTagiteratorCategory;typedef shortvalueType;typedef std::ptrdiff_tdifferenceType;typedef short*pointer;typedef short&reference;};template <> class iteratorTrait < const short > {public:typedef randomAccessIteratorTagiteratorCategory;typedef const shortvalueType;typedef std::ptrdiff_tdifferenceType;typedef const short*pointer;typedef const short&reference;};template <> class iteratorTrait < unsigned short > {public:typedef randomAccessIteratorTagiteratorCategory;typedef unsigned shortvalueType;typedef std::ptrdiff_tdifferenceType;typedef unsigned short*pointer;typedef unsigned short&reference;};template <> class iteratorTrait < const unsigned short > {public:typedef randomAccessIteratorTagiteratorCategory;typedef const unsigned shortvalueType;typedef std::ptrdiff_tdifferenceType;typedef const unsigned short*pointer;typedef const unsigned short&reference;};template <> class iteratorTrait < int > {public:typedef randomAccessIteratorTagiteratorCategory;typedef intvalueType;typedef std::ptrdiff_tdifferenceType;typedef int*pointer;typedef int&reference;};template <> class iteratorTrait < const int > {public:typedef randomAccessIteratorTagiteratorCategory;typedef const intvalueType;typedef std::ptrdiff_tdifferenceType;typedef const int*pointer;typedef const int&reference;};template <> class iteratorTrait < unsigned int > {public:typedef randomAccessIteratorTagiteratorCategory;typedef unsigned intvalueType;typedef std::ptrdiff_tdifferenceType;typedef unsigned int*pointer;typedef unsigned int&reference;};template <> class iteratorTrait < const unsigned int > {public:typedef randomAccessIteratorTagiteratorCategory;typedef const unsigned intvalueType;typedef std::ptrdiff_tdifferenceType;typedef const unsigned int*pointer;typedef const unsigned int&reference;};template <> class iteratorTrait < long > {public:typedef randomAccessIteratorTagiteratorCategory;typedef longvalueType;typedef std::ptrdiff_tdifferenceType;typedef long*pointer;typedef long&reference;};template <> class iteratorTrait < const long > {public:typedef randomAccessIteratorTagiteratorCategory;typedef const longvalueType;typedef std::ptrdiff_tdifferenceType;typedef const long*pointer;typedef const long&reference;};template <> class iteratorTrait < long long > {public:typedef randomAccessIteratorTagiteratorCategory;typedef long long valueType;typedef std::ptrdiff_tdifferenceType;typedef long long *pointer;typedef long long &reference;};template <> class iteratorTrait < const long long > {public:typedef randomAccessIteratorTagiteratorCategory;typedef const long long valueType;typedef std::ptrdiff_tdifferenceType;typedef const long long *pointer;typedef const long long &reference;};template <> class iteratorTrait < unsigned long > {public:typedef randomAccessIteratorTagiteratorCategory;typedef unsigned longvalueType;typedef std::ptrdiff_tdifferenceType;typedef unsigned long*pointer;typedef unsigned long&reference;};template <> class iteratorTrait < const unsigned long > {public:typedef randomAccessIteratorTagiteratorCategory;typedef const unsigned longvalueType;typedef std::ptrdiff_tdifferenceType;typedef const unsigned long*pointer;typedef const unsigned long&reference;};template <> class iteratorTrait < float > {public:typedef randomAccessIteratorTagiteratorCategory;typedef floatvalueType;typedef std::ptrdiff_tdifferenceType;typedef float*pointer;typedef float&reference;};template <> class iteratorTrait < const float > {public:typedef randomAccessIteratorTagiteratorCategory;typedef const floatvalueType;typedef std::ptrdiff_tdifferenceType;typedef const float*pointer;typedef const float&reference;};template <> class iteratorTrait < double > {public:typedef randomAccessIteratorTagiteratorCategory;typedef doublevalueType;typedef std::ptrdiff_tdifferenceType;typedef double*pointer;typedef double&reference;};template <> class iteratorTrait < const double > {public:typedef randomAccessIteratorTagiteratorCategory;typedef const doublevalueType;typedef std::ptrdiff_tdifferenceType;typedef const double*pointer;typedef const double&reference;};template <> class iteratorTrait < long double > {public:typedef randomAccessIteratorTagiteratorCategory;typedef long doublevalueType;typedef std::ptrdiff_tdifferenceType;typedef long double*pointer;typedef long double&reference;};template <> class iteratorTrait < const long double > {public:typedef randomAccessIteratorTagiteratorCategory;typedef const long doublevalueType;typedef std::ptrdiff_tdifferenceType;typedef const long double*pointer;typedef const long double&reference;};template <> class iteratorTrait < bool > {public:typedef randomAccessIteratorTagiteratorCategory;typedef boolvalueType;typedef std::ptrdiff_tdifferenceType;typedef bool*pointer;typedef bool&reference;};template <> class iteratorTrait < const bool > {public:typedef randomAccessIteratorTagiteratorCategory;typedef const boolvalueType;typedef std::ptrdiff_tdifferenceType;typedef const bool*pointer;typedef const bool&reference;};}#endif#ifndef __LIST__H__#define __LIST__H__#include <memory>#include <cassert>#include <stdexcept>#include "typeTrait.h"#include "iteratorTrait.h"namespace stc{template <typename type>class listNode{typedef listNode<type>*pointer;public:listNode() :mNext(0), mNext(0){}listNode(const type&, pointer = NULL, pointer = NULL);type mData;listNode<type>* mNext;listNode<type>* mPrev;};template <typename type>listNode<type>::listNode(const type& val, pointer next, pointer prev):mData(val), mNext(next), mPrev(prev){}template <typename type,typename ref,typename ptr>class listIterator{typedef listNode<type>*linkType;typedef listIterator<type, type&, type*> iterator;typedef listIterator<type, ref, ptr> self;public:typedef stc::bidirectionalIteratorTagiteratorCategory;typedef typevalueType;typedef ptrpointer;typedef refreference;typedef std::size_tsizeType;typedef std::ptrdiff_tdifferenceType;listIterator() = default;listIterator(linkType node) :mNode(node){}listIterator(const listIterator& rhs) :mNode(rhs.mNode){}bool operator ==(const self& x) const{ return mNode == x.mNode; }bool operator !=(const self& x) const{ return mNode != x.mNode; }linkType getNode()const{ return mNode; } reference operator *() const{ return mNode->mData; }pointer operator ->() const{ return &(mNode->mData); }self& operator ++();self& operator ++(int);self& operator --();self& operator --(int);private:linkType mNode;};template <typename type,typename ref,typename ptr>inline typename listIterator<type,ref,ptr>::self&listIterator<type, ref, ptr>::operator ++(){mNode = mNode->mNext;return *this;}template <typename type,typename ref,typename ptr>inline typename listIterator<type, ref, ptr>::self&listIterator<type, ref, ptr>::operator ++(int){self temp = *this;++(*this);return temp;}template <typename type,typename ref,typename ptr>inline typename listIterator<type, ref, ptr>::self&listIterator<type, ref, ptr>::operator --(){mNode = mNode->mPrev;return *this;}template <typename type,typename ref,typename ptr>inline typename listIterator<type, ref, ptr>::self&listIterator<type, ref, ptr>::operator --(int){self temp = *this;--(*this);return temp;}template <typename type,class Alloc = std::allocator<stc::listNode<type> > >class list{typedef listNode<type>* listNode;public:typedef typevalueType;typedef type*pointer;typedef listIterator <type, type&, type*>iterator;typedef type&reference;typedef std::size_tsizeType;typedef std::ptrdiff_tdifferenceType;public:~list();list();list(list<type>&&);list(const list<type>&);const sizeType size()const { return mSize; }bool empty() const{ return !mSize; }iterator begin() const{ return mHead->mNext; }iterator end()const{ return mHead; }reference front() { assert(!empty()); return *(begin()); }reference back()  { assert(!empty()), return *(--end()); }void push_back(const type&);void push_head(const type&);iterator insert(const type&, iterator);iterator erase(iterator);void pop_back();void pop_front();void clear();void remove(const type&);void unique();void splice(iterator, list<type>&);void splice(iterator, list<type>&, iterator);void splice(iterator, list<type>&, iterator, iterator);void reverse();list<type>& memcopy(const list<type>&);list<type>& memcopy(list<type>&&);list<type>& operator =(const list<type>&);list<type>& operator =(list<type>&&);private:listNode getNode();void putNode(listNode&);listNode creatNode(const type&);listNode creatNode(const type&, listNode, falseType);listNode creatNode(const type&, listNode, trueType);void destroyNode(listNode&);void destroyNode(listNode&, falseType);void destroyNode(listNode&, trueType);void emptyInit();void transfer(iterator, iterator, iterator);sizeType distance(iterator, iterator);private:Alloc mAllocator;listNode mHead;sizeType mSize;const size_t sDefaultSz = 1;};template <typename type,class Alloc>list<type, Alloc>::list():mHead(0),mSize(0){this->emptyInit();}template <typename type,class Alloc>list<type, Alloc>::~list(){this->clear();this->putNode(mHead);}template <typename type,class Alloc>list<type, Alloc>::list(const list<type>& rhs) :mHead(0), mSize(0){emptyInit();memcopy(rhs);}template <typename type,class Alloc>list<type,Alloc>::list(list<type>&& rhs){emptyInit();if (!rhs.empty()){transfer(begin(), rhs, rhs.begin(), rhs.end());rhs.mSize = 0;}}template <typename type,class Alloc>typename stc::list<type,Alloc>::listNodelist<type,Alloc>::getNode(){return mAllocator.allocate(sDefaultSz);}template <typename type,class Alloc>void list<type,Alloc>::putNode(listNode& ptr){mAllocator.deallocate(ptr,sDefaultSz);ptr = NULL;}template <typename type,class Alloc>typename list<type,Alloc>::listNodelist<type,Alloc>::creatNode(const type& val){listNode ptr = getNode();typedef typename typeTrait <type>::isPODType isPODType;return creatNode(val, ptr, isPODType());}template <typename type, class Alloc>typename list<type, Alloc>::listNodelist<type, Alloc>::creatNode(const type& val,listNode ptr,falseType){assert(ptr);mAllocator.construct(ptr, val);return ptr;}template <typename type, class Alloc>inline typename list<type, Alloc>::listNodelist<type, Alloc>::creatNode(const type& val, listNode ptr, trueType){*ptr = val;return ptr;}template <typename type,class Alloc>void list<type,Alloc>::destroyNode(listNode& ptr){typedef typename typeTrait<type>::isPODTypeisPODType;this->destroyNode(ptr, isPODType());}template <typename type,class Alloc>void list<type,Alloc>::destroyNode(listNode& ptr, falseType){mAllocator.destroy(ptr);this->putNode(ptr);}template <typename type,class Alloc>void list<type,Alloc>::destroyNode(listNode& ptr, trueType){this->putNode(ptr);}template <typename type,class Alloc>void list<type,Alloc>::emptyInit(){mHead = getNode();mHead->mPrev = mHead;mHead->mPrev = mHead;}template <typename type,class Alloc>void list<type,Alloc>::push_back(const type& val){insert(val, end());}template <typename type,class Alloc>void list<type,Alloc>::push_head(const type& val){insert(val, begin());}template <typename type,class Alloc>typename list<type,Alloc>::iteratorlist<type,Alloc>::insert(const type& val,iterator pos){listNode tmp = creatNode(val);listNode curr = pos.getNode();listNode prev = curr->mPrev;tmp->mPrev = prev;prev->mNext = tmp;tmp->mNext = curr;curr->mPrev = tmp;++mSize;return tmp;}template <typename type,class Alloc>typename list<type,Alloc>::iteratorlist<type,Alloc>::erase(iterator pos){assert(!empty());assert(pos != end());listNode curr = pos.getNode();listNode prev = curr->mPrev;listNode next = curr->mNext;--mSize;prev->mNext = next;next->mPrev = prev;destroyNode(curr);return next;}template <typename type,class Alloc>void list<type, Alloc>::pop_back(){erase(--(end()));}template <typename type,class Alloc>void list<type,Alloc>::pop_front(){erase(begin());}template <typename type,class Alloc>void list<type,Alloc>::clear(){if (empty()) return;sizeType Sz = size();for (size_t i = 0; i != Sz; ++i)this->pop_back();}template <typename type,class Alloc>void list<type,Alloc>::remove(const type& val){if (empty()) return;for (iterator it = begin(); it != end(); ++it)if (*it == val) erase(it);}template <typename type,class Alloc>void list<type,Alloc>::unique(){if (empty()) return;iterator first = begin();iterator last = end();iterator next = first;while (&(*(++next)) != &(*first) && &(*next) != &(*last)){if (*first == *next)erase(next);else first = next;next = first;}}template <typename type,class Alloc>void list<type,Alloc>::transfer(iterator pos, iterator first, iterator last){assert(pos != last);listNode curr = pos.getNode();listNode prev = curr->mPrev;listNode fcurr = first.getNode();listNode fprev = fcurr->mPrev;listNode lcurr = last.getNode();listNode lprev = lcurr->mPrev;prev->mNext = fcurr;fcurr->mPrev = prev;curr->mPrev = lprev;lprev->mNext = curr;fprev->mNext = lcurr;lcurr->mPrev = fprev;}template <typename type,class Alloc>typename list<type,Alloc>::sizeTypelist<type, Alloc>::distance(iterator first, iterator last){sizeType res = 0;while (&(*first) != &(*last)){++first;++res;}return res;}template <typename type,class Alloc>void list<type,Alloc>::splice(iterator pos, list<type>& rhs){if (rhs.empty()) return;if (this == &rhs) return;transfer(pos, rhs.begin(), rhs.end());mSize += rhs.mSize;rhs.mSize = NULL;}template <typename type,class Alloc>void list<type,Alloc>::splice(iterator pos, list<type>& rhs, iterator item){insert(*item, pos);rhs.erase(item);++mSize;}template <typename type,class Alloc>void list<type, Alloc>::splice(iterator pos, list<type>& rhs,iterator first, iterator last){sizeType Sz = distance(first, last);transfer(pos, first, last);rhs.mSize -= Sz;mSize += Sz;}template <typename type,class Alloc>void list<type,Alloc>::reverse(){assert(!empty());iterator first = begin();iterator last = --end();for(sizeType i = 0;i != size() / 2;++i){std::swap(*first, *last);++first;--last;}}template <typename type,class Alloc>list<type>& list<type,Alloc>::memcopy(const list<type>& rhs){if (this == &rhs)return *this;else if (rhs.empty()){this->clear();return *this;}list<type> temp;for (iterator it = rhs.begin(); it != rhs.end(); ++it)temp.push_back(*it);clear();return memcopy(std::move(temp));}template <typename type,class Alloc>list<type>& list<type,Alloc>::memcopy(list<type>&& rhs){if (this == &rhs) return *this;this->clear();if (rhs.empty()) return *this; this->clear();listNode end = rhs.end().getNode();listNode prev = end->mPrev;listNode next = end->mNext;mSize = rhs.size();prev->mNext = mHead;mHead->mPrev = prev;mHead->mNext = next;next->mPrev = mHead;rhs.mSize = 0;rhs.mHead->mNext = rhs.mHead;rhs.mHead->mPrev = rhs.mHead;return *this;}template <typename type,class Alloc>list<type>& list<type,Alloc>::operator =(const list<type>& rhs){return memcopy(rhs);}template <typename type,class Alloc>list<type>& list<type,Alloc>::operator =(list<type>&& rhs){return memcopy(std::move(rhs));}}#endif