Added possibility to transcode params to a proper encoding.

[stg.git] / stglibs / srvconf.lib / parsers / property.h

diff --git a/stglibs/srvconf.lib/parsers/property.h b/stglibs/srvconf.lib/parsers/property.h
index 3469b9873fe8c04f46274f319a201d7008382945..df033c99d84a0fb283257e53633064811c56f16b 100644 (file)
--- a/stglibs/srvconf.lib/parsers/property.h
+++ b/stglibs/srvconf.lib/parsers/property.h
@@ -33,30 +33,48 @@ class BASE_PROPERTY_PARSER
 {
     public:
         virtual ~BASE_PROPERTY_PARSER() {}
 {
     public:
         virtual ~BASE_PROPERTY_PARSER() {}

-        virtual bool Parse(const char ** attr) = 0;
+        virtual bool Parse(const char ** attr, const std::string & attrName, const std::string & fromEncoding) = 0;

 };
 
 template <typename T>
 class PROPERTY_PARSER : public BASE_PROPERTY_PARSER
 {
     public:
 };
 
 template <typename T>
 class PROPERTY_PARSER : public BASE_PROPERTY_PARSER
 {
     public:

-        typedef bool (* FUNC)(const char **, T &);
+        typedef bool (* FUNC)(const char **, T &, const std::string &);

         PROPERTY_PARSER(T & v, FUNC f) : value(v), func(f) {}
         PROPERTY_PARSER(T & v, FUNC f) : value(v), func(f) {}

-        virtual bool Parse(const char ** attr) { return func(attr, value); }
+        PROPERTY_PARSER(T & v, FUNC f, const std::string & e) : value(v), func(f), encoding(e) {}
+        virtual bool Parse(const char ** attr, const std::string & attrName, const std::string & /*fromEncoding*/) { return func(attr, value, attrName); }

     private:
         T & value;
         FUNC func;
     private:
         T & value;
         FUNC func;

+        std::string encoding;

 };
 
 };
 

+template <>
+inline
+bool PROPERTY_PARSER<std::string>::Parse(const char ** attr, const std::string & attrName, const std::string & fromEncoding)
+{
+if (!encoding.empty() && !fromEncoding.empty())
+    {
+    std::string tmp;
+    if (!func(attr, value, attrName))
+        return false;
+    value = IconvString(tmp, fromEncoding, encoding);
+    return true;
+    }
+else
+    return func(attr, value, attrName);
+}
+

 typedef std::map<std::string, BASE_PROPERTY_PARSER *> PROPERTY_PARSERS;
 
 typedef std::map<std::string, BASE_PROPERTY_PARSER *> PROPERTY_PARSERS;
 

-bool CheckValue(const char ** attr);
+bool CheckValue(const char ** attr, const std::string & attrName);

 
 template <typename T>
 inline
 
 template <typename T>
 inline

-bool GetValue(const char ** attr, T & value)
+bool GetValue(const char ** attr, T & value, const std::string & attrName)

 {
 {

-if (CheckValue(attr))
+if (CheckValue(attr, attrName))

     if (str2x(attr[1], value) < 0)
         return false;
 return true;
     if (str2x(attr[1], value) < 0)
         return false;
 return true;


@@ -64,9 +82,9 @@ return true;
 
 template <>
 inline
 
 template <>
 inline

-bool GetValue<std::string>(const char ** attr, std::string & value)
+bool GetValue<std::string>(const char ** attr, std::string & value, const std::string & attrName)

 {
 {

-if (!CheckValue(attr))
+if (!CheckValue(attr, attrName))

     return false;
 value = attr[1];
 return true;
     return false;
 value = attr[1];
 return true;


@@ -74,29 +92,33 @@ return true;
 
 template <>
 inline
 
 template <>
 inline

-bool GetValue<double>(const char ** attr, double & value)
+bool GetValue<double>(const char ** attr, double & value, const std::string & attrName)

 {
 {

-if (CheckValue(attr))
+if (CheckValue(attr, attrName))

     if (strtodouble2(attr[1], value))
         return false;
 return true;
 }
 
     if (strtodouble2(attr[1], value))
         return false;
 return true;
 }
 

-bool GetEncodedValue(const char ** attr, std::string & value);
+bool GetEncodedValue(const char ** attr, std::string & value, const std::string & attrName);

 
 

-bool GetIPValue(const char ** attr, uint32_t& value);
+bool GetIPValue(const char ** attr, uint32_t& value, const std::string & attrName);

 
 template <typename T>
 
 template <typename T>

-void AddParser(PROPERTY_PARSERS & parsers, const std::string & name, T & value, const typename PROPERTY_PARSER<T>::FUNC & func = GetValue<T>);
+inline
+void AddParser(PROPERTY_PARSERS & parsers, const std::string & name, T & value, const typename PROPERTY_PARSER<T>::FUNC & func = GetValue<T>)
+{
+    parsers.insert(std::make_pair(ToLower(name), new PROPERTY_PARSER<T>(value, func)));
+}

 
 template <typename T>
 inline
 
 template <typename T>
 inline

-void AddParser(PROPERTY_PARSERS & parsers, const std::string & name, T & value, const typename PROPERTY_PARSER<T>::FUNC & func)
+void AddParser(PROPERTY_PARSERS & parsers, const std::string & name, T & value, const std::string & toEncoding, const typename PROPERTY_PARSER<T>::FUNC & func = GetValue<T>)

 {
 {

-    parsers.insert(std::make_pair(ToLower(name), new PROPERTY_PARSER<T>(value, func)));
+    parsers.insert(std::make_pair(ToLower(name), new PROPERTY_PARSER<T>(value, func, toEncoding)));

 }
 
 }
 

-bool TryParse(PROPERTY_PARSERS & parsers, const std::string & name, const char ** attr);
+bool TryParse(PROPERTY_PARSERS & parsers, const std::string & name, const char ** attr, const std::string & fromEncoding, const std::string & attrName = "value");

 
 } // namespace STG
 
 
 } // namespace STG