--- trunk/src/utils/ParameterManager.hpp	2005/11/16 21:37:45	748
+++ trunk/src/utils/ParameterManager.hpp	2008/09/11 19:40:59	1291
@@ -44,7 +44,7 @@
  *
  *  Created by Charles F. Vardeman II on 11/16/05.
  *  @author  Charles F. Vardeman II 
- *  @version $Id: ParameterManager.hpp,v 1.1 2005-11-16 21:37:45 chuckv Exp $
+ *  @version $Id: ParameterManager.hpp,v 1.4 2008-09-11 19:40:59 gezelter Exp $
  *
  */
 
@@ -57,13 +57,13 @@
 #include <vector>
 #include <string>
 #include <map>
+#include "config.h"
 
 
-
+#include "utils/simError.h"
+#include "utils/StringTokenizer.hpp"
 #include "utils/CaseConversion.hpp"
 
-
-
 template<typename T> 
 struct ParameterTraits;
 
@@ -109,18 +109,45 @@ struct ParameterTraits<int>{
   static std::string getParamType() { return "int";}  
 };
 
-//double
+//RealType
 template<>                     
-struct ParameterTraits<double>{
-  typedef double RepType;
+struct ParameterTraits<RealType>{
+  typedef RealType RepType;
   template<typename T> static bool    convert(T, RepType&){return false;} 
   template<typename T> static RepType convert(T v)        {RepType tmp; convert(v,tmp);return tmp;} 
   static bool convert(RepType v, RepType& r)            {r=v; return true;}
-  static bool convert(int v, RepType& r)                {r = static_cast<double>(v); return true;}
-  static std::string getParamType() { return "double";}    
+  static bool convert(int v, RepType& r)                {r = static_cast<RealType>(v); return true;}
+  static std::string getParamType() { return "RealType";}    
 };
 
+//Pair of ints
+template<>                     
+struct ParameterTraits<std::pair<int, int> >{
+  typedef std::pair<int, int>  RepType;
+  template<typename T> static bool    convert(T, RepType&){return false;} 
+  template<typename T> static RepType convert(T v)        {RepType tmp; convert(v,tmp);return tmp;} 
+  static bool convert(RepType v, RepType& r)            {r=v; return true;}
+  static bool convert(std::string v, RepType& r) { 
+    oopse::StringTokenizer tokenizer(v," ;,\t\n\r");
+    if (tokenizer.countTokens() == 2) {
+      int atom1 = tokenizer.nextTokenAsInt();
+      int atom2 = tokenizer.nextTokenAsInt();
+      r = std::make_pair(atom1, atom2);
+      return true;
+    } else {
+      sprintf(painCave.errMsg, 
+              "ParameterManager Error: "
+              "Not enough tokens to make pair!\n");
+      painCave.severity = OOPSE_ERROR;
+      painCave.isFatal = 1;
+      simError();    
+    }
+    return false;
+  }
+  static std::string getParamType() { return "std::pair<int, int>";}    
+};
 
+
 class ParameterBase {
 public:    
   ParameterBase() : keyword_(), optional_(false), defaultValue_(false), empty_(true) {}
@@ -134,7 +161,8 @@ class ParameterBase { (public)
   bool empty() {return empty_;}
   virtual bool setData(std::string) = 0;
   virtual bool setData(int) = 0;
-  virtual bool setData(double) = 0;
+  virtual bool setData(RealType) = 0;
+  virtual bool setData(std::pair<int, int>) = 0;
   virtual std::string getParamType() = 0;
 protected:
     std::string keyword_;
@@ -157,9 +185,13 @@ class Parameter : public ParameterBase{ (public)
     return internalSetData<int>(ival);
   }
   
-  virtual bool setData(double dval) {
-    return internalSetData<double>(dval);
+  virtual bool setData(RealType dval) {
+    return internalSetData<RealType>(dval);
   }
+
+  virtual bool setData(std::pair<int, int> pval) {
+    return internalSetData<std::pair<int, int> >(pval);
+  }
   
   virtual std::string getParamType() { return ParameterTraits<ParamType>::getParamType();}
 private: 
@@ -189,15 +221,15 @@ NAME.setKeyword(KEYWORD);                  \
 
 #define DefineParameter(NAME,KEYWORD)                              \
 NAME.setKeyword(KEYWORD);                  \
-parameters_.insert(std::make_pair(std::string(KEYWORD),  &NAME));
+parameters_.insert(std::map<std::string, ParameterBase*>::value_type(std::string(KEYWORD), static_cast<ParameterBase*>(&NAME)));
 
 #define DefineOptionalParameter(NAME,KEYWORD)                              \
 NAME.setKeyword(KEYWORD); NAME.setOptional(true);                    \
-parameters_.insert(std::make_pair(std::string(KEYWORD),  &NAME));
+parameters_.insert(std::map<std::string, ParameterBase*>::value_type(std::string(KEYWORD), static_cast<ParameterBase*>(&NAME)));
 
 #define DefineOptionalParameterWithDefaultValue(NAME,KEYWORD, DEFAULTVALUE)                              \
 NAME.setKeyword(KEYWORD); NAME.setOptional(true); NAME.setDefaultValue(DEFAULTVALUE);                      \
-parameters_.insert(std::make_pair(std::string(KEYWORD),  &NAME));
+parameters_.insert(std::map<std::string, ParameterBase*>::value_type(std::string(KEYWORD), static_cast<ParameterBase*>(&NAME)));
 
 #define CheckParameter(NAME, CONSTRAINT)                              \
 if (!NAME.empty()) { if (!(CONSTRAINT)(NAME.getData())) { sprintf(painCave.errMsg,"Error in checking %s : should be %s\n",NAME.getKeyword().c_str(),(CONSTRAINT).getConstraintDescription().c_str()); painCave.isFatal = 1; painCave.severity = OOPSE_ERROR; simError();} }