RefVector.h

// -*- C++ -*-
//
// RefVector.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_RefVector_H
#define ThePEG_RefVector_H
// This is the declaration of the RefVector and RefVectorBase classes.
 
#include "ThePEG/Config/ThePEG.h"
#include "InterfaceBase.h"
#include "RefVector.xh"
#include "RefVector.fh"
 
namespace ThePEG {
 
class RefVectorBase: public RefInterfaceBase {
 
public:
 
  RefVectorBase(string newName, string newDescription,
                string newClassName,
                const type_info & newTypeInfo,
                string newRefClassName,
                const type_info & newRefTypeInfo, 
                int newSize, bool depSafe,
                bool readonly, bool norebind, bool nullable, bool defnull);
 
  virtual string exec(InterfacedBase & ib, string action,
                      string arguments) const;
 
  virtual string fullDescription(const InterfacedBase & ib) const;
 
  virtual string type() const;
 
  virtual string doxygenType() const;
 
  virtual void set(InterfacedBase & ib, IBPtr ip, int i, bool chk = true)
    const = 0;
 
  virtual void insert(InterfacedBase & ib, IBPtr ip, int i, bool chk = true)
    const = 0;
 
  virtual void erase(InterfacedBase & ib, int i)
    const = 0;
 
  virtual void clear(InterfacedBase & ib)
    const = 0;
 
  virtual IVector get(const InterfacedBase & ib) const
    = 0;
 
  virtual bool check(const InterfacedBase & ib, cIBPtr ip, int i) const
    = 0;
 
  virtual void rebind(InterfacedBase & ib, const TranslationMap & trans,
                      const IVector & defs) const;
 
  virtual IVector getReferences(const InterfacedBase & ib) const;
 
  int size() const { return theSize; }
 
  void setSize(int sz) { theSize = sz; }
 
  void setVariableSize() { theSize = 0; }
 
private:
 
  int theSize;
 
};
 
 
template <class T, class R>
class RefVector: public RefVectorBase {
 
public:
 
  typedef typename Ptr<R>::pointer RefPtr;
  typedef typename Ptr<R>::const_pointer cRefPtr;
  typedef void (T::*SetFn)(RefPtr, int);
  typedef void (T::*InsFn)(RefPtr, int);
  typedef void (T::*DelFn)(int);
  typedef bool (T::*CheckFn)(cRefPtr, int) const;
  typedef vector<RefPtr> (T::*GetFn)() const;
  typedef vector<RefPtr> T::* Member;
 
public:
 
  RefVector(string newName, string newDescription,
            Member newMember, int newSize, bool depSafe = false,
            bool readonly = false, bool rebind = true, bool nullable = true,
            SetFn newSetFn = 0, InsFn newInsFn = 0, DelFn newDelFn = 0,
            GetFn newGetFn = 0, CheckFn newCheckFn = 0);
 
  RefVector(string newName, string newDescription,
            Member newMember, int newSize, bool depSafe,
            bool readonly, bool rebind, bool nullable, bool defnull,
            SetFn newSetFn = 0, InsFn newInsFn = 0, DelFn newDelFn = 0,
            GetFn newGetFn = 0, CheckFn newCheckFn = 0);
 
  virtual void set(InterfacedBase & ib, IBPtr ip, int i, bool chk = true)
    const;
 
  virtual void insert(InterfacedBase & ib, IBPtr ip, int i, bool chk = true)
    const;
 
  virtual void erase(InterfacedBase & ib, int i)
    const;
 
  virtual void clear(InterfacedBase & ib)
    const;
 
  virtual IVector get(const InterfacedBase & ib) const
   ;
 
  virtual bool check(const InterfacedBase & ib, cIBPtr, int i) const
   ;
 
  void setSetFunction(SetFn sf) { theSetFn = sf; }
 
  void setInsertFunction(InsFn ifn) { theInsFn = ifn; }
 
  void setGetFunction(GetFn gf) { theGetFn = gf; }
 
  void setEraseFunction(DelFn df) { theDelFn = df; }
 
  void setCheckFunction(CheckFn cf) { theCheckFn = cf; }
 
private:
 
  Member theMember;
 
  SetFn theSetFn;
 
  InsFn theInsFn;
 
  DelFn theDelFn;
 
  GetFn theGetFn;
 
  CheckFn theCheckFn;
 
};
 
}
 
#include "RefVector.tcc"
 
#endif /* ThePEG_RefVector_H */