Properties --- C++读配置信息的类(一)
http://blog.csdn.net/billow_zhang/article/details/4304980
在开发实践中，积累了一些通用的C++ 类库，在此写出来给大家分享。也希望能给出更好的建议。工具库的名字是xtl——Properties 类。分两部分介绍。这篇介绍类的定义。下一篇将介绍类的实现。 。这篇介绍其中的读配置文件的类
下面是类的定义的头文件：
1
2 /*xtl/Properties.h
3 Author: ZhangTao
4 Date: Nov 6, 2008
5 */
6
7 # ifndef Properties_h
8 # define Properties_h
9
10 # include <algorithm>
11 # include <iterator>
12
13 # include <iostream>
14 # include <string>
15 # include <map>
16
17 namespace std {
18 // <map> member output operator
19 template<typename _U, typename _V>
20 ostream& operator<< (ostream& os, const pair<_U, _V>& val) {
21 return os << val.first << " = " << val.second;
22 }
23
24 // <map> output operator, ie. all members in <map> output to <ostream>
25 template<typename _U, typename _V>
26 ostream& operator<< (ostream& os, const map<_U, _V>& val) {
27 copy(val.begin(), val.end(), ostream_iterator< pair<_U, _V> >(os, "/n"));
28 return os;
29 }
30 } // end of <namespace std>
31
32 namespace xtl {
33
34 class Properties : public std::map<std::string, std::string> {
35 public:
36 Properties() {};
37 Properties(const char* fname, const char* section = "") {
38 load(fname, section);
39 }
40 Properties(std::istream& is, const char* section = "") {
41 load(is, section);
42 }
43
44 void load(const char* fname, const char* section = "");
45 void load(std::istream& is, const char* section = "");
46 void loadXML(const char* fname, const char* section = "");
47 void loadXML(std::istream& is, const char* section = "");
48
49 const std::string& getProperty(const std::string& key) const;
50
51 void list(std::ostream& os) const {
52 os << *this;
53 }
54 }; // end of <class Properties>
55
56 const char* const XML_ENTRY = "entry";
57 const char* const XML_KEY = "key";
58
59 } // end of <namespace xtl>
60
61 # endif /* end of <ifndef Properties_h> */
62
Properties 继承了stl 库的map 容器类。这样可以使用map 的各个接口实现。尤其是输出输入的重载的实现。
18 到22 行定义了map 单个元素的输出重载；25 到29 行则定义了map 全部元素的输出重载。正是有了这些铺垫，才使得51 行的list 函数显得那么简练。实际上list 函数完全可以不需要，可以使用<< 重载输出。例如：
Properties prop;
cout << prop;
等同于：
prop.list(cout);
Properties 的load 是用于从文件中读入数据的。它可以读入下面格式的文件：
# props.conf
# for Properties class test
TEST1=TEST1VALUE
TEST2=TEST2VALUE
TEST3=TEST3VALUE
TEST4 = 100
[Section0]
TEST01=TEST01VALUE
TEST02=TEST02VALUE
TEST03=TEST03VALUE
TEST04 = 200
[Section1]
TEST11=TEST11VALUE
TEST12=TEST12VALUE
TEST13=TEST13VALUE
TEST14 = 300
下面是测试程序：
/* tst-properties
test class Properties
*/
# include "xtl/Properties.h"
int
main(int argc, char* argv[])
{
const char* sec;
if ( argc > 1 )
sec = argv[1];
else
sec = "";
xtl::Properties prop(std::cin, sec);
prop.list(std::cout);
if ( argc > 2 )
std::cout << "Key:<" << argv[2] << "> Value:" <<
prop.getProperty(argv[2]) << "/n";
return 0;
}
上面的测试数据文件为 props.conf ，测试程序编译连接后的执行文件为 tst-properties 。
以下是运行结果。
$ tst-properties <props.conf
TEST1 = TEST1VALUE
TEST2 = TEST2VALUE
TEST3 = TEST3VALUE
TEST4 = 100
$ tst-properties Section0 ITEM04 <props.conf
TEST01 = TEST01VALUE
TEST02 = TEST02VALUE
TEST03 = TEST03VALUE
TEST04 = 200
Key:<TEST04> Value:200
由于继承了map类，相应的操作异常简练。最复杂的应该是load函数了。
load的实现，请阅下一篇文章。
在第一部分中，列出了Properties的定义的头文件。这个文件中的load及loadXML接口参数是一样的。当初设计这个类的时候，主要是读ini格式的文件，后来又有了读XML格式文件的需求，才增加了loadXML的函数。这样以增加函数接口来扩展功能的方式显得比较丑陋，同时也说明，Properties的设计不能满足于读不同文件格式的需要。下面是针对这个问题，作出的重新的设计：
1
2 /* xtl/Properties.h
3 Author: ZhangTao
4 Date: Nov 6, 2008
5 */
6
7 # ifndef Properties_h
8 # define Properties_h
9
10 # include <algorithm>
11 # include <iterator>
12
13 # include <iostream>
14 # include <fstream>
15 # include <string>
16 # include <map>
17
18 # include "xtl/except.h"
19
20 namespace std {
21 // <map> member output operator
22 template<typename _U, typename _V>
23 ostream& operator<< (ostream& os, const pair<_U, _V>& val) {
24 return os << val.first << " = " << val.second;
25 }
26
27 // <map> output operator, ie. all members in <map> output to <ostream>
28 template<typename _U, typename _V>
29 ostream& operator<< (ostream& os, const map<_U, _V>& val) {
30 copy(val.begin(), val.end(), ostream_iterator< pair<_U, _V> >(os, "/n"));
31 return os;
32 }
33 } // end of <namespace std>
34
35 namespace xtl {
36
37 typedef std::map<std::string, std::string> PropMap;
38
39 template<typename _Loader>
40 class Properties : public PropMap {
41 public:
42 Properties() {};
43 Properties(const char* fname, const char* section = "") {
44 load(fname, section);
45 }
46 Properties(std::istream& is, const char* section = "") {
47 load(is, section);
48 }
49
50 void load(const char* fname, const char* section = "") {
51 std::ifstream ifs(fname);
52
53 if ( !ifs )
54 throw_fmtException("can not read <%s>", fname);
55
56 load(ifs, section);
57 }
58
59 void load(std::istream& is, const char* section = "") {
60 loadFunc(*this, is, section);
61 }
62
63 const std::string& getProperty(const std::string& key) const {
64 static const std::string EmptyStr;
65
66 const_iterator it = find(key);
67
68 return it == end()? EmptyStr : it->second;
69 }
70
71 void list(std::ostream& os) const {
72 os << *this;
73 }
74
75 private:
76 _Loader loadFunc; // load map data template function
77
78 }; // end of <class Properties>
79
80
81 } // end of <namespace xtl>
82
83 # endif /* end of <ifndef Properties_h> */
84
is section props
- IniProps的定义头文件：
/* xtl/IniProps.h
Author: ZhangTao
Date: June 28, 2009
*/
# ifndef IniProps_h
# define IniProps_h
# include "xtl/Properties.h"
namespace xtl {
class IniPropsLoad {
public:
void operator() (PropMap& props, std::istream& is, const char* section);
};
typedef Properties<IniPropsLoad> IniProps;
} // end of <namespace xtl>
- IniProps的实现原程序文件
1 /* IniPropsLoad.cpp
2 Author: ZhangTao
3 Date: Nov 6, 2008
4 */
5
6 # include "xtl/utilfunc.h"
7 # include "xtl/IniProps.h"
8
9 namespace xtl {
10
11 DeclareThisFile;
12
13 void IniPropsLoad::operator() (PropMap& props,
14 std::istream& is, const char* section)
15 {
16 char inbuf[256];
17
18 if ( !is )
19 ThrowUtilExceptWithSource("can not read input stream", "");
20
21 if ( !isEmptyStr(section) ) {
22 char sec[64];
23
24 int slen = sprintf(sec, "[%.60s]", section);
25
26 while( is.getline(inbuf, sizeof inbuf) &&
27 (strncmp(inbuf, sec, slen) != 0) );
28
29 if ( !is )
30 ThrowUtilExceptWithSource("can not found section <%s>", section);
31 }
32
33 while( is.getline(inbuf, sizeof inbuf) && (inbuf[0] != '[') ) {
34 // skip remark or space line
35 if ( isSpaceLine(inbuf) )
36 continue;
37
38 char key[64];
39 char val[128];
40
41 if ( sscanf(inbuf, "%63[^=/t ] = %127[^/n]/n", key, val) > 1 )
42 props.insert(make_pair(std::string(key), std::string(val)));
43 }
44 }
45
46 } // end of <namespace xtl>
47
第11行的DeclareThisFile是配合19行和30行的ThrowUtilExceptWithSource的调用使用的。这个抛出异常的定义在xtl/except.h文件中，在后面的文章里将会给出。
第21行的isEmptyStr及第35行的isSpaceLine是在xtl/utilfunc.h中定义的。内容如下：
inline bool isEmptyStr(const char *str) { return *str == '/0'; }
inline bool isSpaceLine(const char *line) {
return (line[0] == '/0') || (line[0] == '#') || (line[0] == '/n')
|| (line[0] == '/r');
}
根据名称就可判断 isEmptyStr是判断是否是空字符串。isSpace是判断是否是空行字符串。对于起始为#字符的也认为是空行，以便于可以在文件里面使用#行开始写注释信息。
第21行到第31行是找到含有section 部的提示行。接着33行到44行是读入信息内容。在41行使用标准C库函数sscanf读入键名称和键值对。然后使用map容器的insert方法将内容插入到容器中。其中make_pair是stl库中将一对类组合成一个成员类的模版函数，正好适合map成员类的产生。这些内容可以参考C++的书籍。
将IniPropsLoad类作为Properties类的模版参数，便可以产生一个使用的Propertie类了。如上面xtl/IniProps.h中定义的：
typedef Properties<IniPropsLoad> IniProps;
这种将Properties设计成模版类，以便于提供不同的读取数据内容的装载类，提高了Properties的通用性和可重用性。
相应的测试程序修改如下：
# include "xtl/IniProps.h"
int
main(int argc, char* argv[])
{
const char* sec;
if ( argc > 1 )
sec = argv[1];
else
sec = "";
xtl::IniProps prop(std::cin, sec);
prop.list(std::cout);
if ( argc > 2 )
std::cout << "Key:<" << argv[2] << "> Value:" <<
prop.getProperty(argv[2]) << "/n";
return 0;
}
测试的结果见上一篇介绍。如上一篇所介绍的，上面的prop.list(std::cout)也可以使用 std::cout << prop替代。另外，由于Properties类继承了stl库中的map类，还可以调用map类的方法，以满足其他特别的需求。比如，可以调用clear方法清除Properties类中的数据，然后再调用load重新装载数据。
自我欣赏一下，感觉这个类的设计精巧、实用、灵活。你觉得呢？欢迎给出建议。有不明白的地方也可以提问。
计划在下一篇，再介绍一下读取XML格式文件的Properties的实现。进一步感受一下其灵活性和可扩展性。
本篇在前两篇的基础上，进一步给出XML格式文件装载的Properties类的实现。如前所述，正是因为我们将Properties设计成为一个模版类，使得装载的过程和方式称为模版的参数，使得Properties成为一个可以适应装载不同方式和格式的配置文件信息的实用类。在前一篇，我们实现了ini文件格式的装载。本篇我们来实现xml格式的装载。
首先来说明一下我们规定的xml的格式。下面是一个实际的xml格式的配置属性信息内容，文件名称为 props.xml:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd" >
<prop>
<node01>
<comment>node01 configure</comment>
<entry key="host">127.0.0.1</entry>
<entry key="port">3001</entry>
<entry key="nodeid">101-12345</entry>
<entry key="acno">100000000000</entry>
<entry key="teller">Auter01</entry>
<entry key="market">201</entry>
<entry key="quantity">1234</entry>
<entry key="ctimeout">6000</entry>
</node01>
<node02>
<comment>node02 configue</comment>,
<entry key="host">127.0.0.1</entry>
<entry key="port">3002</entry>
<entry key="nodeid">102-12345</entry>
<entry key="acno">100000000000</entry>
<entry key="teller">Auter02</entry>
<entry key="market">201</entry>
<entry key="quantity">1234</entry>
<entry key="ctimeout">6000</entry>
</node02>
</prop>
在上面的内容中，根结点prop只是表示一个xml数据的开始。第二层结点为Properties的Section名称。第三层结点中的entry名称的结点为各个属性结点。其中的key属性的值为Properties的关键字名称，结点的实际内容为对应这个这个关键字的实际的值。
现在，我们来实现对上面格式的xml文件的装载实现。如IniProps的实现一样，我们首先定义一个XMLProps的类。下面是这个类的定义头文件 xtl/XMLProps.h:
1
2 /* xtl/XMLProps.h
3 Author: ZhangTao
4 Date: Nov 6, 2008
5 */
6
7 # ifndef XMLProps_h
8 # define XMLProps_h
9
10 # include "xtl/Properties.h"
11
12 namespace xtl {
13
14 class XMLPropsLoad {
15 public:
16 void operator() (PropMap& props, std::istream& is, const char* section);
17 };
18
19 typedef Properties<XMLPropsLoad> XMLProps;
20
21 const char* const XML_ENTRY = "entry"; // Property node entry name
22 const char* const XML_KEY = "key"; // Property key name
23 const char* const DEFAULT_SECTION = "default"; // default section
24
25 } // end of <namespace xtl>
26
27 # endif /* end of <ifndef XMLPropsLoad_h> */
28
与上一篇的xtl/iniProps.h内容比较，可以看出，除了类的名称外，它们的内容几乎相同。在21行到23行定义了三个常量，用于装载函数中使用。比较上面的xml内容，可以看出XML_ENTRY对应的是属性结点的名称；XML_KEY对应的是关键字的xml结点属性名称。DEFAULT_SECTION是定义了缺省的属性部的名称。
实现的文件名称为 XMLPropsLoad.cpp。其中使用了开源的xml2的函数库作为xml的解析工具。内容如下：
1 /* XMLProps.cpp
2 Author: ZhangTao
3 Date: Nov 6, 2008
4 */
5
6 # include <sstream>
7
8 # include "libxml/parser.h"
9 # include "xtl/utilfunc.h"
10 # include "xtl/XMLProps.h"
11
12 namespace xtl {
13
14 DeclareThisFile;
15
16 void XMLPropsLoad::operator() (PropMap& props, std::istream& is,
17 const char* section)
18 {
19 std::stringstream iss;
20
21 iss << is.rdbuf();
22
23 const std::string& xmlStr = iss.str();
24
25 xmlDocPtr xdoc = xmlReadMemory(xmlStr.c_str(), xmlStr.size(), "Prop", 0, 0);
26
27 if ( xdoc == 0 )
28 ThrowUtilExceptWithSource("Invalid XML stream", "");
29
30 // goto root level
31 xmlNodePtr curNode = xmlDocGetRootElement(xdoc);
32
33 // goto <section> level
34 if ( (curNode == 0) || ((curNode = curNode->xmlChildrenNode) == 0) )
35 ThrowUtilExceptWithSource("Empty XML stream", "");
36
37
38 if ( isEmptyStr(section) )
39 section = DEFAULT_SECTION;
40
41 while( (curNode != 0) && (xmlStrcmp(curNode->name,
42 (const xmlChar*)section) != 0) )
43 curNode = curNode->next;
44
45 if ( curNode == 0 )
46 ThrowUtilExceptWithSource("can not found <%s> node", section);
47
48 // goto <Property> level
49 curNode = curNode->xmlChildrenNode;
50
51 while( curNode != 0 ) {
52 if ( xmlStrcmp(curNode->name, (const xmlChar*)XML_ENTRY) == 0 ) {
53 xmlChar* key = xmlGetProp(curNode, (const xmlChar*)XML_KEY);
54 xmlChar* val = xmlNodeGetContent(curNode);
55
56 props.insert(make_pair(std::string((const char*)key),
57 std::string((const char*)val)));
58 xmlFree(key);
59 xmlFree(val);
60 }
61 curNode = curNode->next;
62 }
63 }
64
65 } // end of <namespace stl>
66
这里19行定义了一个字串流。21行通过输入流的rdbuf调用将输入流参数的内容读入到了字串流。通过字串流得到一个string类，从而又可以得到一个C字符串内容，满足了xml库读入内容的解析函数xmlReadMemory的参数要求。这些都属于C++标准库的操作，可以参考C++的有关输入输出流部分。接下来的过程便是xml解析函数的操作。56行是得到有关的属性值对后的插入操作。
同样的，我们编写一个测试程序tst-xmlprops.cpp如下：
# include "xtl/XMLProps.h"
int
main(int argc, char* argv[])
{
const char* sec;
if ( argc > 1 )
sec = argv[1];
else
sec = "";
xtl::XMLProps prop(std::cin, sec);
prop.list(std::cout);
if ( argc > 2 )
std::cout << "Key:<" << argv[2] << "> Value:" <<
prop.getProperty(argv[2]) << "/n";
return 0;
}
编译成目标码 tst-xmlprops，使用上面的xml文件作为测试内容。
# ./tst-xmlprops node01 port <props.xml
acno = 100000000000
ctimeout = 6000
host = 127.0.0.1
market = 201
nodeid = 101-12345
port = 3001
quantity = 1234
teller = Auter01
Key:<port> Value:3001
至此，大功告成。
下一篇，将介绍一个Properties类的应用实例。
