Added possibility to transcode params to a proper encoding.

diff --git a/stglibs/srvconf.lib/parsers/property.cpp b/stglibs/srvconf.lib/parsers/property.cpp
index 7edae52060ffe7aefec75b52c17dd3f8b53c703e..6e9fc72c735d9f781c03f8b701472e246523f1e8 100644 (file)
--- a/stglibs/srvconf.lib/parsers/property.cpp
+++ b/stglibs/srvconf.lib/parsers/property.cpp
@@ -46,10 +46,10 @@ if (value == 0 && ip != "0.0.0.0")
 return true;
 }
 
-bool STG::TryParse(PROPERTY_PARSERS & parsers, const std::string & name, const char ** attr, const std::string & attrName)
+bool STG::TryParse(PROPERTY_PARSERS & parsers, const std::string & name, const char ** attr, const std::string & fromEncoding, const std::string & attrName)
 {
     PROPERTY_PARSERS::iterator it(parsers.find(name));
     if (it != parsers.end())
-        return it->second->Parse(attr, attrName);
+        return it->second->Parse(attr, attrName, fromEncoding);
     return true; // Assume that non-existing params are ok.
 }

diff --git a/stglibs/srvconf.lib/parsers/property.h b/stglibs/srvconf.lib/parsers/property.h
index 59d478179d31814ef7ad3d6270b801f1e9231a9b..df033c99d84a0fb283257e53633064811c56f16b 100644 (file)
--- a/stglibs/srvconf.lib/parsers/property.h
+++ b/stglibs/srvconf.lib/parsers/property.h
@@ -33,7 +33,7 @@ class BASE_PROPERTY_PARSER
 {
     public:
         virtual ~BASE_PROPERTY_PARSER() {}
-        virtual bool Parse(const char ** attr, const std::string & attrName) = 0;
+        virtual bool Parse(const char ** attr, const std::string & attrName, const std::string & fromEncoding) = 0;
 };
 
 template <typename T>
@@ -42,12 +42,30 @@ class PROPERTY_PARSER : public BASE_PROPERTY_PARSER
     public:
         typedef bool (* FUNC)(const char **, T &, const std::string &);
         PROPERTY_PARSER(T & v, FUNC f) : value(v), func(f) {}
-        virtual bool Parse(const char ** attr, const std::string & attrName) { return func(attr, value, attrName); }
+        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;
+        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;
 
 bool CheckValue(const char ** attr, const std::string & attrName);
@@ -87,16 +105,20 @@ bool GetEncodedValue(const char ** attr, std::string & value, const std::string
 bool GetIPValue(const char ** attr, uint32_t& value, const std::string & attrName);
 
 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
-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, const std::string & attrName = "value");
+bool TryParse(PROPERTY_PARSERS & parsers, const std::string & name, const char ** attr, const std::string & fromEncoding, const std::string & attrName = "value");
 
 } // namespace STG
 

diff --git a/stglibs/srvconf.lib/servconf.cpp b/stglibs/srvconf.lib/servconf.cpp
index 4f74ae8f7d4d0b80b6ae24e73c399522bdc085eb..e0c2e58b78548f2f7f0eedb6d4f5c7d37ea92828 100644 (file)
--- a/stglibs/srvconf.lib/servconf.cpp
+++ b/stglibs/srvconf.lib/servconf.cpp
@@ -74,20 +74,21 @@ public:
     template <class P, typename C>
     int Exec(const std::string & request, C callback, void * data)
     {
-        P cp(callback, data);
+        P cp(callback, data, encoding);
         return ExecImpl(request, cp);
     }
 
     template <class P, typename C>
     int Exec(const std::string & tag, const std::string & request, C callback, void * data)
     {
-        P cp(tag, callback, data);
+        P cp(tag, callback, data, encoding);
         return ExecImpl(request, cp);
     }
 
 private:
     NETTRANSACT nt;
 
+    std::string encoding;
     std::string errorMsg;
     XML_Parser parser;
 
@@ -160,7 +161,7 @@ return pImpl->Exec<GET_ADMIN::PARSER>("<GetAdmin login=\"" + login + "\"/>", f,
 
 int SERVCONF::ChgAdmin(const ADMIN_CONF_RES & conf, SIMPLE::CALLBACK f, void * data)
 {
-return pImpl->Exec<SIMPLE::PARSER>("ChgAdmin", "<ChgAdmin" + CHG_ADMIN::Serialize(conf) + "/>", f, data);
+return pImpl->Exec<SIMPLE::PARSER>("ChgAdmin", "<ChgAdmin" + CHG_ADMIN::Serialize(conf, encoding) + "/>", f, data);
 }
 
 int SERVCONF::AddAdmin(const std::string & login,
@@ -170,7 +171,7 @@ int SERVCONF::AddAdmin(const std::string & login,
 int res = pImpl->Exec<SIMPLE::PARSER>("AddAdmin", "<AddAdmin login=\"" + login + "\"/>", f, data);
 if (res != st_ok)
     return res;
-return pImpl->Exec<SIMPLE::PARSER>("ChgAdmin", "<ChgAdmin" + CHG_ADMIN::Serialize(conf) + "/>", f, data);
+return pImpl->Exec<SIMPLE::PARSER>("ChgAdmin", "<ChgAdmin" + CHG_ADMIN::Serialize(conf, encoding) + "/>", f, data);
 }
 
 int SERVCONF::DelAdmin(const std::string & login, SIMPLE::CALLBACK f, void * data)
@@ -192,7 +193,7 @@ return pImpl->Exec<GET_TARIFF::PARSER>("<GetTariff name=\"" + name + "\"/>", f,
 
 int SERVCONF::ChgTariff(const TARIFF_DATA_RES & tariffData, SIMPLE::CALLBACK f, void * data)
 {
-return pImpl->Exec<SIMPLE::PARSER>("SetTariff", "<SetTariff name=\"" + tariffData.tariffConf.name.data() + "\">" + CHG_TARIFF::Serialize(tariffData) + "</SetTariff>", f, data);
+return pImpl->Exec<SIMPLE::PARSER>("SetTariff", "<SetTariff name=\"" + tariffData.tariffConf.name.data() + "\">" + CHG_TARIFF::Serialize(tariffData, encoding) + "</SetTariff>", f, data);
 }
 
 int SERVCONF::AddTariff(const std::string & name,
@@ -202,7 +203,7 @@ int SERVCONF::AddTariff(const std::string & name,
 int res = pImpl->Exec<SIMPLE::PARSER>("AddTariff", "<AddTariff name=\"" + name + "\"/>", f, data);
 if (res != st_ok)
     return res;
-return pImpl->Exec<SIMPLE::PARSER>("SetTariff", "<SetTariff name=\"" + name + "\">" + CHG_TARIFF::Serialize(tariffData) + "</SetTariff>", f, data);
+return pImpl->Exec<SIMPLE::PARSER>("SetTariff", "<SetTariff name=\"" + name + "\">" + CHG_TARIFF::Serialize(tariffData, encoding) + "</SetTariff>", f, data);
 }
 
 int SERVCONF::DelTariff(const std::string & name, SIMPLE::CALLBACK f, void * data)
@@ -227,7 +228,7 @@ int SERVCONF::ChgUser(const std::string & login,
                       const USER_STAT_RES & stat,
                       SIMPLE::CALLBACK f, void * data)
 {
-return pImpl->Exec<CHG_USER::PARSER>("<SetUser><Login value=\"" + login + "\"/>" + CHG_USER::Serialize(conf, stat) + "</SetUser>", f, data);
+return pImpl->Exec<CHG_USER::PARSER>("<SetUser><Login value=\"" + login + "\"/>" + CHG_USER::Serialize(conf, stat, encoding) + "</SetUser>", f, data);
 }
 
 int SERVCONF::DelUser(const std::string & login, SIMPLE::CALLBACK f, void * data)
@@ -243,7 +244,7 @@ int SERVCONF::AddUser(const std::string & login,
 int res = pImpl->Exec<SIMPLE::PARSER>("AddUser", "<AddUser><Login value=\"" + login + "\"/></AddUser>", f, data);
 if (res != st_ok)
     return res;
-return pImpl->Exec<CHG_USER::PARSER>("<SetUser><Login value=\"" + login + "\"/>" + CHG_USER::Serialize(conf, stat) + "</SetUser>", f, data);
+return pImpl->Exec<CHG_USER::PARSER>("<SetUser><Login value=\"" + login + "\"/>" + CHG_USER::Serialize(conf, stat, encoding) + "</SetUser>", f, data);
 }
 
 int SERVCONF::AuthBy(const std::string & login, AUTH_BY::CALLBACK f, void * data)
@@ -275,7 +276,7 @@ return pImpl->Exec<GET_SERVICE::PARSER>("<GetService name=\"" + name + "\"/>", f
 
 int SERVCONF::ChgService(const SERVICE_CONF_RES & conf, SIMPLE::CALLBACK f, void * data)
 {
-return pImpl->Exec<SIMPLE::PARSER>("SetService", "<SetService name=\"" + conf.name.data() + "\">" + CHG_SERVICE::Serialize(conf) + "</SetService>", f, data);
+return pImpl->Exec<SIMPLE::PARSER>("SetService", "<SetService name=\"" + conf.name.data() + "\">" + CHG_SERVICE::Serialize(conf, encoding) + "</SetService>", f, data);
 }
 
 int SERVCONF::AddService(const std::string & name,
@@ -285,7 +286,7 @@ int SERVCONF::AddService(const std::string & name,
 int res = pImpl->Exec<SIMPLE::PARSER>("AddService", "<AddService name=\"" + name + "\"/>", f, data);
 if (res != st_ok)
     return res;
-return pImpl->Exec<SIMPLE::PARSER>("SetService", "<SetService name=\"" + name + "\">" + CHG_SERVICE::Serialize(conf) + "</SetService>", f, data);
+return pImpl->Exec<SIMPLE::PARSER>("SetService", "<SetService name=\"" + name + "\">" + CHG_SERVICE::Serialize(conf, encoding) + "</SetService>", f, data);
 }
 
 int SERVCONF::DelService(const std::string & name, SIMPLE::CALLBACK f, void * data)
@@ -307,7 +308,7 @@ return pImpl->Exec<GET_CORP::PARSER>("<GetCorp name=\"" + name + "\"/>", f, data
 
 int SERVCONF::ChgCorp(const CORP_CONF_RES & conf, SIMPLE::CALLBACK f, void * data)
 {
-return pImpl->Exec<SIMPLE::PARSER>("SetCorp", "<SetCorp name=\"" + conf.name.data() + "\">" + CHG_CORP::Serialize(conf) + "</SetCorp>", f, data);
+return pImpl->Exec<SIMPLE::PARSER>("SetCorp", "<SetCorp name=\"" + conf.name.data() + "\">" + CHG_CORP::Serialize(conf, encoding) + "</SetCorp>", f, data);
 }
 
 int SERVCONF::AddCorp(const std::string & name,
@@ -317,7 +318,7 @@ int SERVCONF::AddCorp(const std::string & name,
 int res = pImpl->Exec<SIMPLE::PARSER>("AddCorp", "<AddCorp name=\"" + name + "\"/>", f, data);
 if (res != st_ok)
     return res;
-return pImpl->Exec<SIMPLE::PARSER>("SetCorp", "<SetCorp name=\"" + name + "\">" + CHG_CORP::Serialize(conf) + "</SetCorp>", f, data);
+return pImpl->Exec<SIMPLE::PARSER>("SetCorp", "<SetCorp name=\"" + name + "\">" + CHG_CORP::Serialize(conf, encoding) + "</SetCorp>", f, data);
 }
 
 int SERVCONF::DelCorp(const std::string & name, SIMPLE::CALLBACK f, void * data)
@@ -335,6 +336,8 @@ SERVCONF::IMPL::IMPL(const std::string & server, uint16_t port,
                      const std::string & login, const std::string & password)
     : nt(server, port, login, password)
 {
+setlocale(LC_ALL, "");
+encoding = nl_langinfo(CODESET);
 parser = XML_ParserCreate(NULL);
 }
 //-----------------------------------------------------------------------------
@@ -343,6 +346,8 @@ SERVCONF::IMPL::IMPL(const std::string & server, uint16_t port,
                      const std::string & login, const std::string & password)
     : nt(server, port, localAddress, localPort, login, password)
 {
+setlocale(LC_ALL, "");
+encoding = nl_langinfo(CODESET);
 parser = XML_ParserCreate(NULL);
 }
 //-----------------------------------------------------------------------------