list.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: list.h,v 1.23 2004/04/22 10:08:19 oliver Exp $
//

#ifndef BALL_DATATYPE_LIST_H
#define BALL_DATATYPE_LIST_H

#ifndef BALL_COMMON_H
# include <BALL/common.h>
#endif

#ifndef BALL_CONCEPT_VISITOR_H
# include <BALL/CONCEPT/visitor.h>
#endif

#ifndef BALL_CONCEPT_PROCESSOR_H
# include <BALL/CONCEPT/processor.h>
#endif

#include <list>

namespace BALL 
{
  template <typename Value>
  class List
    : public std::list<Value>
  {
    public:


    typedef typename std::list<Value>::iterator Iterator;
    // for STL compatibility
    typedef typename std::list<Value>::iterator iterator;

    typedef typename std::list<Value>::const_iterator ConstIterator;
    // for STL compatibility
    typedef typename std::list<Value>::const_iterator const_iterator;



    BALL_CREATE_DEEP(List)

    
    List()
      : std::list<Value>()
    {
    }

    List(const List& new_list, bool /* deep = true */)
      : std::list<Value>(new_list)
    {
    }
      
    void destroy()
    {
      std::list<Value>::clear();
    }
  
    virtual ~List()
    {
      std::list<Value>::clear();
    }


      
    void set(const List& list, bool /* deep */ = true)
    {
      std::list<Value>::clear();

      ConstIterator it = list.begin();
      for ( ; it != list.end(); ++it)
      {
        std::list<Value>::push_back(const_cast<Value&>(*it));
      }
    }

    const List& operator = (const List& list)
    {
      set(list);
      return *this;
    }
      
    void get(List& list, bool deep = true) const 
    {
      list.set(*this, deep);
    }

    void swap(List& list)
    {
      List<Value> temp;
      temp.set(*this);
      (*this).set(list);
      list.set(temp);
    }



    Size getSize() const
    {
      return (Size)std::list<Value>::size();
    }

    bool remove(const Value& item)
    {
      Iterator it = std::list<Value>::begin();
      for (; it != std::list<Value>::end(); ++it)
      {
        if (*it == item)
        {
          std::list<Value>::erase(it);
          return true;
        }
      }
      return false;
    }
    


    bool isEmpty() const
    {
      return (std::list<Value>::size() == 0);
    }



    virtual void host(Visitor<List<Value> >& visitor);



    bool apply(UnaryProcessor<Value>& processor)
    {
      if (!processor.start()) return false;

      for (Iterator it = std::list<Value>::begin(); it != std::list<Value>::end(); ++it)
      {
        Processor::Result result = processor(*it);
        if (result <= Processor::BREAK)
        {
          return (result == Processor::BREAK);
        }
      }

      return processor.finish();
    }


    bool operator == (const List<Value>& list) const
    {
      if (std::list<Value>::size() != list.size())
      {
        return false;
      }

      typename List<Value>::ConstIterator this_it = std::list<Value>::begin();
      typename List<Value>::ConstIterator list_it = list.begin();

      for (; this_it != std::list<Value>::end(); ++this_it)
      {
        if (!(*this_it == *list_it))
        {
          return false;
        }
        ++list_it;
      }
      return true;  
    }

    bool operator != (const List<Value>& list) const
    {
      return !(*this == list);
    }

  };

  template <typename Value>
  void List<Value>::host(Visitor<List<Value> >& visitor)
  {
    visitor.visit(*this);
  }
} // namespace BALL

#endif // BALL_DATATYPE_LIST_H