ObjectIndexer.h

// -*- C++ -*-
//
// ObjectIndexer.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2019 Leif Lonnblad
//
// ThePEG is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef THEPEG_ObjectIndexer_H
#define THEPEG_ObjectIndexer_H
// This is the declaration of the ObjectIndexer class.
 
#include "ThePEG/Config/ThePEG.h"
#include <limits>
 
namespace ThePEG {
 
template <typename IntT, typename ObjT, IntT NoIndex = static_cast<IntT>(-1)>
class ObjectIndexer {
 
public:
 
  ThePEG_DECLARE_TEMPLATE_POINTERS(ObjT,TPtr);
 
  typedef map<IntT,tTPtr> IndexObjectMap;
 
  typedef map<TPtr,IntT> ObjectIndexMap;
 
public:
 
  ObjectIndexer(): next(0) {}
 
  IntT operator()(tTPtr o) {
    typename ObjectIndexMap::iterator it = objectIndex.find(o);
    if ( it == objectIndex.end() ) {
      IntT i = next++;
      objectIndex[o] = i;
      indexObject[i] = o;
      return i;
    } else
      return it->second;
  }
 
  IntT operator()(tTPtr o) const {
    return find(o);
  }
 
  IntT find(tTPtr o) const {
    typename ObjectIndexMap::const_iterator it = objectIndex.find(o);
    return it == objectIndex.end()? NoIndex: it->second;
  }
 
  tTPtr operator()(IntT i) {
    if ( i == NoIndex ) return tTPtr();
    typename IndexObjectMap::iterator it = indexObject.find(i);
    if ( it == indexObject.end() ) {
      TPtr o = new_ptr<ObjT>();
      objectIndex[o] = i;
      indexObject[i] = o;
      next = max(next, i + 1);
      return o;
    } 
    else
      return it->second;
  }
 
  tTPtr operator()(IntT i) const {
    return find(i);
  }
 
  tTPtr find(IntT i) const {
    typename IndexObjectMap::const_iterator it = indexObject.find(i);
    return it == indexObject.end()? tTPtr(): it->second;
  }
 
  void operator()(IntT i, tTPtr o) {
    if ( i == NoIndex ) return;
    typename IndexObjectMap::iterator iit = indexObject.find(i);
    if ( iit != indexObject.end() ) objectIndex.erase(iit->second);
    typename ObjectIndexMap::iterator oit = objectIndex.find(o);
    if ( oit != objectIndex.end() ) indexObject.erase(oit->second);
    objectIndex[o] = i;
    indexObject[i] = o;
    next = max(next, i + 1);
  }
 
  bool included(tTPtr o) const {
    return objectIndex.find(o) != objectIndex.end();
  }
 
  bool included(IntT i) const {
    return indexObject.find(i) != indexObject.end();
  }
 
  void clear() {
    indexObject.clear();
    objectIndex.clear();
  }
 
  bool empty() const {
    return indexObject.empty() && objectIndex.empty();
  }
 
private:
 
  IndexObjectMap indexObject;
 
  ObjectIndexMap objectIndex;
 
  IntT next;
 
private:
 
  ObjectIndexer & operator=(const ObjectIndexer &) = delete;
 
};
 
}
 
#endif /* THEPEG_ObjectIndexer_H */