Wince读取ini的CIniParse类

 

 //========================================================================
//TITLE:
//    Wince读取ini的CIniParse类
//AUTHOR:
//    norains
//DATE:
//    Monday 22-December-2008
//Environment:
//    WINCE5.0 + VS2005 + ARM BSP
//========================================================================   
   
    挺奇怪的是，微软在wince中没有像桌面系统般有读取ini的特定函数。为了解决该问题，网上有不少牛人都给给出了相应的解决方案，比如说：
   
    benkaoya的直接C++/C代码读写：http://blog.csdn.net/benkaoya/archive/2008/01/28/2070648.aspx
   
    xumercury的将以上函数封装为类：http://blog.csdn.net/xumercury/archive/2008/07/09/2629346.aspx
   
    khan的STL读写类：http://www.cppblog.com/Khan/archive/2007/08/09/29459.html?opt=admin
   
    不过，以上的这几个都有一些小问题，或是效率较低，或是有一些小bug，其实最引起自己重写冲动的是因为命名规则和自己的理念有冲突，所以索性就自己另起炉灶弄了个CIniParse。因为习惯问题，我的代码基本上充斥的是STL代码，如果不喜欢这风格，可以使用benkaoya或xumercury的作品，他们的这个代码也是比较成熟的；关于khan的LIniFile类，在他blog的留言中，似乎公布的这个类代码是有缺陷的，完整的代码需要发信向其索取。因为我没有他的完整版代码，所以我也不做更多的评论。
   
    写完这段有损人利己嫌疑的言语后，我们来看看今天的主角：CIniParse。之前说了别人的代码的缺陷，现在也该说说CIniParse所存在的一些问题了。可能最让人不爽的是，CIniParse类在保存的时候，会将原来的注释全部清除掉，并且原来的顺序也全部重排。如果注释以及顺序对你非常重要，请勿使用CIniParse类。
   
    除此以外，该类并不能在ASCII环境中编译通过。只是wince是UNICODE的系统，所以这点在平时使用中倒不会引起很大的麻烦。当然，如果你是打算移植到VC6.0中，那么可能有一些函数就必须要修正了。再一点就是，该类没有详细地进行测试，所以应该还会有或多或少的问题，如果你发现了，也希望我更正，期待你的指出。
   
    惯例，先罗列出CIniParse的完整代码：
   
    头文件：

2. //Class Name
3. // CIniParse
4. //
5. //Version:
6. // 1.0.0
7. //
8. //Date:
9. // 2008.12.22
10. //
11. //Author:
12. // norains
13. //////////////////////////////////////////////////////////////////////
15. #pragma once
17. #include "windows.h"
18. #include <string>
19. #include <vector>
20. #include <map>
22. #ifdef UNICODE
23.  #ifndef TSTRING
24.   #define TSTRING std::wstring
25.  #endif
26. #else
27.  #ifndef TSTRING
28.   #define TSTRING std::string
29.  #endif
30. #endif
33. class CIniParse
34. {
35. public:
36.  //-------------------------------------------------------------------------------
37.  //Description:
38.  // Open the ini file.
39.  //-------------------------------------------------------------------------------
40.  BOOL Open(TSTRING strFile);
42.  //-------------------------------------------------------------------------------
43.  //Description:
44.  // Get the profile value as string type
45.  //-------------------------------------------------------------------------------
46.  TSTRING GetPrivateProfileString(const TSTRING &strSection,const TSTRING &strKey);
48.  //-------------------------------------------------------------------------------
49.  //Description:
50.  // Get the profile value as int type
51.  //-------------------------------------------------------------------------------
52.  int GetPrivateProfileInt(const TSTRING &strSection,const TSTRING &strKey);
54.  //-------------------------------------------------------------------------------
55.  //Description:
56.  // Set the profile value as string type.The function wouldn't save the data to file
57.  //but memory. If you want to save to the file, you must call Flush function
58.  //-------------------------------------------------------------------------------
59.  BOOL SetPrivateProfileString(const TSTRING &strSection,const TSTRING &strKey,TSTRING strSet);
61.  //-------------------------------------------------------------------------------
62.  //Description:
63.  // Set the profile value as int type.The function wouldn't save the data to file
64.  //but memory. If you want to save to the file, you must call Flush function
65.  //-------------------------------------------------------------------------------
66.  BOOL SetPrivateProfileInt(const TSTRING &strSection,const TSTRING &strKey,int iSet);
68.  //-------------------------------------------------------------------------------
69.  //Description:
70.  // Flush the memory buffer to the file
71.  //-------------------------------------------------------------------------------
72.  BOOL Flush();
74. public:
75.  CIniParse();
76.  virtual ~CIniParse();
79. private:
80.  //-------------------------------------------------------------------------------
81.  //Description:
82.  // Get the line value base on the current offset. After calling, the offset value
83.  //would move to the head of next line
84.  //-------------------------------------------------------------------------------
85.  TSTRING GetLine();
87.  //-------------------------------------------------------------------------------
88.  //Description:
89.  // Check the string value of one line whether is comment or not
90.  //-------------------------------------------------------------------------------
91.  static BOOL IsCommentLine(const TSTRING & strLine);
93.  //-------------------------------------------------------------------------------
94.  //Description:
95.  // Check the string value of one line whether is the section.
96.  //Parameters:
97.  // strLine : [in] The string value buffer.
98.  //-------------------------------------------------------------------------------
99.  static BOOL IsSectionLine(const TSTRING & strLine);
102.  //-------------------------------------------------------------------------------
103.  //Description:
104.  // Get the key value from one line
105.  //Parameters:
106.  // strLine : [in] The buffer to find
107.  //-------------------------------------------------------------------------------
108.  static TSTRING GetKeyValueFromLine(const TSTRING & strLine);
111.  //-------------------------------------------------------------------------------
112.  //Description:
113.  // Get the key name from one line
114.  //Parameters:
115.  // strLine : [in] The buffer to find
116.  //-------------------------------------------------------------------------------
117.  static TSTRING GetKeyNameFromLine(const TSTRING & strLine);
119.  //-------------------------------------------------------------------------------
120.  //Description:
121.  // Get the section name from one line
122.  //Parameters:
123.  // strLine : [in] The buffer to find
124.  //-------------------------------------------------------------------------------
125.  static TSTRING GetSectionNameFromLine(const TSTRING & strLine);
127.  //-------------------------------------------------------------------------------
128.  //Description:
129.  // Remove the space from the string
130.  //Parameters:
131.  // strBuf : [in] The buffer to remove
132.  //Return Value:
133.  // Return the string without space
134.  //-------------------------------------------------------------------------------
135.  static TSTRING RemoveSpace(const TSTRING &strBuf);
138.  //-------------------------------------------------------------------------------
139.  //Description:
140.  // Parse the ini file
141.  //-------------------------------------------------------------------------------
142.  void Parse(const TSTRING &strBuf);
144.  //-------------------------------------------------------------------------------
145.  //Description:
146.  // Convert the string to  lowercase
147.  //-------------------------------------------------------------------------------
148.  static TSTRING ConvertToLowercase(const TSTRING &strBuf);
150.  //-------------------------------------------------------------------------------
151.  //Description:
152.  // Reset the offset point to the begin
153.  //-------------------------------------------------------------------------------
154.  BOOL ResetOffset();
156.  //-------------------------------------------------------------------------------
157.  //Description:
158.  // Check whether the offset arrived the end of the buffer.
159.  //-------------------------------------------------------------------------------
160.  BOOL IsOffsetEnd();
163. private:
164.  TSTRING m_strFileBuf;
165.  TSTRING::size_type m_stOffset;
166.  TSTRING m_strFilePath;
167.  std::map<TSTRING, std::map<TSTRING,TSTRING> > m_mpValue; //The first TSTRING is section name, the second is key name and last is the value.
168. };
170.     

   

 

实现体：
 

1.    #include "IniParse.h"
2. #include <deque>
3. #include <algorithm>
7. CIniParse::CIniParse():
8. m_stOffset(0)
9. {}
11. CIniParse::~CIniParse()
12. {}
14. BOOL CIniParse::Open(TSTRING strFile)
15. {
16.  HANDLE hFile = CreateFile(strFile.c_str(),GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
17.  if(hFile == INVALID_HANDLE_VALUE)
18.  {
19.   return FALSE;
20.  }
22.  m_strFilePath = strFile;
24.  DWORD dwSize = GetFileSize(hFile,NULL);
26.  //Read the file to buffer
27.  std::vector<BYTE> vtBuf(dwSize,0);
28.  DWORD dwRead = 0;
29.  ReadFile(hFile,&vtBuf[0],vtBuf.size(),&dwRead,NULL);
30.  vtBuf.resize(dwRead);
32.  CloseHandle(hFile);
34.  #ifdef UNICODE
36.   m_strFileBuf.clear();
38.   if(vtBuf.size() >= 2)
39.   {
40.    if(vtBuf[0] == 0xFF && vtBuf[1] == 0xFE)
41.    {
42.     //Unicode file
44.     //Convert the read buffer to the unicode.The TCHAR here is equal to wchar_t
45.     std::deque<TCHAR> dqBuf;
46.     for(std::vector<BYTE>::size_type i = 2; i < vtBuf.size(); i += 2)
47.     {
48.      dqBuf.push_back(vtBuf[i] + (vtBuf[i+1] << 8));
49.     }
51.     
52.     m_strFileBuf.insert(m_strFileBuf.end(),dqBuf.begin(),dqBuf.end());
53.    }
54.    else
55.    {
56.     std::vector<TCHAR> vtBufT;
57.     vtBufT.resize(MultiByteToWideChar (CP_ACP, 0, reinterpret_cast<char *>(&vtBuf[0]), vtBuf.size(), NULL, 0));
58.     MultiByteToWideChar (CP_ACP, 0, reinterpret_cast<char *>(&vtBuf[0]), vtBuf.size(), &vtBufT[0], vtBufT.size());  
59.    
60.     m_strFileBuf.insert(m_strFileBuf.end(),vtBufT.begin(),vtBufT.end());
61.    }
62.   }
64.  #else
66.   #error "Unfortunately! The source code donesn't complete in the ASCII environment"
68.  #endif
73.  Parse(m_strFileBuf);
75.  return TRUE;
76. }
78. TSTRING CIniParse::GetLine()
79. {
80.  TSTRING strReturn;
82.  if(m_stOffset >= m_strFileBuf.size())
83.  {
84.   return TSTRING();
85.  }
87.  TSTRING::size_type stPos = m_strFileBuf.find(TEXT("/r/n"),m_stOffset);
88.  if(stPos == TSTRING::npos)
89.  {
90.   strReturn.insert(0,m_strFileBuf,m_stOffset,m_strFileBuf.size() - m_stOffset + 1); 
92.   //Move the offset position to end of the file
93.   m_stOffset = m_strFileBuf.size() + 1;
94.  }
95.  else
96.  {
97.   strReturn.insert(0,m_strFileBuf,m_stOffset,stPos - m_stOffset); 
99.   //Move the offset position to the back of the "/r/n" 
100.   m_stOffset = stPos + 2;
102.  }
104.  return strReturn;
105. }
107. BOOL CIniParse::IsCommentLine(const TSTRING &strLine)
108. {
109.  if(strLine.empty() != FALSE || strLine[0] == ';')
110.  {
111.   return TRUE;
112.  }
113.  else
114.  {
115.   return FALSE;
116.  }
117. }
119. BOOL CIniParse::IsSectionLine(const TSTRING &strLine)
120. {
121.  TSTRING::size_type stLeft = strLine.find(TEXT("["));
122.  TSTRING::size_type stRight = strLine.find(TEXT("]"));
123.  if(strLine.empty() == FALSE && stLeft != TSTRING::npos && stRight != TSTRING::npos && stRight > stLeft)
124.  {
125.   return TRUE;
126.  }
127.  else
128.  {
129.   return FALSE;
130.  }
131. }
133. TSTRING CIniParse::GetKeyValueFromLine(const TSTRING &strLine)
134. {
135.  TSTRING::size_type stPosEqual = strLine.find(TEXT("="));
136.  if(stPosEqual == TSTRING::npos)
137.  {
138.   return TSTRING();
139.  }
143.  TSTRING strReturn;
145.  TSTRING::size_type stPosQuoteLeft = strLine.find(TEXT("/""),stPosEqual);
146.  if(stPosQuoteLeft != TSTRING::npos)
147.  {
148.   TSTRING::size_type stPosQuoteRight = strLine.find(TEXT("/""),stPosQuoteLeft + 1);
149.   if(stPosQuoteRight != TSTRING::npos && stPosQuoteLeft + 1 != stPosQuoteRight)
150.   {
151.    strReturn.insert(0,strLine,stPosQuoteLeft + 1,stPosQuoteRight - stPosQuoteLeft - 1);
152.    return strReturn;
153.   }
154.  }
157.  //Store the string to the buffer
158.  if(stPosEqual + 1 > strLine.size())
159.  {
160.   return TSTRING();
161.  }
162.  TSTRING strBuf(strLine,stPosEqual + 1,strLine.size() - stPosEqual);;
163.  return RemoveSpace(strBuf);
164. }
167. TSTRING CIniParse::GetKeyNameFromLine(const TSTRING &strLine)
168. {
169.  TSTRING::size_type stPosEqual = strLine.find(TEXT("="));
170.  if(stPosEqual == 0)
171.  {
172.   return TSTRING();
173.  }
175.  TSTRING strBuf;
176.  if(stPosEqual == TSTRING::npos)
177.  {
178.   //All of the string line is the key name
179.   strBuf = strLine;
180.  }
181.  else
182.  {
183.   strBuf.clear();
184.   strBuf.insert(0,strLine,0,stPosEqual);
185.  }
187.  return RemoveSpace(strBuf);
189. }
191. TSTRING CIniParse::GetSectionNameFromLine(const TSTRING &strLine)
192. {
193.  TSTRING::size_type stLeft = strLine.find(TEXT("["));
194.  TSTRING::size_type stRight = strLine.find(TEXT("]"));
195.  if(!(strLine.empty() == FALSE && stLeft != TSTRING::npos && stRight != TSTRING::npos && stRight > stLeft))
196.  {
197.   return TSTRING();
198.  }
200.  TSTRING strBuf(strLine,stLeft + 1,stRight - stLeft - 1); 
201.  return RemoveSpace(strBuf);
203. }
205. TSTRING CIniParse::RemoveSpace(const TSTRING &strBuf)
206. {
207.  if(strBuf.find(TEXT(" ")) != TSTRING::npos)
208.  {
209.   //Remove the space
210.   TSTRING strReturn;
211.   for(TSTRING::size_type stPos = 0; stPos < strBuf.size(); stPos ++)
212.   {
213.    if(strBuf[stPos] != ' ')
214.    {
215.     strReturn.push_back(strBuf[stPos]);
216.    }
217.   }
218.   return strReturn;
219.  }
220.  else
221.  {
222.   //No space
223.   return strBuf;
224.  }
225. }
227. void CIniParse::Parse(const TSTRING &strBuf)
228. {
229.  //Reset the file pointer to the begin
230.  ResetOffset();
232.  std::map<TSTRING,TSTRING> mpKey;
233.  TSTRING strSection;
235.  while(TRUE)
236.  {
237.   TSTRING strLine = GetLine();
239.   if(strLine.empty() != FALSE || IsCommentLine(strLine) != FALSE)
240.   {
241.    if(IsOffsetEnd())
242.    {
243.     break;
244.    }
245.    else
246.    {
247.     continue;
248.    }
249.   }
251.   if(IsSectionLine(strLine) != FALSE)
252.   {   
253.    if(strSection.empty() != FALSE)
254.    {
255.     //It's the first section
257.     strSection = GetSectionNameFromLine(strLine);
258.     continue;
259.    }
261.    //Store the last section value
262.    m_mpValue.insert(std::make_pair(strSection,mpKey));
264.    strSection = GetSectionNameFromLine(strLine);
265.    mpKey.clear();
266.   }
267.   else
268.   {
269.    if(strSection.empty() != FALSE)
270.    {
271.     //The section name is empty, so needn't store the key value
272.     continue;
273.    }
275.    //Store the key value and name
276.    TSTRING strKeyName = GetKeyNameFromLine(strLine);
277.    if(strKeyName.empty() == FALSE)
278.    {
279.     mpKey.insert(std::make_pair(strKeyName,GetKeyValueFromLine(strLine)));
280.    }
281.   }
282.  }
284.  //Store the last section value
285.  if(strSection.empty() == FALSE)
286.  {
287.   m_mpValue.insert(std::make_pair(strSection,mpKey));
288.  }
289. }
292. TSTRING CIniParse::ConvertToLowercase(const TSTRING &strBuf)
293. {
294.  std::vector<TCHAR> vtBuf(strBuf.length() + 1,0);
295.  _tcscpy(&vtBuf[0],strBuf.c_str());
296.  return _tcslwr(&vtBuf[0]);
297. }
299. BOOL CIniParse::ResetOffset()
300. {
301.  m_stOffset = 0;
302.  return TRUE;
303. }
305. BOOL CIniParse::IsOffsetEnd()
306. {
307.  if(m_stOffset >= m_strFileBuf.size())
308.  {
309.   return TRUE;
310.  }
311.  else
312.  {
313.   return FALSE;
314.  }
315. }
317. TSTRING CIniParse::GetPrivateProfileString(const TSTRING &strSection,const TSTRING &strKey)
318. {
319.  if(m_mpValue.empty() != FALSE)
320.  {
321.   return TSTRING();
322.  }
324.  //Ignoring the character case to find the specified key 
325.  for(std::map<TSTRING, std::map<TSTRING,TSTRING>>::iterator iterSection = m_mpValue.begin(); iterSection != m_mpValue.end(); iterSection ++)
326.  {
327.   if(ConvertToLowercase(iterSection->first) == ConvertToLowercase(strSection))
328.   {
329.    for(std::map<TSTRING,TSTRING>::iterator iterKey = iterSection->second.begin(); iterKey != iterSection->second.end(); iterKey ++)
330.    {
331.     if(ConvertToLowercase(iterKey->first) == ConvertToLowercase(strKey))
332.     {
333.      return iterKey->second;
334.     }
335.    }
336.   }
337.  }
339.  return TSTRING();
340. }
342. int CIniParse::GetPrivateProfileInt(const TSTRING &strSection,const TSTRING &strKey)
343. {
344.  return _ttoi(GetPrivateProfileString(strSection,strKey).c_str());
345. }
347. BOOL CIniParse::SetPrivateProfileString(const TSTRING &strSection,const TSTRING &strKey,TSTRING strSet)
348. {
351.  //Ignoring the character case to find the specified key 
352.  for(std::map<TSTRING, std::map<TSTRING,TSTRING>>::iterator iterSection = m_mpValue.begin(); iterSection != m_mpValue.end(); iterSection ++)
353.  {
354.   if(ConvertToLowercase(iterSection->first) == ConvertToLowercase(strSection))
355.   {
356.    for(std::map<TSTRING,TSTRING>::iterator iterKey = iterSection->second.begin(); iterKey != iterSection->second.end(); iterKey ++)
357.    {
358.     if(ConvertToLowercase(iterKey->first) == ConvertToLowercase(strKey))
359.     {
360.      iterKey->second = strSet;
361.      return TRUE;
362.     }
363.    }
365.    //Add the new key value
366.    iterSection->second.insert(std::make_pair(strKey,strSet));
368.    return TRUE;
369.   }
370.  }
373.  //Add the new section and key value
374.  std::map<TSTRING,TSTRING> mpKey;
375.  mpKey.insert(std::make_pair(strKey,strSet));
376.  m_mpValue.insert(std::make_pair(strSection,mpKey));
378.  return TRUE;
379. }
381. BOOL CIniParse::SetPrivateProfileInt(const TSTRING &strSection,const TSTRING &strKey,int iSet)
382. {
383.  std::vector<TCHAR> vtBuf(MAX_PATH,0);
384.  TSTRING strSet = _itot(iSet,&vtBuf[0],10);
385.  return SetPrivateProfileString(strSection,strKey,strSet);
386. }
388. BOOL CIniParse::Flush()
389. {
390.  TSTRING strWrite;
391.  //strWrite.reserve(m_mpValue.size());
393.  //Store the string value to the buffer
394.  for(std::map<TSTRING, std::map<TSTRING,TSTRING>>::iterator iterSection = m_mpValue.begin(); iterSection != m_mpValue.end(); iterSection ++)
395.  {
396.   strWrite += TEXT("/r/n[");
397.   strWrite += iterSection->first;
398.   strWrite += TEXT("]/r/n");
400.   for(std::map<TSTRING,TSTRING>::iterator iterKey = iterSection->second.begin(); iterKey != iterSection->second.end(); iterKey ++)
401.   {
402.    strWrite += iterKey->first;
403.    strWrite += TEXT("=");
404.    strWrite += iterKey->second;
405.    strWrite += TEXT("/r/n");
406.   }
407.  }
410.  //Write to the file
411.  HANDLE hFile = CreateFile(m_strFilePath.c_str(),GENERIC_WRITE,NULL,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
412.  if(INVALID_HANDLE_VALUE != hFile)
413.  {
415.   std::vector<BYTE> vtWrite;
416.   vtWrite.reserve(sizeof(TCHAR) * strWrite.size());
417.     
418.   #ifdef UNICODE
419.    vtWrite.push_back(0xFF);
420.    vtWrite.push_back(0xFE);
421.    for(TSTRING::iterator iter = strWrite.begin(); iter != strWrite.end(); iter++)
422.    {
423.     vtWrite.push_back(static_cast<BYTE>(*iter));
424.     vtWrite.push_back((*iter)>>8);
425.    }
426.   #else
427.    vtWrite.assign(strWrite.begin(),strWrite.end());
428.   #endif
430.   DWORD dwWrite = 0;
431.   WriteFile(hFile,&vtWrite[0],vtWrite.size(),&dwWrite,NULL);
432.   CloseHandle(hFile);
434.   return TRUE;
435.  }
436.  else
437.  {
438.   return FALSE;
439.  } 
440. }
442.     

具体使用如下：
 

1.    int WINAPI WinMain( HINSTANCE hInstance,
2.      HINSTANCE hPrevInstance,
3.      LPTSTR    lpCmdLine,
4.      int       nCmdShow)
5. {
7.  //声明一个对象
8.  CIniParse iniParse;
10.  //打开相应的ini文件
11.  iniParse.Open(TEXT("//NAND//test.ini"));
13.  TSTRING strValue ;
14.  int iValue = 0;
16.  //获取特定的SECTION和KEY的数值。可以有两种返回形式，一种是TSTRING，另一种是int。
17.  strValue = iniParse.GetPrivateProfileString(TEXT("VERSION_INI_FILE"),TEXT("VERSION_CONFIG_INFO")); 
18.  iValue = iniParse.GetPrivateProfileInt(TEXT("VERSION_INI_FILE"),TEXT("VERSION_CONFIG_INFO"));
20.  //更改相应KEY的数值
21.  iniParse.SetPrivateProfileString(TEXT("VERSION_INI_FILE"),TEXT("VERSION_CONFIG_INFO"),TEXT("5600")); 
22.  strValue = iniParse.GetPrivateProfileString(TEXT("VERSION_INI_FILE"),TEXT("VERSION_CONFIG_INFO")); 
25.  //增加新的SECTION和KEY数值
26.  iniParse.SetPrivateProfileString(TEXT("VERSION_INI_FILE_NEW"),TEXT("VERSION_CONFIG_INFO_NEW"),TEXT("98600")); 
27.  strValue = iniParse.GetPrivateProfileString(TEXT("VERSION_INI_FILE_NEW"),TEXT("VERSION_CONFIG_INFO_NEW")); 
29.  //写到文件中
30.  iniParse.Flush();
32.  return 0; 
33. }

    在这里还有一点需要注意的是，因为从效率考虑，SetPrivateProfileString函数更改的数值都只是在内存中做修改，如果需要保存到文件中，需要调用Flush函数。调用Flush函数后，内存的数据就保存到之前Open传入的文件路径中。
   
    如果想保存到C++动态数组中，也可以实现，只是有点麻烦：
    

2.   strValue = iniParse.GetPrivateProfileString(TEXT("VERSION_INI_FILE_NEW"),TEXT("VERSION_CONFIG_INFO_NEW"));  
3.  TCHAR *pNewBuf = new TCHAR[strValue.size() + 1];
4.  _tcscpy(pNewBuf,strValue.c_str());
5.  delete []pNewBuf;

 用动态数组还需要手动释放资源，相对来说，就不如直接用STL来得更为简便。