Registry.h

Go to the documentation of this file.

#ifndef REGISTRY_H
#define REGISTRY_H

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

#include <TNamed.h>

class RegistryItem;
class type_info;

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

    explicit Registry(bool readonly = true);

    Registry(const Registry& rhs);

    virtual ~Registry();

    Registry& operator=(const Registry& rhs); 

    void Merge(const Registry& 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;
    virtual std::ostream& PrettyPrint(std::ostream& os) const;
    
    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, Registry& r) const;

    const 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;
    Registry    GetRegistry(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, Registry r);

    class RegistryKey
    {
        
    public:
        RegistryKey();
        RegistryKey(const Registry* r);
        virtual ~RegistryKey();
        
        const char* operator()(void);
    
    private:
        
        const Registry* fReg;
        std::map<std::string,RegistryItem*>::iterator fIt;
    };                              // end of class RegistryKey

    RegistryKey Key(void) const;

private:
    bool fValuesLocked;
    bool fKeysLocked;
    ErrorHandler fErrorHandler;  
#ifndef __CINT__
    friend class RegistryKey;
//    template<class T> bool SetPtr(std::string key, T* val);
    tRegMap fMap;
#endif
    bool fDirty;

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

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


#include "Registry/RegistryItemXxx.h"

#endif  // REGISTRY_H

---