BaseRepository.h

// -*- C++ -*-
//
// BaseRepository.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_BaseRepository_H
#define ThePEG_BaseRepository_H
// This is the declaration of the BaseRepository class.
 
#include "ThePEG/Config/ThePEG.h"
#include "BaseRepository.xh"
#include "ThePEG/Interface/InterfaceBase.fh"
#include "ThePEG/Interface/ClassDocumentation.fh"
#include "ThePEG/Interface/InterfacedBase.h"
#include "ThePEG/Utilities/ClassDescription.fh"
 
namespace ThePEG {
 
class BaseRepository {
 
public:
 
  typedef StringSet DirectorySet;
 
  typedef vector<string> StringVector;
 
  typedef set<const InterfaceBase *> InterfaceSet;
 
  typedef map<const ClassDescriptionBase *, InterfaceSet> TypeInterfaceMap;
 
  typedef map<const ClassDescriptionBase *, const ClassDocumentationBase *>
    TypeDocumentationMap;
 
public:
 
  static string exec(string cmd, ostream &);
 
  static void Register(const InterfaceBase &, const type_info &);
 
  static void Register(const ClassDocumentationBase &, const type_info &);
 
  static void Register(IBPtr);
 
  static void Register(IBPtr, string name);
 
  static void remove(tIBPtr);
 
  static string remove(const ObjectSet & rmset);
 
  static void rename(tIBPtr object, string newName);
 
  static void CreateDirectory(string);
 
  static void CheckObjectDirectory(string);
 
  static void CheckDirectory(string);
 
  static void DirectoryAppend(string &);
 
  static void ChangeDirectory(string name);
 
  static void PushDirectory(string name);
 
  static void PopDirectory();
 
  static vector<string> & globalLibraries();
 
 
protected:
 
  static stack<string> & currentReadDirStack();
 
  static vector<string> & readDirs();
 
public:
 
  static const vector<string> & listReadDirs();
 
  static void prependReadDir(string);
  
  static void prependReadDir(const std::vector<std::string>& dirs);
 
  static void appendReadDir(string);
  
  static void appendReadDir(const std::vector<std::string>& dirs);
 
 
  template <typename T>
  static typename Ptr<T>::pointer GetPtr(const T &);
 
  template <typename PtrType>
  static PtrType GetPtr(string);
 
  template <typename PtrType>
  static PtrType GetObject(string);
 
  static IBPtr GetPointer(string);
 
  static IVector SearchDirectory(string name, string className = "");
 
  static IBPtr TraceObject(string name);
 
  static string GetInterfacedBaseClasses(const ClassDescriptionBase * cdb);
 
  static IBPtr getObjectFromNoun(string noun);
 
  static IVector GetObjectsReferringTo(IBPtr);
 
  static IVector DirectReferences(IBPtr);
 
  static void addReferences(tIBPtr obj, ObjectSet & refs);
 
  static InterfaceMap getInterfaces(const type_info & ti, bool all = true);
 
  static const InterfaceBase * FindInterface(IBPtr object, string name);
 
  static string getInterfaceFromNoun(string noun);
 
  static string getPosArgFromNoun(string noun);
 
  template <typename Cont>
  static vector< pair<IBPtr, const InterfaceBase *> >
  getNonDefaultInterfaces(const Cont &);
 
 
  static void update();
 
  template<typename Cont>
  static void clearAll(const Cont & c) 
  {  
    for_each(c, mem_fn(&InterfacedBase::clear));
  }
 
  template<typename Cont>
  static void resetAll(const Cont & c) 
  {  
    for_each(c, mem_fn(&InterfacedBase::reset));
  }
 
  static void readSetup(tIBPtr ip, istream & is);
 
  static void lock(tIBPtr ip) { ip->lock(); }
 
  static void unlock(tIBPtr ip) { ip->unlock(); }
 
  static const ClassDocumentationBase * getDocumentation(tcIBPtr ip);
 
  static string getModelDescription(tcIBPtr ip);
 
  static string getModelReferences(tcIBPtr ip);
 
  static void cout(ostream & os) { coutp() = &os; }
 
  static ostream & cout() { return *coutp(); }
 
  static void cerr(ostream & os) { cerrp() = &os; }
 
  static ostream & cerr() { return *cerrp(); }
 
  static void clog(ostream & os) { clogp() = &os; }
 
  static ostream & clog() { return *clogp(); }
 
protected:
 
  template <typename T>
  static typename Ptr<T>::pointer clone(const T & t);
 
  template <typename T>
  static typename Ptr<T>::pointer fullclone(const T & t);
 
  static void rebind(InterfacedBase & obj, const TranslationMap & trans,
                     const IVector & defaults);
  
 
  static void addInterfaces(const ClassDescriptionBase &,
                            InterfaceMap &, bool all = true);
 
  static ObjectMap & objects();
 
  static ObjectSet & allObjects();
 
  static TypeInterfaceMap & interfaces();
 
  static TypeDocumentationMap & documentations();
 
  static DirectorySet & directories();
 
  static StringVector & directoryStack();
 
  static bool & updating();
 
  static ostream *& coutp();
 
  static ostream *& cerrp();
  static ostream *& clogp();
 
};
 
 
}
 
#ifndef ThePEG_TEMPLATES_IN_CC_FILE
#include "BaseRepository.tcc"
#endif
 
#endif /* ThePEG_BaseRepository_H */