InterfaceBase.h

// -*- C++ -*-
//
// InterfaceBase.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2007 Leif Lonnblad
//
// ThePEG is licenced under version 2 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() {}

  virtual string
  exec(InterfacedBase & ib, string action, string arguments) const
    = 0;

  virtual string type() const = 0;

  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; } 

  static bool NoReadOnly;

private:

  string theDescription;

  string theClassName;

  double theRank;

protected:

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

---