BaseRepository.h

// -*- C++ -*-
//
// BaseRepository.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_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 void prependReadDir(string);

  static void appendReadDir(string);


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

  static void update();

  template<typename Cont>
  static void clearAll(const Cont & c) 
  {  
    for_each(c, mem_fun(&InterfacedBase::clear));
  }

  template<typename Cont>
  static void resetAll(const Cont & c) 
  {  
    for_each(c, mem_fun(&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 */

---