Always set ConfigurableParam provenance, add provenance getter

shahor02 · shahor02 · commit d6768981a889 · 2021-04-11T23:36:17.000+02:00
diff --git a/Common/Utils/include/CommonUtils/ConfigurableParam.h b/Common/Utils/include/CommonUtils/ConfigurableParam.h
@@ -143,6 +143,12 @@ class ConfigurableParam
     /* can add more modes here */
   };
 
+  enum class EParamUpdateStatus {
+    Changed,   // param was successfully changed
+    Unchanged, // param was not changed: new value is the same as previous
+    Failed     // failed to update param
+  };
+
   static std::string toString(EParamProvenance p)
   {
     static std::array<std::string, 3> names = {"CODE", "CCDB", "RT"};
@@ -155,6 +161,11 @@ class ConfigurableParam
   // print the current keys and values to screen (optionally with provenance information)
   virtual void printKeyValues(bool showprov = true) const = 0;
 
+  // return the provenance of the member key
+  virtual EParamProvenance getMemberProvenance(const std::string& key) const = 0;
+
+  static EParamProvenance getProvenance(const std::string& key);
+
   static void printAllRegisteredParamNames();
   static void printAllKeyValuePairs();
 
@@ -189,7 +200,7 @@ class ConfigurableParam
       if (sPtree->get_optional<std::string>(key).is_initialized()) {
         sPtree->put(key, x);
         auto changed = updateThroughStorageMap(mainkey, subkey, typeid(T), (void*)&x);
-        if (changed) {
+        if (changed != EParamUpdateStatus::Failed) {
           sValueProvenanceMap->find(key)->second = kRT; // set to runtime
         }
       }
@@ -210,7 +221,7 @@ class ConfigurableParam
       if (sPtree->get_optional<std::string>(key).is_initialized()) {
         sPtree->put(key, valuestring);
         auto changed = updateThroughStorageMapWithConversion(key, valuestring);
-        if (changed) {
+        if (changed != EParamUpdateStatus::Failed) {
           sValueProvenanceMap->find(key)->second = kRT; // set to runtime
         }
       }
@@ -252,8 +263,8 @@ class ConfigurableParam
   friend std::ostream& operator<<(std::ostream& out, const ConfigurableParam& me);
 
   static void initPropertyTree();
-  static bool updateThroughStorageMap(std::string, std::string, std::type_info const&, void*);
-  static bool updateThroughStorageMapWithConversion(std::string const&, std::string const&);
+  static EParamUpdateStatus updateThroughStorageMap(std::string, std::string, std::type_info const&, void*);
+  static EParamUpdateStatus updateThroughStorageMapWithConversion(std::string const&, std::string const&);
 
   virtual ~ConfigurableParam() = default;
 
diff --git a/Common/Utils/include/CommonUtils/ConfigurableParamHelper.h b/Common/Utils/include/CommonUtils/ConfigurableParamHelper.h
@@ -82,6 +82,13 @@ class ConfigurableParamHelper : virtual public ConfigurableParam
     return P::sKey;
   }
 
+  // ----------------------------------------------------------------
+  // get the provenace of the member with given key
+  EParamProvenance getMemberProvenance(const std::string& key) const final
+  {
+    return getProvenance(getName() + '.' + key);
+  }
+
   // ----------------------------------------------------------------
 
   // one of the key methods, using introspection to print itself
diff --git a/Common/Utils/src/ConfigurableParam.cxx b/Common/Utils/src/ConfigurableParam.cxx
@@ -313,6 +313,20 @@ void ConfigurableParam::printAllKeyValuePairs()
 
 // ------------------------------------------------------------------
 
+ConfigurableParam::EParamProvenance ConfigurableParam::getProvenance(const std::string& key)
+{
+  if (!sIsFullyInitialized) {
+    initialize();
+  }
+  auto iter = sValueProvenanceMap->find(key);
+  if (iter == sValueProvenanceMap->end()) {
+    throw std::runtime_error(fmt::format("provenace of unknown {:s} parameter is requested", key));
+  }
+  return iter->second;
+}
+
+// ------------------------------------------------------------------
+
 // evidently this could be a local file or an OCDB server
 // ... we need to generalize this ... but ok for demonstration purposes
 void ConfigurableParam::toCCDB(std::string filename)
@@ -612,24 +626,24 @@ bool isMemblockDifferent(void const* block1, void const* block2)
 // copies data from one place to other and returns
 // true of data was actually changed
 template <typename T>
-bool Copy(void const* addr, void* targetaddr)
+ConfigurableParam::EParamUpdateStatus Copy(void const* addr, void* targetaddr)
 {
   if (isMemblockDifferent<T>(addr, targetaddr)) {
     std::memcpy(targetaddr, addr, sizeof(T));
-    return true;
+    return ConfigurableParam::EParamUpdateStatus::Changed;
   }
-  return false;
+  return ConfigurableParam::EParamUpdateStatus::Unchanged;
 }
 
-bool ConfigurableParam::updateThroughStorageMap(std::string mainkey, std::string subkey, std::type_info const& tinfo,
-                                                void* addr)
+ConfigurableParam::EParamUpdateStatus ConfigurableParam::updateThroughStorageMap(std::string mainkey, std::string subkey, std::type_info const& tinfo,
+                                                                                 void* addr)
 {
   // check if key_exists
   auto key = mainkey + "." + subkey;
   auto iter = sKeyToStorageMap->find(key);
   if (iter == sKeyToStorageMap->end()) {
     LOG(WARN) << "Cannot update parameter " << key << " not found";
-    return false;
+    return ConfigurableParam::EParamUpdateStatus::Failed;
   }
 
   // the type we need to convert to
@@ -638,7 +652,7 @@ bool ConfigurableParam::updateThroughStorageMap(std::string mainkey, std::string
   // check that type matches
   if (iter->second.first != tinfo) {
     LOG(WARN) << "Types do not match; cannot update value";
-    return false;
+    return ConfigurableParam::EParamUpdateStatus::Failed;
   }
 
   auto targetaddress = iter->second.second;
@@ -749,72 +763,74 @@ bool ConfigurableParam::updateThroughStorageMap(std::string mainkey, std::string
       break;
     }
   }
-  return false;
+  return ConfigurableParam::EParamUpdateStatus::Failed;
 }
 
 template <typename T>
-bool ConvertAndCopy(std::string const& valuestring, void* targetaddr)
+ConfigurableParam::EParamUpdateStatus ConvertAndCopy(std::string const& valuestring, void* targetaddr)
 {
   auto addr = boost::lexical_cast<T>(valuestring);
   if (isMemblockDifferent<T>(targetaddr, (void*)&addr)) {
     std::memcpy(targetaddr, (void*)&addr, sizeof(T));
-    return true;
+    return ConfigurableParam::EParamUpdateStatus::Changed;
   }
-  return false;
+  return ConfigurableParam::EParamUpdateStatus::Unchanged;
 }
+
 // special version for std::string
 template <>
-bool ConvertAndCopy<std::string>(std::string const& valuestring, void* targetaddr)
+ConfigurableParam::EParamUpdateStatus ConvertAndCopy<std::string>(std::string const& valuestring, void* targetaddr)
 {
   std::string& target = *((std::string*)targetaddr);
   if (target.compare(valuestring) != 0) {
     // the targetaddr is a std::string to which we can simply assign
     // and all the magic will happen internally
     target = valuestring;
-    return true;
+    return ConfigurableParam::EParamUpdateStatus::Changed;
   }
-  return false;
+  return ConfigurableParam::EParamUpdateStatus::Unchanged;
 }
 // special version for char and unsigned char since we are interested in the numeric
 // meaning of char as an 8-bit integer (boost lexical cast is assigning the string as a character i// nterpretation
 template <>
-bool ConvertAndCopy<char>(std::string const& valuestring, void* targetaddr)
+ConfigurableParam::EParamUpdateStatus ConvertAndCopy<char>(std::string const& valuestring, void* targetaddr)
 {
   int intvalue = boost::lexical_cast<int>(valuestring);
   if (intvalue > std::numeric_limits<char>::max() || intvalue < std::numeric_limits<char>::min()) {
     LOG(ERROR) << "Cannot assign " << valuestring << " to a char variable";
-    return false;
+    return ConfigurableParam::EParamUpdateStatus::Failed;
   }
   char addr = intvalue;
   if (isMemblockDifferent<char>(targetaddr, (void*)&addr)) {
     std::memcpy(targetaddr, (void*)&addr, sizeof(char));
-    return true;
+    return ConfigurableParam::EParamUpdateStatus::Changed;
   }
-  return false;
+  return ConfigurableParam::EParamUpdateStatus::Unchanged;
 }
+
 template <>
-bool ConvertAndCopy<unsigned char>(std::string const& valuestring, void* targetaddr)
+ConfigurableParam::EParamUpdateStatus ConvertAndCopy<unsigned char>(std::string const& valuestring, void* targetaddr)
 {
   unsigned int intvalue = boost::lexical_cast<int>(valuestring);
   if (intvalue > std::numeric_limits<unsigned char>::max() || intvalue < std::numeric_limits<unsigned char>::min()) {
     LOG(ERROR) << "Cannot assign " << valuestring << " to an unsigned char variable";
-    return false;
+    return ConfigurableParam::EParamUpdateStatus::Failed;
   }
   unsigned char addr = intvalue;
   if (isMemblockDifferent<unsigned char>(targetaddr, (void*)&addr)) {
     std::memcpy(targetaddr, (void*)&addr, sizeof(unsigned char));
-    return true;
+    return ConfigurableParam::EParamUpdateStatus::Changed;
   }
-  return false;
+  return ConfigurableParam::EParamUpdateStatus::Unchanged;
 }
 
-bool ConfigurableParam::updateThroughStorageMapWithConversion(std::string const& key, std::string const& valuestring)
+ConfigurableParam::EParamUpdateStatus ConfigurableParam::updateThroughStorageMapWithConversion(std::string const& key, std::string const& valuestring)
 {
   // check if key_exists
   auto iter = sKeyToStorageMap->find(key);
   if (iter == sKeyToStorageMap->end()) {
     LOG(WARN) << "Cannot update parameter " << key << " (parameter not found) ";
-    return false;
+    return ConfigurableParam::EParamUpdateStatus::Failed;
   }
 
   auto targetaddress = iter->second.second;
@@ -936,7 +952,7 @@ bool ConfigurableParam::updateThroughStorageMapWithConversion(std::string const&
       break;
     }
   }
-  return false;
+  return ConfigurableParam::EParamUpdateStatus::Failed;
 }
 
 } // namespace conf
