MultiMap.hpp

Go to the documentation of this file.

// ANNA - Anna is Not Nothingness Anymore                                                         //
//                                                                                                //
// (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo                         //
//                                                                                                //
// See project site at http://redmine.teslayout.com/projects/anna-suite                           //
// See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //


#ifndef anna_core_util_MultiMap_hpp
#define anna_core_util_MultiMap_hpp

// Solaris std::multimap is missing !!

#include <algorithm>
#include <functional>
#include <vector>

#include <anna/core/RuntimeException.hpp>
#include <anna/config/defines.hpp>

namespace anna {

template < typename T, typename SortBy, typename TKey = int > class MultiMap : public std::vector <T*> {
  struct LessT : public std::binary_function <T*, T*, bool> {
    bool operator()(const T* first, const T* second) const {
      return SortBy::value(first) < SortBy::value(second);
    }
  };

  // El orden de los operandos está impuesto por cómo se invoca al operator() desde stl_algo.h (2685).
  struct LessKey : public std::binary_function <T*, TKey, bool> {
    bool operator()(const T* _vv, const TKey& searched) const {
      return SortBy::value(_vv) < searched;
    }
  };

public:
  typedef typename std::vector <T*> container;
  typedef typename container::iterator iterator;
  typedef typename container::const_iterator const_iterator;
  typedef typename container::value_type value_type;

  MultiMap() {;}

  explicit MultiMap(const MultiMap& other) : container(other) {}

  virtual ~MultiMap() { this->clear(); }

  bool add(T* _vv)
  noexcept(false) {
    if(_vv == NULL)
      return false;

    iterator maxii = this->end();
    iterator ii = std::upper_bound(this->begin(), maxii, _vv, a_lessT);

    if(ii == maxii)
      this->push_back(_vv);
    else
      this->insert(ii, _vv);

    return true;
  }

  bool contains(const T* _vv) const { return (_vv == NULL) ? false : (find(SortBy::value(_vv)) != NULL); }

  void clearAndDestroy() {
    for(iterator ii = this->begin(), maxii = this->end(); ii != maxii; ii ++)
      delete data(ii);

    this->clear();
  }

  T* erase(const T* _vv)
  noexcept(false) {
    if(_vv == NULL)
      return NULL;

    iterator maxii = this->end();
    iterator ii = std::lower_bound(this->begin(), this->end(), _vv, a_lessT);

    if(ii == maxii)
      return NULL;

    T* dd = data(ii);

    if(!(SortBy::value(_vv) == SortBy::value(dd)))
      return NULL;

    container::erase(ii);
    return dd;
  }

  iterator erase_iterator(iterator ii) { return container::erase(ii); }

  T* find(const TKey& key)
  {
    iterator maxii = this->end();
    iterator ii = lower_bound(this->begin(), maxii, key, a_lessKey);

    if(ii == maxii)
      return NULL;

    T* pos = data(ii);
    return (SortBy::value(pos) == key) ? pos : NULL;
  }

  iterator find_iterator(const TKey& key)
  {
    return lower_bound(this->begin(), this->end(), key, a_lessKey);
  }

  const T* find(const TKey& key) const {
    return const_cast <MultiMap <T, SortBy, TKey>*>(this)->find(key);
  }

  static T* data(iterator ii) { return *ii; }

  static const T* data(const_iterator ii) { return *ii; }

private:
  LessT a_lessT;
  LessKey a_lessKey;
};

}

#endif