Public interfaces: part 1

[stg.git] / libs / srvconf / parsers / property.h

diff --git a/libs/srvconf/parsers/property.h b/libs/srvconf/parsers/property.h
index 7aa98aebca16fbe057f798b0c942fb9fc8331ff1..f83e2f6e66ee2d630a17cb0c47018849e870f695 100644 (file)
--- a/libs/srvconf/parsers/property.h
+++ b/libs/srvconf/parsers/property.h
@@ -18,8 +18,7 @@
  *    Author : Maxim Mamontov <faust@stargazer.dp.ua>
  */
 
  *    Author : Maxim Mamontov <faust@stargazer.dp.ua>
  */
 

-#ifndef __STG_STGLIBS_SRVCONF_PROPERTY_PARSERS_H__
-#define __STG_STGLIBS_SRVCONF_PROPERTY_PARSERS_H__
+#pragma once

 
 #include "stg/common.h"
 
 
 #include "stg/common.h"
 


@@ -29,97 +28,94 @@
 namespace STG
 {
 
 namespace STG
 {
 

-class BASE_PROPERTY_PARSER
+struct BasePropertyParser

 {
 {

-    public:
-        virtual ~BASE_PROPERTY_PARSER() {}
-        virtual bool Parse(const char ** attr, const std::string & attrName, const std::string & fromEncoding) = 0;
+    virtual ~BasePropertyParser() = default;
+    virtual bool Parse(const char** attr, const std::string& attrName, const std::string& fromEncoding) = 0;

 };
 
 template <typename T>
 };
 
 template <typename T>

-class PROPERTY_PARSER : public BASE_PROPERTY_PARSER
+class PropertyParser : public BasePropertyParser

 {
     public:
 {
     public:

-        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, 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); }
+        using Func = bool (*)(const char **, T&, const std::string&);
+        PropertyParser(T& v, Func f) : value(v), func(f) {}
+        PropertyParser(T& v, Func f, const std::string& e) : value(v), func(f), encoding(e) {}
+        bool Parse(const char** attr, const std::string& attrName, const std::string& /*fromEncoding*/) override { return func(attr, value, attrName); }

     private:
         T & value;
     private:
         T & value;

-        FUNC func;
+        Func func;

         std::string encoding;
 };
 
 template <>
 inline
         std::string encoding;
 };
 
 template <>
 inline

-bool PROPERTY_PARSER<std::string>::Parse(const char ** attr, const std::string & attrName, const std::string & toEncoding)
+bool PropertyParser<std::string>::Parse(const char** attr, const std::string& attrName, const std::string& toEncoding)

 {
 {

-if (!encoding.empty() && !toEncoding.empty())
+    if (!encoding.empty() && !toEncoding.empty())

     {
     {

-    std::string tmp;
-    if (!func(attr, tmp, attrName))
-        return false;
-    value = IconvString(tmp, encoding, toEncoding);
-    return true;
+        std::string tmp;
+        if (!func(attr, tmp, attrName))
+            return false;
+        value = IconvString(tmp, encoding, toEncoding);
+        return true;

     }
     }

-else
+

     return func(attr, value, attrName);
 }
 
     return func(attr, value, attrName);
 }
 

-typedef std::map<std::string, BASE_PROPERTY_PARSER *> PROPERTY_PARSERS;
+using PropertyParsers = std::map<std::string, BasePropertyParser *>;

 
 

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

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

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

 {
 {

-if (CheckValue(attr, attrName))
-    if (str2x(attr[1], value) < 0)
-        return false;
-return true;
+    if (checkValue(attr, attrName))
+        if (str2x(attr[1], value) < 0)
+            return false;
+    return true;

 }
 
 template <>
 inline
 }
 
 template <>
 inline

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

 {
 {

-if (!CheckValue(attr, attrName))
-    return false;
-value = attr[1];
-return true;
+    if (!checkValue(attr, attrName))
+        return false;
+    value = attr[1];
+    return true;

 }
 
 template <>
 inline
 }
 
 template <>
 inline

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

 {
 {

-if (CheckValue(attr, attrName))
-    if (strtodouble2(attr[1], value))
-        return false;
-return true;
+    if (checkValue(attr, attrName))
+        if (strtodouble2(attr[1], value))
+            return false;
+    return true;

 }
 
 }
 

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

 
 

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

 
 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 = GetValue<T>)
+void addParser(PropertyParsers& parsers, const std::string& name, T& value, const typename PropertyParser<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 PropertyParser<T>(value, func)));

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

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

 {
 {

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

 }
 
 }
 

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

 
 } // namespace STG
 
 } // namespace STG

-
-#endif