collectors.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 1992-2010 VT MAK
** All rights reserved.
******************************************************************************/


#ifndef collectors_H_
#define collectors_H_

#include <vector>
#include <deque>
#include <list>
#include <set>
#include <vlutil/vlSmartPointers.h>

namespace MAKLogger
{


   template <typename T>
   class DtCollectorImpl
   {
   public:
      virtual ~DtCollectorImpl() {}

      virtual void   collect(T&)    = 0;
      virtual void   collect(const T&) = 0;

      virtual size_t size()  const = 0;
      virtual bool   full()  const = 0;
      virtual bool   empty() const = 0;
   };

   template <typename T>
   class DtCollector
   {
   public:

      DtCollector(DtCollectorImpl<T>* impl) :
         myImpl(DtBoost::shared_ptr<DtCollectorImpl<T> >(impl)){}

      void   collect(T& t)  { myImpl->collect(t);}
      void   collect(const T& t)  { myImpl->collect(t);}
      size_t size()  const { return myImpl->size();}
      bool   full()  const { return myImpl->full();}
      bool   empty() const { return myImpl->empty();}

   protected:
      DtBoost::shared_ptr<DtCollectorImpl<T> > myImpl;
   private:
      DtCollector* operator&();
      static void *operator new(size_t size);
      static void operator delete(void* ptr);
   };

   template <typename T,typename Container>
   class DtPushBackCollector : public DtCollectorImpl<T>
   {
   public:

      DtPushBackCollector(Container& container) :
         myContainer(container)
      {
      }

      virtual void collect(T& t)
      {
         myContainer.push_back(t);
      }

      virtual void collect(const T& t)
      {
         myContainer.push_back(t);
      }

      virtual size_t size()const
      {
         return myContainer.size();
      }

      virtual bool full() const
      {
         return false;
      }

      virtual bool empty() const
      {
         return myContainer.empty();
      }

   protected:
      Container& myContainer;
   };

   template <typename T,typename Container>
   class DtInsertCollector : public DtCollectorImpl<T>
   {
   public:

      DtInsertCollector(Container& container) : myContainer(container) {}

      virtual void collect(T& t)
      {
         myContainer.insert(t);
      }

      virtual void collect(const T& t)
      {
         myContainer.insert(t);
      }

      virtual size_t size()const
      {
         return myContainer.size();
      }

      virtual bool full() const
      {
         return false;
      }

      virtual bool empty() const
      {
         return myContainer.empty();
      }

   protected:
      Container& myContainer;
   };

   template <typename T,typename Container>
   class DtFixedSizePushBackCollector : public DtCollectorImpl<T>
   {
   public:

      DtFixedSizePushBackCollector(Container& container,int size) :
         myContainer(container),myMaxSize(size) {}

      virtual void collect(T& t)
      {
         if(!full) myContainer.push_back(t);
      }

      virtual void collect(const T& t)
      {
         if(!full) myContainer.push_back(t);
      }

      virtual void size()const
      {
         myContainer.size();
      }

      virtual bool full() const
      {
         return myMaxSize == myContainer.size();
      }

      virtual bool empty() const
      {
         return myContainer.empty();
      }

   protected:
      Container& myContainer;
      int        myMaxSize;
   };

   template <typename T>
   class DtFixedSizeArrayCollector : public DtCollectorImpl<T>
   {
   public:

      DtFixedSizeArrayCollector(T* container,int size) :
         myContainer(container),
            myMaxSize(size),
            myCurrentIndex(0)
         {}

         virtual void collect(T& t)
         {
            if(!full) myContainer[myCurrentIndex] = t;
            ++myCurrentIndex;
         }

         virtual void collect(const T& t)
         {
            if(!full) myContainer[myCurrentIndex] = t;
            ++myCurrentIndex;
         }

         virtual void size()const
         {
            return myCurrentIndex;
         }

         virtual bool full() const
         {
            return myMaxSize <= myCurrentIndex;
         }

         virtual bool empty() const
         {
            return myCurrentIndex == 0;
         }

   protected:
      T*  myContainer;
      int myMaxSize;
      int myCurrentIndex;
   };

   class DtCollectors
   {
   public:
      template <typename T>
      static DtCollector<T> create(std::vector<T>& collection)
      {
         return new DtPushBackCollector<T,std::vector<T> >(collection);
      }

      template <typename T>
      static DtCollector<T> create(std::deque<T>& collection)
      {
         return new DtPushBackCollector<T,std::deque<T> >(collection);
      }

      template <typename T>
      static DtCollector<T> create(std::list<T>& collection)
      {
         return new DtPushBackCollector<T,std::list<T> >(collection);
      }

      template <typename T>
      static DtCollector<T> create(std::set<T>& collection)
      {
         return new DtInsertCollector<T,std::set<T> >(collection);
      }

      template <typename T>
      static DtCollector<T> create(T* array,int size)
      {
         return new DtFixedSizeArrayCollector<T>(array,size);
      }
   };

   template <typename Key,typename Value>
   class DtMapCollector
   {
   public:
      virtual void add(Key,Value)  = 0;
      virtual bool containes(Key)  = 0;

      virtual int  size()  const = 0;
      virtual bool full()  const = 0;
      virtual bool empty() const = 0;
   };

   template <typename Key,typename Value,typename Container>
   class DtInsertMapCollector : public DtMapCollector<Key,Value>
   {
   public:
      DtInsertMapCollector(Container& container) :
         DtMapCollector<Key,Value>(),
         myContainer(container) {}

      virtual void add(Key key,Value value)
      {
         myContainer.insert(key,value);
      }

      virtual bool containes(Key key)
      {
         return myContainer.find(key) != myContainer.end();
      }

      virtual int size()const
      {
         return myContainer.size();
      }

      virtual bool full() const
      {
         return false;
      }

      virtual bool empty() const
      {
         return myContainer.empty();
      }

   protected:
      Container& myContainer;
   };

}

#endif