several years of daqman upgrades that were never backported

Author: bloer

Makefile

@@ -42,12 +42,12 @@ libMessageHandler.so: src/MessageHandler.o
 	@$(CXX) $(LDFLAGS) $(LIBFLAGS) $^ -o $@
 	@mv $@ lib/$@
 
-libParameterList.so: src/MessageHandler.o src/VParameterNode.o src/ParameterList.o
+libParameterList.so: src/MessageHandler.o src/VParameterNode.o src/ParameterList.o src/ParameterIOimpl.o
 	@echo " Generating shared library $@"
 	@$(CXX) $(LDFLAGS) $(LIBFLAGS) $^ -o $@
 	@mv $@ lib/$@
 
-libConfigHandler.so: src/MessageHandler.o src/VParameterNode.o src/ParameterList.o src/ConfigHandler.o
+libConfigHandler.so: src/MessageHandler.o src/VParameterNode.o src/ParameterList.o src/ParameterIOimpl.o src/ConfigHandler.o
 	@echo " Generating shared library $@"
 	@$(CXX) $(LDFLAGS) $(LIBFLAGS) $^ -o $@
 	@mv $@ lib/$@

include/CommandSwitchFunctions.hh

@@ -13,7 +13,8 @@
 #include <sstream>
 #include <string>
 #include "VParameterNode.hh"
-
+#include "ConfigHandler.hh"
+ 
 /** @namespace CommandSwitch
     @brief Defines commonly used functors for command switches
     @ingroup ConfigHandler
@@ -54,7 +55,12 @@ namespace CommandSwitch{
   public:
     LoadConfigFile(VParameterNode* par) : l(par) {}
     int operator()(const char* file)
-    { return l->ReadFromFile(file); }
+    { 
+      std::string filepath = ConfigHandler::GetInstance()->FindConfigFile(file);
+      if(filepath=="")
+	return 1;
+      return l->ReadFromFile(filepath.c_str()); 
+    }
   };
 
   /** @class SetValue

include/ConfigFunctor.hh

@@ -27,6 +27,9 @@
 
     @ingroup ConfigHandler
 */
+
+#include "ParameterIOimpl.hh"
+
 template <typename readfunc, typename writefunc>
 class ConfigFunctor : public VParameterNode{
 public:
@@ -36,8 +39,11 @@ public:
   ~ConfigFunctor(){}
 
   std::istream& ReadFrom(std::istream& in, bool dummy=0){ return reader(in);}
-  std::ostream& WriteTo(std::ostream& out, bool dummy1=0, int dummy=0)
+  std::ostream& WriteTo(std::ostream& out, bool dummy1=0, int dummy=0) const
   { return writer(out);}
+  
+  ConfigFunctor<readfunc, writefunc>* Clone(const void* from, void* to) const
+  { return new ConfigFunctor<readfunc, writefunc>(*this); }
 private:
   readfunc reader;
   writefunc writer;
@@ -49,8 +55,11 @@ struct ConfigFunctorDummyRead{
 };
 /// Null-op utility class for ConfigFunctors that don't need write functionality
 struct ConfigFunctorDummyWrite{
-  std::ostream& operator()(std::ostream& out){ return out; }
+  std::ostream& operator()(std::ostream& out) const{ return out; }
 };
 
+template<class T> struct DeprecatedParameter{
+  std::istream& operator()(std::istream& in){ T t; return ParameterIOimpl::read(in,t); }
+};
 
 #endif

include/ConfigHandler.hh

@@ -80,7 +80,7 @@ public:
   std::string GetProgramDescription(){ return _program_description; }
 
   ///Process the command line for the registered switches.
-  ///Returns the number of non-switch arguments remaining, neg value if error
+  ///Returns 0 in case of success
   int ProcessCommandLine(int& argc, char** argv);
 
   ///Get the number of non-switch arguments to the command line.
@@ -111,13 +111,23 @@ public:
   /// Get the default config file
   const std::string& GetDefaultCfgFile(){ return _default_cfg_file; }
 
+  //search multiple paths for a config file
+  std::string FindConfigFile(const std::string& fname);
+
+  ///Should we hide all children of disabled lists when printing? 
+  void CollapseDisabledLists(bool collapse) { _collapse_disabled = collapse; }
+  
+  
 private:
   std::string _program_usage;      ///< String detailing how to use program
   std::string _program_description; ///< String describing the program
 
-  phrase _notes;                      ///< specify comments in a config file
+  std::string _notes;                ///< specify comments in a config file
   std::string _default_cfg_file;    ///< default config file for this program
   std::string _saved_cfg;             ///< name of old config file
+
+  std::vector<std::string> _cfg_paths; ///<list of paths to search for cfg files
+  
   /// Default constructor is private; singleton implementation
   ConfigHandler(); 
   /// Destructor also private
@@ -126,6 +136,7 @@ private:
   /// Copy constructor private
   ConfigHandler(const ConfigHandler& right) : ParameterList(),
 					      _switches(right._switches) {}
+  
   /// Copy constructor private
   ConfigHandler& operator=(const ConfigHandler& right)
   { _switches = right._switches; return *this; }
@@ -158,15 +169,15 @@ private:
       
       Holds the user-defined function to call when the switch is read
   */
-  template<class Action> class CommandSwitch : public VCommandSwitch{
+  template<class Action> class TCommandSwitch : public VCommandSwitch{
     Action do_action;
   public:
-    CommandSwitch(char short_name, const std::string& long_name,
+    TCommandSwitch(char short_name, const std::string& long_name,
 		  const std::string& help_text, const std::string& par,
 		  Action action) : 
       VCommandSwitch(short_name, long_name, help_text, par), 
       do_action(action) {}
-    virtual ~CommandSwitch() {}
+    virtual ~TCommandSwitch() {}
     virtual int Process(const char* arg);
   };
 
@@ -205,14 +216,14 @@ int ConfigHandler::AddCommandSwitch(char shortname,
       return -3;
     }
   }
-  _switches.insert(new CommandSwitch<Action>(shortname, longname, helptext,
+  _switches.insert(new TCommandSwitch<Action>(shortname, longname, helptext,
 					     parameter, action) );
   return 0;
 }
 
 
 template<class Action> inline
-int ConfigHandler::CommandSwitch<Action>::Process(const char* arg)
+int ConfigHandler::TCommandSwitch<Action>::Process(const char* arg)
 {
   return do_action(arg);
 }

include/MessageHandler.hh

@@ -34,7 +34,7 @@ enum MESSAGE_LEVEL {DEBUG3=0, DEBUG2, DEBUG, INFO, WARNING, ERROR,
 		    CRITICAL, EXCEPTION, N_MESSAGE_LEVELS};
 //MESSAGE_LEVEL needs streaming and increment/decrement operators
 /// ostream overload for MESSAGE_LEVEL
-std::ostream& operator<<(std::ostream& out, MESSAGE_LEVEL& level);
+std::ostream& operator<<(std::ostream& out, const MESSAGE_LEVEL& level);
 /// istream overload for MESSAGE_LEVEL
 std::istream& operator>>(std::istream& in, MESSAGE_LEVEL& level);
 /// increment operator for MESSAGE_LEVEL

include/Parameter.hh

@@ -11,20 +11,28 @@
 #ifndef PARAMETER_h
 #define PARAMETER_h
 #include "VParameterNode.hh"
+#include "ParameterIOimpl.hh"
 #include "Message.hh"
+#include "phrase.hh"
+
 #include <stdexcept>
 #include <string>
 #include <cstdlib>
 #include <typeinfo>
 #include <ctime>
 #include <cstdio>
 
+
+
 /** @class Parameter
     @brief Template implementation of VParamterNode, allows any variable to be 
     set/read via stl iostreams
     
     @ingroup ConfigHandler
 */
+
+class ParameterList;
+
 template<class T> class Parameter : public VParameterNode{
 public:
   /// DefaultConstructor
@@ -38,51 +46,60 @@ public:
   /// Assignment operator
   Parameter& operator=(const Parameter& right){ _val=right._val; return *this;}
   /// Return the underlying variable by reference
-  const T& GetValue(){ return _val; }
+  const T& GetValue() const { return _val; }
+  ///Return the underlying variable by pointer
+  const T* GetPointer() const { return &_val; }
   /// Print information about this parameter
   virtual int PrintHelp(const std::string& myname="") const;
+    
+  ///Clone to new ParameterList
+  virtual Parameter<T>* Clone(const void* from, void* to) const;
+  
+  ///access to the type of parameter for copy usage
+  typedef T param_type;
 protected:
   /// Read the underlying variable from an istream
   virtual std::istream& ReadFrom( std::istream& in , bool single=false);
   /// Write the underlying variable to an ostream
-  virtual std::ostream& WriteTo( std::ostream& out , bool, int);
-  /// Read unsigned integers from istreams possibly in hex format
-  virtual unsigned long ReadUnsignedInt(std::istream& in){
-    std::string temp;
-    in>>temp;
-    if(temp[0] == '0' && (temp[1] == 'x' || temp[1] == 'X'))
-      return std::strtoul(temp.c_str(),0,16);
-    else
-      return std::strtoul(temp.c_str(),0,10);
-  }
+  virtual std::ostream& WriteTo( std::ostream& out , bool showhelp=false, 
+				 int indent=0) const;
+  
+  //implementation of read/write is done with impls so we can overload
+  /*std::istream& read_impl(std::istream& in, T& t){ return in>>t; }
+  std::ostream& write_impl(std::ostream& out, T& t, 
+			   bool showhelp=false, int indent=0){ return out<<t; }
+  */
+  //specific impl overload
+  
 private:
   T& _val; ///< reference to the wrapped underyling variable
 };
-  
-//template members must go here so they'll actually get compiled
-template<class T>
+
+template<class T> 
 inline std::istream& Parameter<T>::ReadFrom(std::istream& in, bool)
 {
-  if( !( in >> _val ) && !in.eof()){
+  if( !ParameterIOimpl::read(in, _val) && !in.eof()){
     Message e(EXCEPTION);
     e<<"Error trying to read parameter with default key "<<_default_key<<"!\n";
     throw std::invalid_argument(e.str());
   }
   return in;
 }
 
-template<class T>
-inline std::ostream& Parameter<T>::WriteTo(std::ostream& out, bool, int)
+template<class T> 
+inline std::ostream& Parameter<T>::WriteTo(std::ostream& out, bool showhelp, int indent) const
 {
-  return out<<_val;
+  return ParameterIOimpl::write(out, _val, showhelp, indent);
 }
 
 template<class T>
 inline int Parameter<T>::PrintHelp(const std::string& myname) const
 {
   VParameterNode::PrintHelp(myname);
   std::cout<<"Parameter type: "<<typeid(_val).name()<<"\n"
-	   <<"Current Value:  "<<_val<<std::endl;
+	   <<"Current Value:  ";
+  ParameterIOimpl::write(std::cout, _val, true);
+  std::cout<<std::endl;
   std::string dummy;
   std::cout<<"\nHit <enter> to continue.";
   std::getline(std::cin, dummy);
@@ -91,107 +108,12 @@ inline int Parameter<T>::PrintHelp(const std::string& myname) const
   return 0;
 }
 
-/// Specific ostream overload for booleans
-template<> inline std::ostream& Parameter<bool>::WriteTo(std::ostream& out, bool, int)
+template<class T> inline 
+Parameter<T>* Parameter<T>::Clone(const void* from, void* to) const
 {
-  return out<<std::boolalpha<<_val<<std::noboolalpha;
+  unsigned diff = (const char*)(GetPointer()) - (const char*)from;
+  return new Parameter<T>((T&)(*( (char*)to+diff )), _default_key, _helptext); 
 }
 
-/// specific istream overload for booleans
-template<> inline std::istream& Parameter<bool>::ReadFrom(std::istream& in, bool)
-{
-  std::string temp;
-  in>>temp;
-  if(temp == "1" || temp == "true" || temp == "TRUE")
-    _val = true;
-  else if( temp == "0" || temp == "false" || temp == "FALSE" )
-    _val = false;
-  else{
-    Message e(EXCEPTION);
-    e<<"Expected boolean value, got "<<temp<<std::endl;
-    throw std::invalid_argument(e.str());
-  }
-  return in;
-}
-
-/// Write the 0x prefix on unsigned integers
-template<> inline std::ostream& Parameter<unsigned>::WriteTo(std::ostream& out, bool, int)
-{
-  return out<<std::hex<<std::showbase<<_val<<std::noshowbase<<std::dec;
-}
-
-/// Write the 0x prefix on unsigned integers
-template<> inline std::ostream& Parameter<unsigned char>::WriteTo(std::ostream& out, bool,int)
-{
-  return out<<std::hex<<std::showbase<<_val<<std::noshowbase<<std::dec;
-}
-
-/// Write the 0x prefix on unsigned integers
-template<> inline std::ostream& Parameter<unsigned short>::WriteTo(std::ostream& out, bool, int)
-{
-  return out<<std::hex<<std::showbase<<_val<<std::noshowbase<<std::dec;
-}
 
-/// Write the 0x prefix on unsigned integers
-template<> inline std::ostream& Parameter<unsigned long>::WriteTo(std::ostream& out, bool, int)
-{
-  return out<<std::hex<<std::showbase<<_val<<std::noshowbase<<std::dec;
-}
-
-/// Write the 0x prefix on unsigned integers
-template<> inline std::ostream& Parameter<unsigned long long>::WriteTo(std::ostream& out, bool, int)
-{
-  return out<<std::hex<<std::showbase<<_val<<std::noshowbase<<std::dec;
-}
-
-/// Read unsigned ints either in decimal or hex format
-template<> inline std::istream& Parameter<unsigned>::ReadFrom(std::istream& in, bool)
-{
-  _val = ReadUnsignedInt(in); return in;
-}
-
-/// Read unsigned ints either in decimal or hex format
-template<> inline std::istream& Parameter<unsigned char>::ReadFrom(std::istream& in, bool)
-{
-  _val = ReadUnsignedInt(in); return in;
-}
-
-/// Read unsigned ints either in decimal or hex format
-template<> inline std::istream& Parameter<unsigned short>::ReadFrom(std::istream& in, bool)
-{
-  _val = ReadUnsignedInt(in); return in;
-}
-
-/// Read unsigned ints either in decimal or hex format
-template<> inline std::istream& Parameter<unsigned long>::ReadFrom(std::istream& in, bool)
-{
-  _val = ReadUnsignedInt(in); return in;
-}
-
-/// Read unsigned ints either in decimal or hex format
-template<> inline std::istream& Parameter<unsigned long long>::ReadFrom(std::istream& in, bool)
-{
-  _val = ReadUnsignedInt(in); return in;
-}
-
-///Override std::string's to let "" be an empty string
-template<> inline std::istream& Parameter<std::string>::ReadFrom(std::istream& in, bool)
-{
-  std::string temp;
-  if(in>>temp){
-    if(temp == "\"\"")
-      _val = "";
-    else 
-      _val = temp;
-  }
-  return in;
-}
-
-///Override std::string's to let "" be an empty string
-template<> inline std::ostream& Parameter<std::string>::WriteTo(std::ostream& out, bool, int)
-{
-  if(_val == "")
-    return out<<"\"\"";
-  return out<<_val;
-}
 #endif