CollectorMap.h

Go to the documentation of this file.

#ifndef CollectorMap_h
#define CollectorMap_h

#include <cctype>
#include <string>
#include <map>
#include <algorithm>
#include <functional>
#include <sstream>
#include <iomanip>
#include <exception>
#include "iString.h"
#include "iException.h"
#include <gsl/gsl_math.h>


namespace Isis {

  template <typename K> struct SimpleCompare {

    bool operator()(const K &v1, const K &v2) const {
      return (v1 < v2);
    }

  };

  template <typename K> struct NoCaseStringCompare {

    bool operator()(const K &v1, const K &v2) const {
      return (iString::DownCase(v1) < iString::DownCase(v2));
    }

  };

  template <typename K> struct RobustFloatCompare {

    bool operator()(const K &v1, const K &v2) const {
      return (gsl_fcmp(v1, v2, -1.0E-6) < 0);
    }

  };

  template <typename T> struct NoopRemoval {
    protected:

      void destroy(T *element) {
        return;
      }

  };

  template <typename T> struct PointerRemoval {
    protected:

      void destroy(T *element) {
        delete(*element);
        return;
      }

  };

  template <typename T> struct ArrayRemoval {
    protected:

      void destroy(T *element) {
        delete [](*element);
        return;
      }

  };


  template <typename T> struct DefaultCopy {
    protected:

      const T &copy(const T &src) const {
        return (src);
      }

  };


  template <typename T> struct PointerCopy {
    protected:
      T copy(const T &src)  const {
        return (allocate(*(src)));
      }

    private:
      template <typename P>
      P *allocate(const P &obj) const {
        return (new P(obj));
      }
  };



  template < typename K, typename T,
           template <class> class ComparePolicy = SimpleCompare,
           template <class> class RemovalPolicy = NoopRemoval,
           template <class> class CopyPolicy = DefaultCopy
           >
  class CollectorMap : public RemovalPolicy<T>, public CopyPolicy<T> {
    public:
      typedef T                                      CollectorType; 

      typedef std::multimap<K, CollectorType, ComparePolicy<K> > CollectorList;
      typedef typename CollectorList::iterator       CollectorIter;
      typedef typename CollectorList::const_iterator CollectorConstIter;

      enum KeyPolicy { UniqueKeys,     
                       DuplicateKeys   
                     };

      CollectorMap() : _keyPolicy(UniqueKeys) { }

      CollectorMap(const KeyPolicy &keyPolicy) : _keyPolicy(keyPolicy) { }

      virtual ~CollectorMap() {
        selfDestruct();
      }

      CollectorMap(const CollectorMap &cmap) {
        _keyPolicy = cmap._keyPolicy;
        CollectorConstIter cItr;
        for(cItr = cmap._list.begin() ; cItr != cmap._list.end() ; cItr++) {
          _list.insert(std::make_pair(cItr->first, cmap.copy(cItr->second)));
        }
      }

      CollectorMap &operator=(const CollectorMap &cmap) {
        if(&cmap != this) {
          selfDestruct();
          _keyPolicy = cmap._keyPolicy;
          CollectorConstIter cItr;
          for(cItr = cmap._list.begin() ; cItr != cmap._list.end() ; cItr++) {
            _list.insert(std::make_pair(cItr->first, cmap.copy(cItr->second)));
          }
        }
        return (*this);
      }

      int size() const {
        return (_list.size());
      }

      int count(const K &key) const {
        return (_list.count(key));
      }

      void add(const K &key, const T &value) {
        if(_keyPolicy == UniqueKeys) remove(key);
        _list.insert(std::make_pair(key, value));
        return;
      }

      bool exists(const K &key) const {
        CollectorConstIter cItr = _list.find(key);
        return (cItr != _list.end());
      }

      T &get(const K &key) throw(iException &) {
        CollectorIter cItr = _list.find(key);
        if(cItr == _list.end()) {
          std::string mess = "Requested value does not exist!";
          throw iException::Message(iException::Programmer, mess.c_str(), _FILEINFO_);
        }
        return (cItr->second);
      }

      const T &get(const K &key) const throw(iException &) {
        CollectorConstIter cItr = _list.find(key);
        if(cItr == _list.end()) {
          std::string mess = "Requested value does not exist!";
          throw iException::Message(iException::Programmer, mess.c_str(), _FILEINFO_);
        }
        return (cItr->second);
      }

      int index(const K &key) const {
        CollectorConstIter cItr = _list.lower_bound(key);
        if(cItr == _list.end()) {
          return (-1);
        }
        else {
          return (std::distance(_list.begin(), cItr));
        }
      }

      T &getNth(int nth) throw(iException &) {
        CollectorIter cItr;
        int i;
        for(cItr = _list.begin(), i = 0 ; cItr != _list.end() ; ++cItr, i++) {
          if(i == nth) break;
        }

        if(cItr == _list.end()) {
          std::ostringstream mess;
          mess << "Requested index (" << nth << ") out of range" << std::endl;
          throw iException::Message(iException::Programmer, mess.str(), _FILEINFO_);
        }
        return (cItr->second);
      }

      const T &getNth(int nth) const throw(iException &) {
        CollectorConstIter cItr;
        int i;
        for(cItr = _list.begin(), i = 0 ; cItr != _list.end() ; ++cItr, i++) {
          if(i == nth) break;
        }
        if(cItr == _list.end()) {
          std::ostringstream mess;
          mess << "Requested index (" << nth << ") out of range" << std::endl;
          throw iException::Message(iException::Programmer, mess.str(), _FILEINFO_);
        }
        return (cItr->second);
      }

      const K &key(int nth) const throw(iException &) {
        CollectorConstIter cItr;
        int i;
        for(cItr = _list.begin(), i = 0 ; cItr != _list.end() ; ++cItr, i++) {
          if(i == nth) break;
        }
        if(cItr == _list.end()) {
          std::ostringstream mess;
          mess << "Requested key index (" << nth << ") out of range" << std::endl;
          throw iException::Message(iException::Programmer, mess.str(), _FILEINFO_);
        }
        return (cItr->first);
      }

      int remove(const K &key) {
        CollectorIter Itr1 = _list.lower_bound(key);
        if(Itr1 == _list.end()) return (0);

        CollectorIter Itr2 = _list.upper_bound(key);
        while(Itr1 != Itr2) {
          destroy(&Itr1->second);
          ++Itr1;
        }
        return (_list.erase(key));
      }

      CollectorConstIter begin() const {
        return _list.begin();
      }

      CollectorConstIter end() const {
        return _list.end();
      }

      CollectorIter begin() {
        return _list.begin();
      }

      CollectorIter end() {
        return _list.end();
      }

    private:
      KeyPolicy      _keyPolicy;  
      CollectorList  _list;       

      void selfDestruct() {
        CollectorIter itr;
        for(itr = _list.begin() ; itr != _list.end() ; itr++) {
          destroy(&itr->second);
        }
        _list.clear();
      }


  };

};
#endif