CollectorMap.h

#ifndef CollectorMap_h
#define CollectorMap_h
/* SPDX-License-Identifier: CC0-1.0 */
#include <cctype>
#include <QString>
#include <map>
#include <algorithm>
#include <functional>
#include <sstream>
#include <iomanip>
#include <exception>
#include "IException.h"
#include "IString.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 {
 
    // defines used for cross platform suppression of unused parameter warning. This will prevent
    // distroy() from causing unused parameter warnings in clang. This is done for the purpose
    // of porting ISIS to OSX 10.11
    // #define MON_Internal_UnusedStringify(macro_arg_string_literal) #macro_arg_string_literal
    // #define MONUnusedParameter(macro_arg_parameter) _Pragma(MON_Internal_UnusedStringify(unused(macro_arg_parameter)))
 
    protected:
 
      void destroy(T *element) {
        // arbitrary cast type to suppress unused parameter warnings generated
        // by clang when building on mac
        (void)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) {
        CollectorIter cItr = _list.find(key);
        if(cItr == _list.end()) {
          QString mess = "Requested value does not exist!";
          throw IException(IException::Programmer, mess, _FILEINFO_);
        }
        return (cItr->second);
      }
 
      const T &get(const K &key) const {
        CollectorConstIter cItr = _list.find(key);
        if(cItr == _list.end()) {
          QString mess = "Requested value does not exist!";
          throw IException(IException::Programmer, mess, _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) {
        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(IException::Programmer, mess.str(), _FILEINFO_);
        }
        return (cItr->second);
      }
 
      const T &getNth(int nth) const {
        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(IException::Programmer, mess.str(), _FILEINFO_);
        }
        return (cItr->second);
      }
 
      const K &key(int nth) const {
        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(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) {
          this->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++) {
          this->destroy(&itr->second);
        }
        _list.clear();
      }
 
 
  };
 
};
#endif