Config.cpp

Go to the documentation of this file.

#include "cafe/Config.hpp"

#include "TEnv.h"
#include "TOrdCollection.h"
#include "TObjArray.h"
#include "TString.h"
#include "TObjString.h"
#include "THashList.h"
#include "TDirectory.h"
#include "TSystem.h"

#include <memory>
#include <iostream>
#include <set>
#include <cstdlib>

namespace cafe {

    Config::Config(const std::string& name)
        : _name(name)
    {}

    Config::~Config()
    {}
        
    std::string Config::get(const std::string& key, const std::string& def)
    {
        return getEnv().GetValue((_name + '.' + key).c_str(), def.c_str());
    }

    int Config::get(const std::string& key, int def)
    {
        return getEnv().GetValue((_name + '.' + key).c_str(), def);        
    }

    double Config::get(const std::string& key, double def)
    {
        return getEnv().GetValue((_name + '.' + key).c_str(), def);
    }

    std::vector<std::string> Config::getVString(const std::string& key, const std::string& delim)
    {

        TString s(get(key, "").c_str());
        std::vector<std::string> result;
        TObjArray *tokens = s.Tokenize(delim.c_str());
  {
          TIter iter(tokens);
          while(TObject *p = iter.Next()) {
              TObjString *item = (TObjString*)p;
              result.push_back(item->GetString().Data());
          }
  }
        delete tokens;
        return result;
    }

     std::vector<float> Config::getVFloat(const std::string& key, const std::string& delim)
     {

        TString s(get(key, "").c_str());
        std::vector<float> result;
        TObjArray *tokens = s.Tokenize(delim.c_str());
        TIter iter(tokens);
        while(TObject *p = iter.Next()) {
            TObjString *item = (TObjString*)p;
            result.push_back(atof(item->GetString().Data()));
        }
        delete tokens;
        return result;
     }

     std::vector<int> Config::getVInt(const std::string& key, const std::string& delim)
     {

        TString s(get(key, "").c_str());
        std::vector<int> result;
        TObjArray *tokens = s.Tokenize(delim.c_str());
        TIter iter(tokens);
        while(TObject *p = iter.Next()) {
            TObjString *item = (TObjString*)p;
            result.push_back(strtol(item->GetString().Data(),0,0));
        }
        delete tokens;
        return result;
     }

    void Config::set(const std::string& key, const std::string& value)
    {
        getEnv().SetValue(key.c_str(), value.c_str());
    }

    void Config::dumpConfig(std::ostream& stream)
    {
      TIter next(getEnv().GetTable());
      TEnvRec *er;
      static const char *lc[] = { "Global", "User", "Local", "Changed" };

      stream << "cafe::Config: Dumping configuration settings" << std::endl;
      while ((er = (TEnvRec*) next()))
        stream << Form("%-25s: %-30s [%s]",
                       er->GetName(),er->GetValue(),lc[er->GetLevel()]) << std::endl;
      stream << "cafe::Config: End of configuration settings" << std::endl;

      return;
    }

    void Config::dumpConfig(TDirectory* const dir, std::string const name)
    {
      if (dir) {
        TObjArray array(getEnv().GetTable()->GetSize());
        array.SetOwner(kTRUE);

        TIter next(getEnv().GetTable());
        TEnvRec *er;
        static const char *lc[] = { "Global", "User", "Local", "Changed" };

        size_t index = 0;
        while ((er = (TEnvRec*) next())) {
          TObjString* str = new TObjString(Form("%-25s: %-30s [%s]",
                                                er->GetName(),
                                                er->GetValue(),
                                                lc[er->GetLevel()]));
          array[index] = str;
          ++index;
        } // while

        dir->cd();
        array.Write(name.c_str(),TObject::kSingleKey);
        //      array.Write();
      }

      return;
    }

    namespace {
        std::auto_ptr<TEnv> _cleanup;
    }
    
    TEnv& Config::getEnv()
    {
        static TEnv *_env;
        
        if(_env == 0) {
            // Search order:
            //   $CAFE_CONFIG  (putenv() by main routine if set on command line !
            //   ./cafe.config
            //   $SRT_PRIVATE_CONTEXT/cafe.config
            //
            if(const char *filename = gSystem->Getenv("CAFE_CONFIG")) {
                std::cout << "Reading configuration file: " << filename << std::endl;
                _env = new TEnv(filename);
                if(_env->GetTable()->GetSize() == 0) {
                    delete _env;
                    _env = 0;
                }
            }
            
            if(_env == 0) {
                _env = new TEnv("./cafe.config");
                if(_env->GetTable()->GetSize() == 0) {
                    delete _env;
                    _env = 0;
                }
            }

            if(_env == 0) {
                std::string ctx;
                if(const char *c = getenv("SRT_PRIVATE_CONTEXT")) {
                    ctx += c;
                }
                ctx += "./cafe.config";
                _env = new TEnv(ctx.c_str());
            }

            // now load all include files

            // the files we have already seen
            std::set<std::string> _files_included;
            
            bool add_more = false;
            do {
                add_more = false;
                TString s(_env->GetValue("cafe.Include", "")) ;
                std::auto_ptr<TObjArray> includes(s.Tokenize(" ,\t"));
                TIter iter(includes.get());
                while(TObject *p = iter.Next()) {
                    std::string filename(((TObjString*)p)->GetString().Data());
                    if(_files_included.count(filename) > 0) continue;
                    std::cout << "Including configuration file: " << filename << std::endl;
                    _env->ReadFile((filename).c_str(), kEnvLocal);
                    _files_included.insert(filename);
                    add_more = true;
                }
            } while(add_more);

            _cleanup = std::auto_ptr<TEnv>(_env);
        }
        return *_env;
    }
}

---