FairRegistry.h

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file FairRegistry.h

#ifndef FAIRREGISTRY_H
#define FAIRREGISTRY_H

#include <iostream>
#include <map>
#include <string>

//#include <typeinfo>

#include <TNamed.h>

class FairRegistryItem;
//class type_info;

class FairRegistry : public TNamed
{
  public:
    typedef std::map<std::string,FairRegistryItem*> tRegMap;
    typedef void (*ErrorHandler)(void);

    explicit FairRegistry(bool readonly = true);

    FairRegistry(const FairRegistry& rhs);

    virtual ~FairRegistry();

    FairRegistry& operator=(const FairRegistry& rhs);

    void Merge(const FairRegistry& rhs);

    unsigned int Size() const { return fMap.size(); }

    bool KeyExists(const char* key) const;
    void RemoveKey(const char* key);

    void Clear(Option_t* option=""); //*MENU*

    void Dump(void) const;      //*MENU*

    virtual std::ostream& PrintStream(std::ostream& os) const;
    virtual std::istream& ReadStream(std::istream& is);

    // TObject::Print().
    virtual void Print(Option_t* option="") const; //*MENU*
    virtual std::ostream& PrettyPrint(std::ostream& os) const;

    // TObject::Browse()
    // The default implementation crashes TBrowser, doing nothing is better.
    virtual void Browse(TBrowser*) {}

    virtual bool ValuesLocked(void) const { return fValuesLocked; }
    virtual void LockValues(void) { fValuesLocked = true; } //*MENU*
    virtual void UnLockValues(void) { fValuesLocked = false; } //*MENU*

    virtual bool KeysLocked(void) const { return fKeysLocked; }
    virtual void LockKeys(void) { fKeysLocked = true; } //*MENU*
    virtual void UnLockKeys(void) { fKeysLocked = false; } //*MENU*

    void SetDirty(bool is_dirty = true) { fDirty = is_dirty; }
    bool IsDirty() { return fDirty; }


    void SetErrorHandler(ErrorHandler eh) { fErrorHandler = eh; }


//    bool Get(const char* key, bool& b) const;
    bool Get(const char* key, char& c) const;
    bool Get(const char* key, const char*& s) const;
    bool Get(const char* key, int& i) const;
    bool Get(const char* key, double& d) const;
    bool Get(const char* key, FairRegistry& r) const;

    const std::type_info& GetType(const char* key) const;
    std::string GetTypeAsString(const char* key) const;
    std::string GetValueAsString(const char* key) const;


//    bool        GetBool(const char* key) const;
    char        GetChar(const char* key) const;
    const char* GetCharString(const char* key) const;
    int         GetInt(const char* key) const;
    double      GetDouble(const char* key) const;
    FairRegistry    GetFairRegistry(const char* key) const;

//    bool Set(const char* key, bool b);
    bool Set(const char* key, char c);
    bool Set(const char* key, const char* s);
    bool Set(const char* key, int i);
    bool Set(const char* key, double d);
    bool Set(const char* key, FairRegistry r);

    class FairRegistryKey
    {

      public:
        FairRegistryKey();
        FairRegistryKey(const FairRegistry* r);
        virtual ~FairRegistryKey();

        const char* operator()(void);

      private:

        const FairRegistry* fReg;
        std::map<std::string,FairRegistryItem*>::iterator fIt;

        //     FairRegistryKey(const FairRegistryKey&);
        FairRegistryKey operator=(const FairRegistryKey&);

    };                              // end of class RegistryKey

    FairRegistryKey Key(void) const;

  private:
    bool fValuesLocked;
    bool fKeysLocked;
    ErrorHandler fErrorHandler;  
#ifndef __CINT__
    friend class FairRegistryKey;
    tRegMap fMap;
#endif
    bool fDirty;

    ClassDef(FairRegistry,1)
};                              // end of class Registry

inline std::ostream& operator<<(std::ostream& os, const FairRegistry& r) { return r.PrintStream(os); }


#include "FairRegistryItemXxx.h"

#endif  // FAIRREGISTRY_H