vee_object_store.h

Go to the documentation of this file.

/* -*- C++ -*- */

/* COPYRIGHT
 *
 * This file is part of the Visual Effects Engine - VEE
 *
 * Read the "VEE-LICENSE" file for the license.
 *
 * Authors & Copyright:   
 *
 * Tommi Ilmonen, Tuukka Heikura, Marko Myllymaa and 
 * Janne Kontkanen 2001-2004
 *
 * Additional copyrights: Tekes 2003-2004
 *
 * firstname.lastname@hut.fi
 *
 */


#ifndef VEE_OBJECT_STORE_H
#define VEE_OBJECT_STORE_H

#include <list>

template <typename T> class VEE_PointerStoreList
{
public:

  VEE_PointerStoreList() : m_last(0) {}
  
  void add(T * o) { m_objs.push_back(o); m_last = o; }
  
  bool remove(T * o) 
  {
    if(m_last == o) m_last = 0;

    typename std::list<T *>::iterator it = std::find(m_objs.begin(), m_objs.end(), o);

    if(it == m_objs.end())
      return false;

    if(it == m_it) {

      if(it == m_objs.begin()) {
  m_objs.erase(it); 
  m_it = m_objs.begin(); 
      }
      else {
  --m_it;
  m_objs.erase(it); 
      }
    }
    else
      m_objs.erase(it); 

    return true;
  }

  bool contains(T * o) 
  {
    if(o == m_last) return true;

    typename std::list<T *>::iterator it = std::find(m_objs.begin(), m_objs.end(), o);

    if(it != m_objs.end()) {
      m_last = o;
      return true;
    }
    return false;
  }

  int size() { return m_objs.size(); }

  void clear() { m_objs.clear(); m_last = 0; }

  void toFirst() { m_it = m_objs.begin(); }
  bool isAtEnd() { return m_it == m_objs.end(); }
  void advance() { ++m_it; }
  T * current() { return *m_it; }
  
protected:
  T         *    m_last;

  std::list<T *> m_objs;
  typename std::list<T *>::iterator m_it;
};


/* #include <hash_set>


template <class T> class VEE_PointerStoreHash
{
public:

  VEE_PointerStoreHash() : m_last(0) {}
  
  void add(T * o) { m_objs.insert(o); m_last = o; }
  
  bool remove(T * o) 
  {
    if(m_last == o) m_last = 0;

    std::hash_set<T *, vptrHash, eqVptr>::iterator it = m_objs.find(o);

    if(it == m_objs.end())
      return false;

    m_objs.erase(it);

    m_it = m_objs.begin();

    return true;
  }

  bool contains(T * o) 
  {
    if(o == m_last) return true;

    std::hash_set<T *, vptrHash, eqVptr>::iterator it = m_objs.find(o);

    if(it != m_objs.end()) {
      m_last = o;
      return true;
    }
    return false;
  }

  int size() { return m_objs.size(); }

  void clear() { m_objs.clear(); m_last = 0; }

  void toFirst() { m_it = m_objs.begin(); }
  bool isAtEnd() { return m_it == m_objs.end(); }
  void advance() { ++m_it; }
  T * current() { return *m_it; }
  
protected:
  T *       m_last;

  struct vptrHash {
    size_t operator()(T * x) const { return ((ulong) x) >> 3; }
  };


  struct eqVptr
  {
    bool operator()(const T* s1, const T* s2) const
    {
      return s1 == s2;
    }
  };

  std::hash_set<T *, vptrHash, eqVptr> m_objs;
  typename std::hash_set<T *, vptrHash, eqVptr>::iterator m_it;
};

*/


#include <set>


template <typename T> class VEE_PointerStoreSet
{
public:

  struct eqPtr
  {
    bool operator()(const T* s1, const T* s2) const
    {
      return s1 < s2;
    }
  };

  typedef typename std::set<T *, eqPtr>::iterator iterator;

  VEE_PointerStoreSet() : m_last(0) { m_it = m_objs.begin(); }
  
  void add(T * o) { m_objs.insert(o); m_last = o; }
  
  bool remove(T * o) 
  {
    if(m_last == o) m_last = 0;

    iterator it = m_objs.find(o);

    if(it == m_objs.end())
      return false;
    
    if(it == m_it) {

      if(it == m_objs.begin()) {
  m_objs.erase(it); 
  m_it = m_objs.begin(); 
      }
      else {
  --m_it;
  m_objs.erase(it); 
      }
    }
    else
      m_objs.erase(it); 

    return true;
  }

  void removeCurrent()
  {
    if(m_it == end())
      return;
    if(m_it == begin()) {
      m_objs.erase(m_it);
      m_it = begin();
    }
    else {
      iterator it = m_it;
      m_it--;
      m_objs.erase(it);
    }
  }

  bool contains(T * o) 
  {
    if(o == m_last) return true;

    typename std::set<T *, eqPtr>::iterator it = m_objs.find(o);

    if(it != m_objs.end()) {
      m_last = o;
      return true;
    }
    return false;
  }

  unsigned size() { return m_objs.size(); }

  void clear() { m_objs.clear(); m_last = 0;  m_it = m_objs.begin(); }

  void toFirst() { m_it = m_objs.begin(); }
  bool isAtEnd() { return m_it == m_objs.end(); }
  void advance() { ++m_it; }
  T * current() { return *m_it; }

  iterator begin() { return m_objs.begin(); }
  iterator end() { return m_objs.end(); }
  
  static T * getObject(iterator & it) { return (*it); }

protected:
  T *       m_last;

  std::set<T *, eqPtr> m_objs;
  typename std::set<T *, eqPtr>::iterator m_it;
};

#endif

---