AndroMeta/include/AndroMeta/MList.h

Go to the documentation of this file.

/*
 * Copyright 2009-2012 AndroMeta LLC. All rights reserved.
 *
 * AndroMeta LLC retains all intellectual property and proprietary 
 * rights to this software and related documentation and any modifications 
 * thereto.  Any use, reproduction, disclosure, or distribution of this 
 * software and related documentation without an express license agreement 
 * from AndroMeta LLC is strictly prohibited.
 * 
 */

#include <list>
#include <iterator>
#include <sstream>
#include <iostream>

#include <AndroMeta/MError.h>

#ifndef ANDROMETA_M_LIST_H
#define ANDROMETA_M_LIST_H

namespace Meta{
  
  template<typename T, class Allocator = std::allocator<T> >
  class MList{
  public:
    typedef std::list<T, Allocator> List_;
    
    typedef typename List_::reference reference;
    typedef typename List_::const_reference const_reference;
    typedef typename List_::iterator iterator;
    typedef typename List_::const_iterator const_iterator;
    typedef typename List_::allocator_type allocator_type;
    typedef typename List_::reverse_iterator reverse_iterator;
    typedef typename List_::const_reverse_iterator const_reverse_iterator;
    
    explicit MList(const Allocator& allocator=Allocator())
    : list_(allocator),
    i_(-1){
      
    }
    
    explicit MList(size_t n,
                   const T& value=T(),
                   const Allocator& allocator=Allocator())
    : list_(n, value, allocator),
    i_(-1){
      
    }
    
    template<class InputIterator>
    MList(InputIterator first,
          InputIterator last,
          const Allocator& allocator=Allocator())
    : list_(first, last, allocator),
    i_(-1){
      
    }
    
    MList(const MList<T, Allocator>& x)
    : list_(x.list_),
    i_(-1){
      
    }
    
    virtual ~MList(){
      
    }
    
    const List_ list() const{
      return list_;
    }
    
    List_ list(){
      return list_;
    }  
    
    template<class InputIterator>
    void assign(InputIterator first, InputIterator last){
      list_.assign(first, last);
      i_ = -1;
    }
    
    void assign(size_t n, const T& u){
      list_.assign(n, u);
      i_ = -1;
    }
    
    reference back(){
      return list_.back();
    }
    
    const_reference back() const{
      return list_.back();
    }
    
    iterator begin(){
      return list_.begin();
    }
    
    const_iterator begin () const{
      return list_.begin();
    }
    
    void clear(){
      list_.clear();
      i_ = -1;
    }
    
    bool empty() const{
      return list_.empty();
    }
    
    bool isEmpty() const{
      return list_.isEmpty();
    }
    
    iterator end(){
      return list_.end();
    }
    
    const_iterator end() const{
      return list_.end();
    }
    
    iterator erase(iterator position){
      i_ = -1;
      return list_.erase(position);
    }
    
    iterator erase(iterator first, iterator last){
      i_ = -1;
      return list_.erase(first, last);
    }
    
    reference front(){
      return list_.front();
    }
    
    const_reference front() const{
      return list_.front();
    }
    
    allocator_type get_allocator() const{
      return list_.get_allocator();
    }
    
    allocator_type getAllocator() const{
      return list_.get_allocator();
    }
    
    iterator insert(iterator position, const T& x){
      i_ = -1;
      return list_.insert(position, x);
    }
    
    void insert(iterator position, size_t n, const T& x){
      i_ = -1;
      return list_.insert(position, n, x);
    }
    
    template <class InputIterator>
    void insert(iterator position, InputIterator first, InputIterator last){
      i_ = -1;
      list_.insert(position, first, last);
    }
    
    void append(const MList<T> l){
      list_.insert(list_.end(), l.begin(), l.end());
    }
    
    template<class S>
    void append(const MList<S> l){
      list_.insert(list_.end(), l.begin(), l.end());
    }
    
    size_t max_size() const{
      return list_.max_size();
    }
    
    size_t maxSize() const{
      return list_.max_size();
    }
    
    void merge(MList<T, Allocator>& x){
      i_ = -1;
      list_.merge(x.list_);
    }
    
    template<class Compare>
    void merge(MList<T, Allocator>& x, Compare comp){
      i_ = -1;
      list_.merge(x.list_, comp);
    }
    
    MList<T, Allocator>& operator=(const MList<T, Allocator>& x){
      i_ = -1;
      list_ = x.list_;
      return *this;
    }
    
    void pop_back(){
      list_.pop_back();
    }
    
    T popBack(){
      T ret = *(--list_.end());
      list_.pop_back();
      return ret;
    }
    
    void pop_front(){
      i_ = -1;
      list_.pop_front();
    }
    
    T popFront(){
      i_ = -1;
      T ret = *list_.begin();
      list_.pop_front();
      return ret;
    }
    
    void push_back(const T& x){
      list_.push_back(x);
    }
    
    void pushBack(const T& x){
      list_.push_back(x);
    }
    
    void push_front(const T& x){
      i_ = -1;
      list_.push_front(x);
    }
    
    void pushFront(const T& x){
      i_ = -1;
      list_.push_front(x);
    }
    
    reverse_iterator rbegin(){
      return list_.rbegin();
    }
    
    const_reverse_iterator rbegin() const{
      return list_.rbegin();
    }
    
    void remove(const T& value){
      i_ = -1;
      list_.remove(value);
    }
    
    template <class Predicate>
    void remove_if(Predicate pred){
      i_ = -1;
      list_.remove_if(pred);
    }
    
    template <class Predicate>
    void removeIf(Predicate pred){
      i_ = -1;
      list_.remove_if(pred);
    }
    
    reverse_iterator rend(){
      return list_.rend();
    }
    
    const_reverse_iterator rend() const{
      return list_.rend();
    }
    
    void resize(size_t sz, T c=T()){
      i_ = -1;
      list_.resize(sz, c);
    }
    
    void reverse(){
      list_.reverse();
    }
    
    size_t size() const{
      return list_.size();
    }
    
    void sort(){
      list_.sort();
    }
    
    template<class Compare>
    void sort(Compare comp){
      list_.sort(comp);
    }
    
    void splice(iterator position, MList<T, Allocator>& x){
      i_ = -1;
      list_.splice(position, x);
    }
    
    void splice(iterator position, MList<T,Allocator>& x, iterator i){
      i_ = -1;
      list_.splice(position, x, i);
    }
    
    void splice(iterator position,
                MList<T,Allocator>& x,
                iterator first,
                iterator last){
      i_ = -1;
      list_.splice(position, x, first, last);
    }
    
    void swap(MList<T, Allocator>& lst){
      i_ = -1;
      list_.swap(lst);
    }
    
    void unique(){
      i_ = -1;
      list_.unique();
    }
    
    template<class BinaryPredicate>
    void unique(BinaryPredicate binary_pred){
      i_ = -1;
      list_.unique(binary_pred);
    }
    
    MList<T,Allocator>& operator<<(const T& x){
      list_.push_back(x);
      return *this;
    }
    
    reference operator[](size_t i){
      if(i >= list_.size()){
        std::stringstream ostr;
        ostr << "MList::operator[]: invalid index: " << i;
        throw MError(ostr.str());
      }
      
      if(i_ < 0){
        itr_ = list_.begin();
        advance(itr_, i);
      }
      else{
        advance(itr_, i - i_);
      }
      
      i_ = i;
      
      return *itr_;
    }
    
    const_reference operator[](size_t i) const{
      MList* l = const_cast<MList*>(this);
      return l->operator[](i);
    }
    
  private:
    List_ list_;
    iterator itr_;
    int64_t i_;
  };
  
  template<class T, class Allocator>
  bool operator==(const MList<T,Allocator>& x,
                  const MList<T,Allocator>& y){
    return x.list() == y.list();
  }
  
  template<class T, class Allocator>
  bool operator<(const MList<T,Allocator>& x,
                 const MList<T,Allocator>& y){
    return x.list() < y.list();
  }
  
  template<class T, class Allocator>
  bool operator!=(const MList<T,Allocator>& x,
                  const MList<T,Allocator>& y){
    return x.list() != y.list();
  }
  
  template<class T, class Allocator>
  bool operator>(const MList<T,Allocator>& x,
                 const MList<T,Allocator>& y){
    return x.list() > y.list();
  }
  
  template<class T, class Allocator>
  bool operator>=(const MList<T,Allocator>& x,
                  const MList<T,Allocator>& y){
    return x.list() >= y.list();
  }
  
  template <class T, class Allocator>
  bool operator<=(const MList<T,Allocator>& x,
                  const MList<T,Allocator>& y){
    return x.list() <= y.list();
  }
  
  template<typename T>
  std::ostream& operator<<(std::ostream& ostr, const MList<T>& v){
    typename MList<T>::const_iterator itr = v.begin();
    size_t i = 0;
    bool index = v.size() > 10;
    ostr << "(";
    while(itr != v.end()){
      if(index){
        ostr << i << ":";
      }
      if(i > 0){
        ostr << ", ";
      }
      ostr << *itr;
      ++i;
      ++itr;
    }
    ostr << ")";
    return ostr;
  }
  
} // end namespace Meta

#endif // ANDROMETA_M_LIST_H