nlist.hpp

Go to the documentation of this file.

// LICENSE: (Please see the file COPYING for details)
//
// NUS - Nemesis Utilities System: A C++ application development framework 
// Copyright (C) 2006, 2008 Otavio Rodolfo Piske
//
//  This file is part of NUS
//
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Lesser General Public
//  License as published by the Free Software Foundation version 2.1
//  of the License.
//
//  This library is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//  Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with this library; if not, write to the Free Software
//  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifndef NLIST_HPP
#define NLIST_HPP

template<typename T>
class NList {
      public:
            class iterator;
            
            typedef const iterator const_iterator;
            
            NList(void);
            
            NList(const T &val);
            
            NList(const NList<T> &other);
            
            virtual ~NList(void);

            nuint64 count(void) const;
            
            nuint64 count(const T &obj) const;
            
            
            nuint64 size(void) const;
            bool isEmpty(void) const;

            NList<T> &append(const T &val);
            
            NList<T> &insert(const T &val, nuint64 pos);
            
            NList<T> &removeAt(nuint64 pos);
            
            const T &at(nuint64 pos) const;
            
            T value(nuint64 pos) const;
 
            T &first(void);
            
            T &last(void);
            
            T takeFirst(void);
            
            T takeLast(void);
            
            T takeAt(nuint64 pos);

            void clear(void);
            
            NList<T> &copy(const NList<T> &other);

            bool hasNext(void) const;
            
            bool hasPrevious(void) const;
            
            bool contains(const T &val) const;

            NList<T> &operator=(const NList<T> &rhs);
            
            
            iterator begin(void);
            
            const_iterator constBegin(void) const;
            
            iterator end(void); 
            
            const_iterator constEnd(void) const;
      
      protected:
            mutable NListNode<T> *m_first;      
            mutable NListNode<T> *m_node;       
            nuint64 m_count;        
            void gotoFirst() const;
            
            void gotoPos(nuint64 pos) const;
};

template<typename T>
NList<T>::NList(void)
      : m_first(NULL),
      m_node(NULL),
      m_count(0)
{

}


template<typename T>
NList<T>::NList(const T &val)
      : m_first(NULL),
      m_node(NULL),
      m_count(0)
{
      append(val);
}


template<typename T>
NList<T>::NList(const NList<T> &other)
      : m_first(NULL),
      m_node(NULL),
      m_count(0)
{
      copy(other);
}


template<typename T>
NList<T>::~NList(void) {
      clear();
}


template<typename T>
bool NList<T>::isEmpty(void) const {
      if (m_count == 0) {
            return true;
      }

      return false;
}


template<typename T>
nuint64 NList<T>::count(void) const {
      return m_count;
}

template<typename T>
nuint64 NList<T>::count(const T &obj) const { 
      nuint64 ret = 0;
      
      gotoFirst();
      for (nint32 i = 0; i < size(); i++) {
            if (obj == at(i)) {
                  ret++;
            }
      }
      
      return ret;
}


template<typename T>
nuint64 NList<T>::size(void) const {
      return count();
}


template<typename T>
NList<T> &NList<T>::append(const T &val) {
      NListNode<T> *node = NULL;

      node = new NListNode<T>;
      node->data = val;
      
      if (isEmpty()) {
            m_first = node;
      }
      else {
            m_node->next = node;
            node->previous = m_node;
      }
      m_node = node;
      m_count++;
      
      return *this;
}


template<typename T>
void NList<T>::gotoFirst(void) const {
      m_node = m_first;
}


template<typename T>
void NList<T>::gotoPos(nuint64 pos) const { 
      
      assert(pos < size());
      
      gotoFirst();
      for (nuint64 i = 0; i < pos; i++) {
            if (m_node && m_node->next) {
                  m_node = m_node->next;
            }
      }
}


template<typename T>
NList<T> &NList<T>::insert(const T &val, nuint64 pos) {
      NListNode<T> *node = NULL;

      gotoPos(pos);
      node = new NListNode<T>;
      node->data = val;
      
      if (!isEmpty()) {
            node->previous = m_node->previous;
            m_node->previous = node;

            // Sets the 'next' pointer, only if it exists.
            if (node->previous) {
                  node->previous->next = node;
            }
            node->next = m_node;
      }

      m_node = node;
      m_count++;
      
      return *this;
}


template<typename T>
NList<T> &NList<T>::removeAt(nuint64 pos) {
      NListNode<T> *previous = NULL;
      NListNode<T> *next = NULL;
      
      gotoPos(pos);
      
      previous = m_node->previous;
      next = m_node->next;
      
      delete m_node;
      m_node = NULL;
      
      if (previous) {
            previous->next = next;
            m_node = previous;
      }
      else {
            m_first = next;
            m_node = m_first;
      }

      if (next) {
            next->previous = previous;
            m_node = next;
      }

      m_count--;
      if (count() == 0) {
            m_first = NULL; 
            m_node = NULL;
      }
      
      return *this;
}


template<typename T>
const T &NList<T>::at(nuint64 pos) const {
      gotoPos(pos);

      return m_node->data;
}


template<typename T>
T NList<T>::value(nuint64 pos) const {
      T ret;

      this->gotoPos(pos);
      ret = m_node->data;

      return ret;
}


template<typename T>
T &NList<T>::first(void) {
      gotoPos(0);
      return m_node->data;
}


template<typename T>
T &NList<T>::last(void) {
      gotoPos(size() - 1);
      return m_node->data;
}


template<typename T>
void NList<T>::clear(void) {
      for (nint32 i = size() - 1; i >= 0; i--) {
            removeAt(i);
      }
      
}


template<typename T>
NList<T> &NList<T>::copy(const NList<T> &other) {
      clear();
      for (nuint64 i = 0; i < other.size(); i++) {
            append(other.value(i));
      }

      return *this;
}


template<typename T>
bool NList<T>::hasNext(void) const {
      if (m_node && m_node->next) {
            return true;
      }

      return false;
}


template<typename T>
bool NList<T>::hasPrevious(void) const {
      if (m_node && m_node->previous) {
            return true;
      }

      return false;
}


template <typename T>
T NList<T>::takeFirst(void) { 
    return takeAt(0);
}


template <typename T>
T NList<T>::takeLast(void) { 
    return takeAt(size() - 1);
}


template<typename T>
T NList<T>::takeAt(nuint64 pos) {
      T ret;

      ret = value(pos);
      removeAt(pos);
      return ret;
}


template<typename T>
NList<T> &NList<T>::operator=(const NList<T> &rhs) { 
      return copy(rhs);
}


template <typename T>
bool NList<T>::contains(const T &val) const { 
      T tmp;
      
      for (nuint64 i = 0; i < size(); i++) { 
            tmp = at(i);
            if (val == tmp) { 
                  return true;
            }
      }
      
      return false;
}


template <typename T>
class NList<T>::iterator {
      public:
            iterator(NListNode<T> *node)
                  : m_node(node)
            {}
            
            iterator(const iterator &other): m_node(NULL) {
                  m_node = other.m_node;
            }
            
            ~iterator(void) {}

            iterator &operator=(const iterator &rhs) {
                  m_node = rhs.m_node;
                  
                  return *this;
            }
            
            
            bool operator!=(const iterator &rhs) const {
                  if (!m_node || !rhs.m_node) { 
                        if (!m_node && !rhs.m_node) {
                              return false;
                        }

                        return true;
                  }
                  
                  if (m_node->data != rhs.m_node->data) {
                        return true;
                  }

                  return false;
            }

            
            bool operator==(const iterator &rhs) const {
                  if (!m_node || !rhs.m_node) { 
                        if (!m_node && !rhs.m_node) {
                              return true;
                        }

                        return false;
                  }

                  if (m_node->data == rhs.m_node->data) {
                        return true;
                  }
                  
                  return false;
            }
            
            iterator operator++(int) {
                  iterator tmp(*this);
                  
                  inc();
                  return tmp;
            }
            
            const iterator &operator++(void) const {
                  iterator tmp(*this);
                  
                  m_node = m_node->next;
                  return *this;
            }
            
            
            const iterator operator++(int) const {
                  iterator tmp(*this);
                  
                  ++(*this);
                  return tmp;
            }
            
            T& operator*(void) {
                  return m_node->data;
            }
            
            const T& operator*(void) const {
                  return m_node->data;
            }
            
            T* operator->(void) {
                  return &m_node->data;
            }
            
            const T* operator->(void) const {
                  return &m_node->data;
            }
            
            
      private:
            mutable NListNode<T> *m_node;
            
            iterator inc(void) {
                  iterator tmp(*this);
                  
                  m_node = m_node->next;
                  return tmp;
            }
};


template <typename T>
typename NList<T>::iterator NList<T>::begin(void) {
      typename NList<T>::iterator i(m_first);
      
      return i;
}


template <typename T>
NLISTITERATOR_CONST NList<T>::constBegin(void) const {
      typename NList<T>::const_iterator i(m_first);
      
      return i;
} 


template <typename T>
typename NList<T>::iterator NList<T>::end(void) {
      return typename NList<T>::iterator(NULL);
}



template <typename T>
NLISTITERATOR_CONST NList<T>::constEnd(void) const {
      return typename NList<T>::const_iterator(NULL);
}

#endif // NLIST_HPP

---