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 */