CfgPromptConfigurable.cxx

Go to the documentation of this file.

#include "CfgPromptConfigurable.h"
#include "CfgDialog.h"
#include "MessageService/MsgService.h"
#include <string.h>
#include <stdlib.h>
#include <typeinfo> 
#include <assert.h>

ClassImp(CfgPromptConfigurable)
CVSID( " $Id: CfgPromptConfigurable.cxx,v 1.5 2008/10/10 23:34:22 bckhouse Exp $" );

CfgPromptConfigurable::CfgPromptConfigurable()
{
}

void CfgPromptConfigurable::InitializeConfig(const Registry& initConfig)
{
  fConfig.UnLockKeys();
  fConfig.UnLockValues();
  fConfig.Clear();
  fConfig=initConfig;
  fConfig.SetDirty(false); // Do this whenever ConfigModified is called.
  fConfig.LockKeys();
  fConfig.UnLockValues();

  // For GUIs:
  fDefaultConfig=initConfig;

  ConfigModified();
}

Bool_t CfgPromptConfigurable::Split(const char* line, char sep, string& a, string& b)
{
 //======================================================================
  // Purpose: Split a character string into two pieces given a
  //          separator.  Example peas::carots::beans into 
  //          a = peas 
  //          b = carots::beans
  //
  //          Or, peas -> a=peas, b=""
  //
  // Inputs: line - the text to split
  //         sep  - the separation character (':' in the example above)
  //         a    - text before the separator
  //         b    - text after separator
  //  
  // Return value: true if a split happened, false otherwise.
  //======================================================================
  // Clear a and b strings
  bool split = false;
  a = "";
  b = "";
  const char* c = line;
  while(*c != '\0') {
    if(*c == sep) { 
      split=true;
      break;
    }
    a+=(*c);
    ++c;
  }
  while(*c == sep) { ++c; };
  b = c;
  return split;
}

bool CfgPromptConfigurable::IsInt(const std::string& s, Int_t& i)
{
  //======================================================================
  // Does the string s represent an integer?
  //======================================================================
  const char* ss = s.c_str();
  char* endptr;
  double d = strtod(ss, &endptr);
  if (endptr==ss && d==0.0) return false; // Conversion to double failed...
  
  // Check if this number is int or float
  if (strchr(ss,'.')) return false;
  if (strchr(ss,'E')) return false;
  if (strchr(ss,'e')) return false;

  // All checks for "intness" passed  
  i = atoi(ss);
  
  return true;
}


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

bool CfgPromptConfigurable::IsFloat(const std::string& s, Double_t& val)
{
//======================================================================
// Does the string s represent an integer?
//======================================================================
  char* endptr;
  double d = strtod(s.c_str(), &endptr);
  if (endptr==s && d==0.0) return false; // Conversion to double failed...
  
  // All checks for "floatness" passed
  val = d;
  return true;
}


void CfgPromptConfigurable::Set(CfgDialog* d) 
{
//======================================================================
// Update the configuration parameters. Allow a CfgDialog object to be
// passed in. If none is passed in use the default, text based dialog
// object.
//======================================================================
  bool deleteDialog = false;
  if (d==0) {
    d = new CfgDialog();
    deleteDialog = true;
  }

  // Set up d with the default configuration parameters
  d->SetDefault(fDefaultConfig);
  d->SetCurrent(fConfig);
  
  // Do the querry
  Registry r = d->Query();
  Set(r);

  // Clean up the dialog
  if (deleteDialog) { delete d; d = 0; }
}

void CfgPromptConfigurable::Set(const char* key, char val)
{ Registry r;  r.Set(key,val); Set(r); }


void CfgPromptConfigurable::Set(const char* key, const char* val)
{ Registry r;  r.Set(key,val); Set(r); }



void CfgPromptConfigurable::Set(const char* key, double val)
{ Registry r;  r.Set(key,val); Set(r); }


void CfgPromptConfigurable::Set(const char* key, int val)
{ Registry r;  r.Set(key,val); Set(r); }


void CfgPromptConfigurable::Set(const char* key, const Registry& val )
{ Registry r;  r.Set(key,val); Set(r); }


void CfgPromptConfigurable::Set(const char* setstring)
{ 
  // Parse a whole string.
  
  // First, look for spaces to seperate entries.
  Registry r;
  string a,b;
  string line = setstring;
  bool split;
  do {
    split = Split(line,' ',a,b);
    
    // a contains the possible code.
    string key, val;
    if(a.size()>0) {
      if(Split(a,'=',key,val)) {
        Int_t i;
        Double_t f;
        if(IsInt(val,i)) {
          r.Set(key.c_str(),i);
        } else if(IsFloat(val,f)) {
          r.Set(key.c_str(),f);
        } else {
          r.Set(key.c_str(),val.c_str());
        };
        
        
      } else {
        MSG("Configurable",Msg::kWarning) << "Can't parse fragment: " << a << endl;
      }
    }
    
    line = b;
  } while ( split );

  // Add the data.
  Set(r);
}


// Granddaddy of set() routines:
void CfgPromptConfigurable::Set(const Registry& stuff, Bool_t recursive)
{
  if(SafeMerge(fConfig,stuff,recursive)) {
    // Something got changed, so allow user to change stuff:
    ConfigModified();
    fConfig.SetDirty(false);
  }
}

Bool_t CfgPromptConfigurable::SafeMerge(Registry& modify, 
                                     const Registry& stuff,
                                     Bool_t recursive )
{

  // First, see if we're locked up too tight to set anything.
  if(modify.ValuesLocked()) {
    MSG("Configurable",Msg::kWarning) << "Configurable has values locked. Can't set:" << endl;
    MSG("Configurable",Msg::kWarning) << stuff << endl;
    return false;
  }

  
  bool modified = false;
  
  // Iterate through all the keys in stuff.
  Registry::RegistryKey keyitr = stuff.Key();
  const char* key;
  while( (key = keyitr()) ) {
                                                
    // Does modify have this key?
    if(!modify.KeyExists(key)) {
      // Key doesn't exist. 

      if(modify.KeysLocked()) {

        // Keys are locked, so throw away with an error.
        MSG("Configurable",Msg::kWarning) << "Key " << key << " is not initialized in this Configurable. Skipping." << endl;
        MSG("Configurable",Msg::kInfo)    << "Current key/values are:" <<endl;
        if( MsgService::Instance()->IsActive("Configurable",Msg::kInfo) )
          modify.PrettyPrint(std::cout);

        MSG("Configurable",Msg::kFatal) << "\"" << key << "\" is an illegal key! Fix your script!" << endl;
        assert(0);
        continue;

      } else {
        // Key exists. Go on to save this one.
      }

    } else {
      // Key exists. 

      // Is the key the right type?
      if(modify.GetType(key)!=stuff.GetType(key)) {
        MSG("Configurable",Msg::kWarning) << "Key \"" << key << "\" is not initialized as type (" 
                                          << modify.GetType(key).name() 
                                          << ") but you've tried to set it to type (" 
                                          << stuff.GetType(key).name() 
                                          << ")" << endl;
        continue;
      }
      
      if( modify.GetValueAsString(key)==stuff.GetValueAsString(key) ) {
        // The values are identical. So save the work and skip it.
        continue;
      }
    }

    // Switch on type:
    int    vint;
    double vdouble;
    char   vchar;
    const char* vcharstar;
    Registry vregistry;

    const type_info& theType(modify.GetType(key));

    if((theType==typeid(char))&&(stuff.Get(key,vchar)))   modify.Set(key,vchar);
    if((theType==typeid(int))&&(stuff.Get(key,vint)))    modify.Set(key,vint);
    if((theType==typeid(double))&&(stuff.Get(key,vdouble))) modify.Set(key,vdouble);
    if((theType==typeid(const char*))&&(stuff.Get(key,vcharstar))) modify.Set(key,vcharstar);
    if(stuff.GetTypeAsString(key) == "Registry"){
      if(stuff.Get(key,vregistry)) {
        // Registries are harder. Merge using this function.
        if(recursive) {

          Registry old;
          if(modify.Get(key,old)) {
            Registry old;
            // Just for safety:
            old.UnLockValues();
            old.LockKeys();
            if(SafeMerge(old,vregistry)) modified = true;
            modify.Set(key,old);
          }

        } else {
          modify.Set(key,vregistry);
        }
      }
    }

    modified = true;
  };

  return modified;
}

---