Registry.cxx

Go to the documentation of this file.

#include <map>
#include <iomanip>

#include "TBuffer.h"
#include "TObject.h"

#include "Registry.h"
#include "RegistryItem.h"

#include <Util/UtilStream.h>
using namespace Util;

#include <MessageService/MsgService.h>
CVSID("$Id: Registry.cxx,v 1.51 2008/09/25 13:06:57 bckhouse Exp $");

#include <typeinfo>
#include <iostream>
#include <sstream>
#include <cassert>
using namespace std;

ClassImp(Registry)



//......................................................................

Registry::Registry(bool readonly /* = true */) 
    : fValuesLocked(readonly), 
      fKeysLocked(false),
      fErrorHandler(0)
{
    MSG("Registry",Msg::kVerbose) << "Creating Registry at " << (void * ) this << endl;
    this->SetDirty();
}

// Deep copy constructor
Registry::Registry(const Registry& rhs) : TNamed(rhs)
{
    MSG("Registry",Msg::kVerbose) << "Creating Registry at " << (void * ) this << endl;
    RegistryKey rk = rhs.Key();
    const char* s;

    while ( (s = rk()) ) fMap[s] = rhs.fMap.find(s)->second->Dup();

    fValuesLocked = rhs.fValuesLocked;
    fKeysLocked   = rhs.fKeysLocked;
    this->SetDirty();
    this->SetName(rhs.GetName());
}

Registry& Registry::operator=(const Registry& rhs)
{
    if (this == &rhs) return *this;

    UnLockValues();
    UnLockKeys();

    // If we are already holding something - clear it.
    if (Size() != 0) Clear();

    RegistryKey rk = rhs.Key();
    const char* s;

    while ( (s = rk()) ) fMap[s] = rhs.fMap.find(s)->second->Dup();

    fValuesLocked = rhs.fValuesLocked;
    fKeysLocked   = rhs.fKeysLocked;
    this->SetDirty();
    this->SetName(rhs.GetName());
    
    // Do like copy ctor.
    return *this;
}

void Registry::Merge(const Registry& rhs)
{
    if (this == &rhs) return;

    RegistryKey rk = rhs.Key();
    const char* s;
    while ( (s = rk()) ) {
        tRegMap::iterator mit = fMap.find(s);
        bool exists = mit != fMap.end();
        
        if (fKeysLocked && !exists) {
            MSG("Registry",Msg::kWarning) 
                << "Merge: can't, add new key " << s <<", keys locked."
                << "  merger=" << this->GetName() 
                << ", mergie=" << rhs.GetName() << endl;
            continue;
        }        
        if (exists && fValuesLocked) {
            MSG("Registry",Msg::kWarning) 
                << "Merge: can't, merge key " << s <<", values locked."
                << "  merger=" << this->GetName() 
                << ", mergie=" << rhs.GetName() << endl;
            continue;
        }
        if (exists) delete mit->second;
        fMap[s] = rhs.fMap.find(s)->second->Dup();
    }
    this->SetDirty();
}

bool Registry::KeyExists(const char* key) const
{
    return fMap.find(key) != fMap.end();
}

void Registry::RemoveKey(const char* key)
{
    tRegMap::iterator dead = fMap.find(key);
    if (dead == fMap.end()) return;
    fMap.erase(dead);
    delete dead->second;
    this->SetDirty();
}

void Registry::Clear(Option_t * /* option */)
{
    if (fValuesLocked || fKeysLocked) {
        MSG("Registry",Msg::kWarning) 
            << "Clear: can't, there are locks in \""
            << this->GetName() << "\"\n";
        return;
    }

    tRegMap::iterator mit = fMap.begin();
    while (mit != fMap.end()) {
        delete mit->second;
        ++mit;
    }
    fMap.clear();
    this->SetDirty();
}

void Registry::Dump(void) const
{
    this->TNamed::Dump();
    tRegMap::const_iterator mit = fMap.begin();
    MSG("Registry",Msg::kInfo) 
        << "Registry: `" << this->GetName() << "', "
        << this->Size() << " entries."
        << " (Locks: [Keys|Values] `key', `value'):\n";
    while (mit != fMap.end()) {
        MSG("Registry",Msg::kInfo) 
            << " [" << (fKeysLocked ? 'L' : 'U') << "|"
            << (fValuesLocked ? 'L' : 'U') << "] "
            << "`" << mit->first << "', `";
        mit->second->Dump();
        MSG("Registry",Msg::kInfo) << "'\n";
        ++mit;
    }

}

ostream& Registry::PrettyPrint(ostream& os) const
{
    static int print_depth = 0;

    // print (to cout) the registry
    tRegMap::const_iterator mit = this->fMap.begin();
    for(int i=0; i<print_depth; ++i) os << " ";
    os << "\"" << this->GetName() << "\", "
       << this->Size() << " entries." 
       << " keys " << (this->fKeysLocked ? "locked" : "unlocked") 
       << ", values " << (this->fValuesLocked ? "locked" : "unlocked")
       << "\n";

    print_depth+=4;
    while (mit != this->fMap.end()) {
        for(int i=0; i<print_depth; ++i) os << " ";

        os << mit->first << " = ";
        mit->second->PrintStream(os);
        os << endl;
        ++mit;
    }
    print_depth-=4;
    return os;
}

void Registry::Print(Option_t* /* option */) const
{
    this->PrettyPrint(cout);
}


Registry::~Registry() 
{
    tRegMap::iterator mit = fMap.begin();
    while (mit != fMap.end()) {
        delete mit->second;
        ++mit;
    }
}

Registry::RegistryKey::RegistryKey(const Registry* r) :
    fReg(r)
{
    // FIXME!  Figure out how to correctly declare fIt to reflect
    // constness.
    fIt = const_cast<Registry*>(fReg)->fMap.begin();
}

Registry::RegistryKey::RegistryKey()
{
}

Registry::RegistryKey::~RegistryKey()
{
}

const char* Registry::RegistryKey::operator()(void)
{
    if (fIt == fReg->fMap.end()) return 0;
    const char* s = fIt->first.c_str();
    ++ fIt;
    return s;
}

Registry::RegistryKey Registry::Key(void) const
{
    return RegistryKey(this);
}

#define REGISTRY_SET(TYPE)                                              \
bool Registry::Set(const char* key, TYPE val)                           \
{                                                                       \
    tRegMap::iterator mit = fMap.find(key);                             \
    if (mit != fMap.end()) {                                            \
        if (fValuesLocked) {                                            \
             MSG("Registry",Msg::kWarning)                              \
               << "Set: Values are locked - not overwriting \""         \
               << key << "\" with \"" << val << "\" in registry \"" << this->GetName() << "\"\n";\
            return false;                                               \
        }                                                               \
        if (!dynamic_cast<RegistryItemXxx<TYPE>*>(mit->second)) {       \
            MSG("Registry",Msg::kWarning)                               \
                << "Set: attempt to overwrite old value for key \""     \
                << key << "\" with different type value "               \
                << val << " in registry \"" << this->GetName() << "\"\n";\
            return false;                                               \
        }                                                               \
        delete mit->second;                                             \
        fMap.erase(mit);                                                \
    }                                                                   \
    else {                                                              \
        if (fKeysLocked) {                                              \
            MSG("Registry",Msg::kWarning)                               \
                 << "Set: Keys are locked - not adding `"               \
                 << key << "' to registry \"" << this->GetName() << "\"\n";\
            return false;                                               \
        }                                                               \
    }                                                                   \
    RegistryItem* ri = new RegistryItemXxx< TYPE >(new TYPE (val));     \
    fMap[key] = ri;                                                     \
    this->SetDirty();                                                   \
    return true;                                                        \
}
//REGISTRY_SET(bool)
REGISTRY_SET(char)
REGISTRY_SET(int)
REGISTRY_SET(double)
REGISTRY_SET(Registry)
#undef REGISTRY_SET


// Must treat char* special
bool Registry::Set(const char* key, const char* val)
{
    tRegMap::iterator mit = fMap.find(key);
    if (mit != fMap.end()) {    // Found it
        if (fValuesLocked) {
            MSG("Registry",Msg::kWarning) 
                << "Set: Values are locked - not overwriting `"
                << key << "\" with \"" << val << "\" in registry \"" << this->GetName() << "\"\n";
            return false;
        }
        if (! dynamic_cast<RegistryItemXxx<const char*>*>(mit->second) ) {
            MSG("Registry",Msg::kWarning)
                << "Set: attempt to overwrite old value for key \""
                << key << "\" with different type value "
                << val << " in registry \"" << this->GetName() << "\"\n";
            return false;
        }
        delete mit->second;
        fMap.erase(mit);
    }
    else {                      // didn't find it
        if (fKeysLocked) {
            MSG("Registry",Msg::kWarning) 
                << "Registry::Set: Keys are locked - not adding `" 
                << key << "' in registry \"" << this->GetName() << "\"\n";
            return false;
        }
    }

    char** cpp = new char*;
    (*cpp) = new char [strlen(val)+1];
    strcpy(*cpp,val);
    const char** ccpp = const_cast<const char**>(cpp);
    RegistryItem* ri = new RegistryItemXxx< const char* >(ccpp);
    fMap[key] = ri;
    this->SetDirty();
    return true;
}


#define REGISTRY_GET(TYPE)                                      \
bool Registry::Get(const char* key, TYPE & val) const           \
{                                                               \
    tRegMap::const_iterator mit = fMap.find(key);               \
    if (mit == fMap.end()) return false;                        \
    RegistryItemXxx<TYPE>* rix =                                \
        dynamic_cast<RegistryItemXxx<TYPE>*>(mit->second);      \
    if (rix == 0){                                              \
      MSG("Registry", Msg::kError) << "Key " << key             \
                                   << " does not have type "    \
                                   << #TYPE << " as required"   \
                                   << endl;                     \
      return false;                                             \
    }                                                           \
    val = *(rix->Get());                                        \
    return true;                                                \
}
//REGISTRY_GET(bool)
REGISTRY_GET(char)
REGISTRY_GET(Registry)
REGISTRY_GET(const char*)
REGISTRY_GET(int)
//REGISTRY_GET(double)
bool Registry::Get(const char* key, double & val) const           
{                                                               
    tRegMap::const_iterator mit = fMap.find(key);
    if (mit == fMap.end()) return false;
    // try correct type
    RegistryItemXxx<double>* rixd =
        dynamic_cast<RegistryItemXxx<double>*>(mit->second);
    if (rixd) {
        val = *(rixd->Get());
        return true;
    }
    // try int
    RegistryItemXxx<int>* rixi =
        dynamic_cast<RegistryItemXxx<int>*>(mit->second);
    if (rixi) {
        val = *(rixi->Get());
        return true;
    }
    MSG("Registry", Msg::kError) << "Key " << key
                                 << " does not have type double or int"
                                 << " as required" << endl;
    return false;
}

#define REGISTRY_GET_TYPE(NAME, RETTYPE, TYPE)                            \
RETTYPE Registry::Get##NAME(const char* key) const                        \
{                                                                         \
    TYPE retval = 0;                                                      \
    if (Get(key,retval)) return retval;                                   \
    if (fErrorHandler) { fErrorHandler(); return 0; }                     \
    else {                                                                \
        MSG("Registry",Msg::kWarning)                                     \
            << "\nRegistry::GetTYPE: failed to get value for key \""      \
            << key << "\" from Registry \"" << this->GetName()            \
            << "\".  Aborting\n\n";                                       \
        bool must_get_a_value = false;                                    \
        assert(must_get_a_value);                                         \
        return 0;                                                         \
    }                                                                     \
}

//REGISTRY_GET_TYPE(Bool, bool, bool)
REGISTRY_GET_TYPE(Char, char, char)
REGISTRY_GET_TYPE(CharString, const char*, const char*)
REGISTRY_GET_TYPE(Int, int, int)
REGISTRY_GET_TYPE(Double, double, double)
//REGISTRY_GET_TYPE(Registry, Registry, Registry)
#undef REGISTRY_GET_TYPE
Registry Registry::GetRegistry(const char* key) const
{
    Registry retval;
    if (Get(key,retval)) return retval;
    if (fErrorHandler) { fErrorHandler(); return retval; }
    else {
        MSG("Registry",Msg::kWarning)
            << "\nRegistry::GetTYPE: failed to get value for key \""
            << key << "\" from Registry \"" << this->GetName()
            << "\".  Aborting\n\n";
        bool must_get_a_value = false;
        assert(must_get_a_value);
        return retval;
    }
}

const type_info& Registry::GetType(const char* key) const
{
    tRegMap::const_iterator mit = fMap.find(key);
    if (mit == fMap.end()) return typeid(void);
    return mit->second->GetType();
}
string Registry::GetTypeAsString(const char* key) const
{
    tRegMap::const_iterator mit = fMap.find(key);
    if (mit == fMap.end()) return "void";
    return mit->second->GetTypeAsString();
}

string Registry::GetValueAsString(const char* key) const
{
    ostringstream os;
    tRegMap::const_iterator mit = fMap.find(key);
    if (mit == fMap.end()) return "";
    mit->second->PrintStream(os);
    return os.str();
}

void Registry::Streamer(TBuffer& b)
{
    int nobjects;

    if (b.IsReading()) {
        Version_t v = b.ReadVersion();
        if (v) {}
        TNamed::Streamer(b);

        b >> nobjects;

        for (int i = 0; i < nobjects; ++i) {

            char tmp[1024];
            b >> tmp;
            string key(tmp);

            RegistryItem *ri;
            b >> ri;

            // This is copied from Set(), bad programmer!
            tRegMap::iterator mit = fMap.find(key);
            if (mit != fMap.end()) {
                delete mit->second;
                fMap.erase(mit);
            }
            fMap[key] = ri;

        } // end reading in all RegistryItems
    } // isReading
    else {
        b.WriteVersion(Registry::IsA());
        TNamed::Streamer(b);

        nobjects = fMap.size();
        b << nobjects;

        MSG("Registry",Msg::kDebug) 
            << "Streamer, Writing "<< nobjects <<" objects\n";

        tRegMap::iterator mit = fMap.begin();
        while (mit != fMap.end()) {
            b << mit->first.c_str();

            MSG("Registry",Msg::kDebug) 
                << mit->first.c_str() << endl;

            b << mit->second;

            ++mit;
        }
    }
}


std::ostream& Registry::PrintStream(std::ostream& os) const
{
    os << "['" << this->GetName() << "'";
    
    tRegMap::const_iterator mit, done = fMap.end();
    for (mit = fMap.begin(); mit != done; ++mit) {
        os << " '" << mit->first << "'=(";
        os << mit->second->GetTypeAsString();
        os << ")";
        mit->second->PrintStream(os);
    }

    os << "]";
    return os;
}


static std::istream& bail(std::istream& is)
{
    MSG("Registry",Msg::kWarning)
        << "Registry::Read(istream&) stream corrupted\n";
    return is;
}

std::istream& Registry::ReadStream(std::istream& is) 
{
    Registry reg;

    char c;
    if (!is.get(c)) return bail(is);
    if (c != '[') {
        is.putback(c);
        return bail(is);
    }
    string name = Util::read_quoted_string(is);
    reg.SetName(name.c_str());

    while (is.get(c)) {
        if (isspace(c)) continue;
        if (c == ']') {
            *this = reg;
            return is;
        }
        is.putback(c);

        // get the key
        string key = read_quoted_string(is);
        if (key == "") return bail(is);

        // skip the "="
        if (!is.get(c)) return bail(is);

        // get the "("
        if (!is.get(c) || c != '(') {
            is.putback(c);
            return bail(is);
        }
        
        // get the type
        string type;
        while (is.get(c)) {
            if (c == ')') break;
            type += c;
        }
        
        // factory:
        RegistryItem* ri = 0;
        if (type == "char") 
            ri = new RegistryItemXxx<char>();
        else if (type == "int")
            ri = new RegistryItemXxx<int>();
        else if (type == "double")
            ri = new RegistryItemXxx<double>();
        else if (type == "string")
            ri = new RegistryItemXxx<const char*>();
        else if (type == "Registry")
            ri = new RegistryItemXxx<Registry>();
        else return bail(is);

        ri->ReadStream(is);
        reg.fMap[key] = ri;
    }
    return is;
  
}

---