InterfaceBase.h

// -*- C++ -*-
//
// InterfaceBase.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_InterfaceBase_H
#define ThePEG_InterfaceBase_H
// This is the declaration of the InterfaceBase and RefInterfaceBase classes.
 
#include "ThePEG/Config/ThePEG.h"
#include "InterfaceBase.fh"
#include "InterfaceBase.xh"
#include "ThePEG/Utilities/Named.h"
#include "ThePEG/Utilities/ClassTraits.h"
#include "Interface.h"
 
namespace ThePEG {
 
class InterfaceBase: public Named {
 
public:
 
  InterfaceBase(string newName, string newDescription,
                string newClassName,
                const type_info & newTypeInfo, bool depSafe,
                bool readonly);
 
  virtual ~InterfaceBase() {}
 
  string tag(int pos = -1) const;
 
  virtual string
  exec(InterfacedBase & ib, string action, string arguments) const
    = 0;
 
  virtual string type() const = 0;
 
  virtual bool notDefault(InterfacedBase &) const;
 
  map<string,string> & objectDefaults(InterfacedBase &) const;
 
  virtual void rebind(InterfacedBase &,
                      const TranslationMap &,
                      const IVector & = IVector()) const {}
 
  virtual IVector getReferences(const InterfacedBase &) const {
    return IVector();
  }
 
  string description() const { return theDescription; }
 
  virtual string fullDescription(const InterfacedBase & ib) const;
 
  virtual void doxygenDescription(ostream & stream) const;
 
  virtual string doxygenType() const = 0;
 
  string className() const { return theClassName; }    
 
  bool dependencySafe() const { return isDependencySafe; } 
 
  void setDependencySafe() { isDependencySafe = true; } 
 
  void setDependencySensitive() { isDependencySafe = false; } 
 
  bool readOnly() const { return isReadOnly && (!NoReadOnly); } 
 
  void setReadOnly() { isReadOnly = true; } 
 
  void setReadWrite() { isReadOnly = false; } 
 
  bool anonymous() const { return description().empty(); } 
 
  double rank() const { return theRank; } 
 
  void rank(double r) { theRank = r; } 
 
  void setHasDefault(bool b) {
    hasDefault = b;
  }
 
  static bool NoReadOnly;
 
private:
 
  string theDescription;
 
  string theClassName;
 
  double theRank;
 
protected:
 
  bool hasDefault;
 
  mutable bool isDependencySafe;
 
  mutable bool isReadOnly;
 
 
};
 
 
class RefInterfaceBase: public InterfaceBase {
 
public:
 
   RefInterfaceBase(string newName, string newDescription,
                          string newClassName, const type_info & newTypeInfo,
                          string newRefClassName,
                          const type_info & newRefTypeInfo,
                          bool depSafe, bool readonly,
                          bool norebind, bool nullable, bool defnull);
 
  string refClassName() const { return theRefClassName; } 
 
  const type_info & refTypeInfo() const { return theRefTypeInfo; } 
 
  bool noRebind() const { return dontRebind; } 
 
  void setNoRebind() { dontRebind = true; } 
 
  void setRebind() { dontRebind = false; } 
 
  bool noNull() const { return !isNullable; } 
 
  void setNullable() { isNullable = true; } 
 
  void setNotNullable() { isNullable = false; } 
 
  bool defaultIfNull() const { return theDefaultIfNull; } 
 
  void setDefaultIfNull() { theDefaultIfNull = true; } 
 
  void setNoDefaultIfNull() { theDefaultIfNull = false; } 
 
private:
 
  string theRefClassName;
 
  const type_info & theRefTypeInfo;
 
  bool dontRebind;
 
  bool isNullable;
 
  bool theDefaultIfNull;
 
};
 
inline double operator/(string,string) { return 0.0; }
 
inline string operator*(double,string) { return ""; }
 
}
 
#endif /* ThePEG_InterfaceBaseH */