Utilisation de Boost.Regex

#ifndef MyRegex_INCLUDED
#define MyRegex_INCLUDED
 
#include <string>
#include <vector>
#include <boost/regex.hpp>
 
class CMyRegex
{
public:
   typedef enum
   { CMyRegex_NoError,
     CMyRegex_InvalidRegex,
     CMyRegex_EmptyRegex,
     CMyRegex_NoMatch,
     CMyRegex_TranslateError,
     CMyRegex_MemoryError,
     CMyRegex_SettingError,
   } CMyRegexError_t;
 
   // The constructor with no string
   inline CMyRegex(void) { }
 
   // The explicit constructor with a ANSI string
   inline explicit CMyRegex(const std::string & Regex) { SetRegex(Regex); }
 
   // The explicit constructor with a UNICODE string
   inline explicit CMyRegex(const std::wstring & Regex) { SetRegex(Regex); }
 
   // Reset all parameter of the class
   void Reset(void);
 
   // The functions to manipulate the regular expression
   bool SetRegex(const std::string & Regex);
   bool SetRegex(const std::wstring & Regex);
   inline const std::wstring & GetRegex(void) const { return m_regex_str; }
 
   // The functions to check a string with the current regular expression
   bool Match(const std::string & Expression);
   bool Match(const std::wstring & Expression);
 
   // The functions to check a string with the current regular expression.
   // This set of function return the sub string
   bool Match(const std::string & Expression, std::vector<std::wstring> & ArrayValue);
   bool Match(const std::wstring & Expression, std::vector<std::wstring> & ArrayValue);
 
   // The function to get the last error message
   const std::wstring GetLastError(void) const;
 
private:
   // The function to translate a ANSI string into a UNICODE string
   bool translate(const std::string & AString, std::wstring & WString);
 
   // The functions to set the last error message
   void set_last_error(const CMyRegexError_t Code, const std::string & MoreInfo = "");
 
   //
   // The members
   // -----------
 
   // The current regular expression
   std::wstring m_regex_str;
 
   // The boost regex object used to match
   boost::wregex m_regex_obj;
 
   // The last error message
   CMyRegexError_t m_last_error;
   std::wstring m_last_error_moreinfo;
};
 
#endif // #ifndef MyRegex_INCLUDED

#include "MyRegex.h"
#include <Windows.h>
 
// Reset all parameter of the class
void CMyRegex::Reset(void)
{
   SetRegex(L"");
   set_last_error(CMyRegex_NoError);
}
 
// Set the regular expression with a ANSI string
bool CMyRegex::SetRegex(const std::string & Regex)
{
   // translate the ANSI string into a UNICODE string
   std::wstring str;
   if(translate(Regex, str) == false)
   {
      // An error while translating
      return false;
   }
 
   // Set the regular expression (with a UNICODE string)
   return SetRegex(str);
}
 
// Set the regular expression with a UNICODE string
bool CMyRegex::SetRegex(const std::wstring & Regex)
{
   try
   {
      // Try to set the regular expression
      m_regex_obj.assign(Regex, boost::regex_constants::extended);
 
      // Save the regular expression
      m_regex_str = Regex;
      return true;
   }
   catch(const std::exception & e)
   {
      // An error while setting the regular expression
      set_last_error(CMyRegex_InvalidRegex, e.what());
      m_regex_str = L"";
      return false;
   }
}
 
// Match a ANSI string against the current regular expression
bool CMyRegex::Match(const std::string & Expression)
{
   // translate the ANSI string into a UNICODE string
   std::wstring str;
   if(translate(Expression, str) == false)
   {
      // Translate error
      return false;
   }
 
   // Match the string
   return Match(str);
}
 
// Match a UNICODE string against the current regular expression
bool CMyRegex::Match(const std::wstring & Expression)
{
   // Check if a regex is set
   if(GetRegex().length() == 0)
   {
      // The regex is not set
      set_last_error(CMyRegex_EmptyRegex);
      return false;
   }
 
   try
   {
      // Match the string against the current regular expression
      if(regex_match(Expression, m_regex_obj) == false)
      {
         // The expression does not match the regex
         set_last_error(CMyRegex_NoMatch);
         return false;
      }
      return true;
   }
   catch(const std::exception & e)
   {
      // An exception, it is probably an error
      set_last_error(CMyRegex_NoMatch, e.what());
      return false;
   }
}
 
// Match a ANSI string against the current regular expression
bool CMyRegex::Match(const std::string & Expression, std::vector<std::wstring> & ArrayValue)
{
   // translate the ANSI string into a UNICODE string
   std::wstring str;
   if(translate(Expression, str) == false)
   {
      // Translate error
      return false;
   }
 
   // Match the string
   return Match(str, ArrayValue);
}
 
// Match a UNICODE string against the current regular expression
bool CMyRegex::Match(const std::wstring & Expression, std::vector<std::wstring> & ArrayValue)
{
   // Empty the array of values
   ArrayValue.clear();
 
   // Check if a regex is set
   if(GetRegex().length() == 0)
   {
      // The regex is not set
      set_last_error(CMyRegex_EmptyRegex);
      return false;
   }
 
   try
   {
      // Match the string against the current regular expression
      boost::wsmatch what;
      if(regex_match(Expression, what, m_regex_obj) == false)
      {
         // The expression does not match the regex
         set_last_error(CMyRegex_NoMatch);
         return false;
      }
 
      // Read all values
      for(unsigned int boucle = 0; boucle != what.size(); boucle++)
      {
         // Make a temporary string
         std::wstring str;
         str.assign(what[boucle].first, what[boucle].second);
 
         // Add the temporary string into the array
         ArrayValue.push_back(str);
      }
      return true;
   }
   catch(const std::exception & e)
   {
      // An exception, it is probably an error
      set_last_error(CMyRegex_NoMatch, e.what());
      return false;
   }
}
 
// translate a ANSI string into a UNICODE string
bool CMyRegex::translate(const std::string & AString, std::wstring & WString)
{
   // Try to translate the string (1st try)
   wchar_t buffer[1024];
   int ret = ::MultiByteToWideChar(CP_ACP, 0, AString.c_str(), -1, buffer, sizeof(buffer) / sizeof(buffer[0]));
   if(ret != 0)
   {
      // The translate is correct
      WString = buffer;
      return true;
   }
 
   // Test the error to check if the buffer is big enougth
   if(::GetLastError() != ERROR_INSUFFICIENT_BUFFER)
   {
      set_last_error(CMyRegex_TranslateError);
      return false;
   }
 
   // Ask the needed size to translate the string
   ret = ::MultiByteToWideChar(CP_ACP, 0, AString.c_str(), -1, NULL, 0);
   if(ret == 0)
   {
      // An error while translating
      set_last_error(CMyRegex_TranslateError);
      return false;
   }
 
   // Allocate a buffer large enougth and store it in a boost::scoped_array object
   boost::scoped_array<wchar_t> p_buf(new wchar_t [ret]);
   if(p_buf.get() == NULL)
   {
      // A memory allocation error
      set_last_error(CMyRegex_MemoryError);
      return false;
   }
 
   // Perform the translate (2nd try)
   ret = ::MultiByteToWideChar(CP_ACP, 0, AString.c_str(), -1, p_buf.get(), ret);
   if(ret == 0)
   {
      // An error while translating
      set_last_error(CMyRegex_TranslateError);
      return false;
   }
 
   // The translate is correct
   WString = p_buf.get();
   return true;
}
 
// Set the last error
void CMyRegex::set_last_error(const CMyRegexError_t Code, const std::string & MoreInfo /*= ""*/)
{
   // save the last error code
   m_last_error = Code;
 
   // Translate the information into a UNICODE string
   translate(MoreInfo, m_last_error_moreinfo);
}
 
const std::wstring CMyRegex::GetLastError(void) const
{
   std::wstring ret;
   switch(m_last_error)
   {
   default : ret = L"Unknown error"; break;
   case CMyRegex_NoError : ret = L"No error"; break;
   case CMyRegex_InvalidRegex : ret = L"Invalid regular expression"; break;
   case CMyRegex_EmptyRegex : ret = L"Regular expression is empty"; break;
   case CMyRegex_NoMatch : ret = L"Expression does not match with the regular expression"; break;
   case CMyRegex_TranslateError : ret = L"Error while translating an ANSI string to a UNICODE string"; break;
   case CMyRegex_MemoryError : ret = L"Memory allocation error"; break;
   case CMyRegex_SettingError : ret = L"Error while setting the error code"; break;
   }
 
   // add the more info string if not empty
   if(m_last_error_moreinfo.length() != 0)
      ret += L" (" + m_last_error_moreinfo + L")";
 
   return ret;
}

#include "MyRegex.h"
#include <iostream>
 
void check(const std::wstring & TestName, const CMyRegex & Regex, const std::vector<std::wstring> & Array, const bool ret)
{
   // display the test name
   std::wcout << TestName << L" : ";
   if(ret == false)
   {
      // display the error string and leave the function
      std::wcout << L"Echec - " << Regex.GetLastError() << std::endl;
      return;
   }
 
   // display OK
   std::wcout << L"OK" << std::endl;
 
   // display the string returned in the array (if any)
   for(size_t boucle = 0; boucle != Array.size(); boucle++)
   {
      std::wcout << L"\tArray[" << boucle << L"] = " << Array[boucle] << std::endl;
   }
}
 
int wmain(void)
{
   // the variables
   std::vector<std::wstring> val;
   CMyRegex regex;
 
   // the tests
   check(L"Regex ANSI invalide   ", regex, val, regex.SetRegex("(t(o).*"));
   check(L"Regex UNICODE invalide", regex, val, regex.SetRegex(L"t)(o).*"));
   check(L"Regex ANSI valide     ", regex, val, regex.SetRegex("(t)(o).*"));
   check(L"Regex UNICODE valide  ", regex, val, regex.SetRegex(L"(t)(o).*"));
 
   check(L"ANSI match pas        ", regex, val, regex.Match("otototototo"));
   check(L"UNICODE match pas     ", regex, val, regex.Match(L"otototototo"));
 
   check(L"ANSI match            ", regex, val, regex.Match("tototototo"));
   check(L"UNICODE match         ", regex, val, regex.Match(L"tototototo"));
 
   check(L"ANSI match pas        ", regex, val, regex.Match("otototototo", val));
   check(L"UNICODE match pas     ", regex, val, regex.Match(L"otototototo", val));
 
   check(L"ANSI match            ", regex, val, regex.Match("tototototo", val));
   check(L"UNICODE match         ", regex, val, regex.Match(L"tototototo", val));
 
   // test avec chaine vide
   check(L"chaine ANSI vide      ", regex, val, regex.Match(L""));
   check(L"chaine UNICODE vide   ", regex, val, regex.Match(""));
   check(L"chaine ANSI vide      ", regex, val, regex.Match(L"", val));
   check(L"chaine UNICODE vide   ", regex, val, regex.Match("", val));
 
   // expression régulière vide
   regex.Reset();
   check(L"chaine ANSI vide      ", regex, val, regex.Match(L""));
   check(L"chaine UNICODE vide   ", regex, val, regex.Match(""));
   check(L"chaine ANSI vide      ", regex, val, regex.Match(L"", val));
   check(L"chaine UNICODE vide   ", regex, val, regex.Match("", val));
 
   // Construction par copie
   regex.SetRegex(L"(t)(o).*");
   {
      CMyRegex regex2(regex);
      check(L"ANSI match            ", regex2, val, regex2.Match("tototototo"));
      check(L"UNICODE match         ", regex2, val, regex2.Match(L"tototototo"));
 
      check(L"ANSI match pas        ", regex2, val, regex2.Match("otototototo"));
      check(L"UNICODE match pas     ", regex2, val, regex2.Match(L"otototototo"));
   }
 
   // Construction par affectation
   {
      CMyRegex regex2;
      regex2 = regex;
      check(L"ANSI match            ", regex2, val, regex2.Match("tototototo"));
      check(L"UNICODE match         ", regex2, val, regex2.Match(L"tototototo"));
 
      check(L"ANSI match pas        ", regex2, val, regex2.Match("otototototo"));
      check(L"UNICODE match pas     ", regex2, val, regex2.Match(L"otototototo"));
   }
 
   // utilisation du constructeur explicit ANSI
   {
      CMyRegex regex2("(t)(o).*");
      check(L"ANSI match            ", regex2, val, regex2.Match("tototototo"));
      check(L"UNICODE match         ", regex2, val, regex2.Match(L"tototototo"));
 
      check(L"ANSI match pas        ", regex2, val, regex2.Match("otototototo"));
      check(L"UNICODE match pas     ", regex2, val, regex2.Match(L"otototototo"));
   }
 
   // utilisation du constructeur explicit UNICODE
   {
      CMyRegex regex2(L"(t)(o).*");
      check(L"ANSI match            ", regex2, val, regex2.Match("tototototo"));
      check(L"UNICODE match         ", regex2, val, regex2.Match(L"tototototo"));
 
      check(L"ANSI match pas        ", regex2, val, regex2.Match("otototototo"));
      check(L"UNICODE match pas     ", regex2, val, regex2.Match(L"otototototo"));
   }
 
   return 0;
}

Regex ANSI invalide    : Echec - Invalid regular expression (Unmatched ( or \()
Regex UNICODE invalide : Echec - Invalid regular expression (Unmatched ( or \()
Regex ANSI valide      : OK
Regex UNICODE valide   : OK
ANSI match pas         : Echec - Expression does not match with the regular expression
UNICODE match pas      : Echec - Expression does not match with the regular expression
ANSI match             : OK
UNICODE match          : OK
ANSI match pas         : Echec - Expression does not match with the regular expression
UNICODE match pas      : Echec - Expression does not match with the regular expression
ANSI match             : OK
        Array[0] = tototototo
        Array[1] = t
        Array[2] = o
UNICODE match          : OK
        Array[0] = tototototo
        Array[1] = t
        Array[2] = o
chaine ANSI vide       : Echec - Expression does not match with the regular expression
chaine UNICODE vide    : Echec - Expression does not match with the regular expression
chaine ANSI vide       : Echec - Expression does not match with the regular expression
chaine UNICODE vide    : Echec - Expression does not match with the regular expression
chaine ANSI vide       : Echec - Regular expression is empty
chaine UNICODE vide    : Echec - Regular expression is empty
chaine ANSI vide       : Echec - Regular expression is empty
chaine UNICODE vide    : Echec - Regular expression is empty
ANSI match             : OK
UNICODE match          : OK
ANSI match pas         : Echec - Expression does not match with the regular expression
UNICODE match pas      : Echec - Expression does not match with the regular expression
ANSI match             : OK
UNICODE match          : OK
ANSI match pas         : Echec - Expression does not match with the regular expression
UNICODE match pas      : Echec - Expression does not match with the regular expression
ANSI match             : OK
UNICODE match          : OK
ANSI match pas         : Echec - Expression does not match with the regular expression
UNICODE match pas      : Echec - Expression does not match with the regular expression
ANSI match             : OK
UNICODE match          : OK
ANSI match pas         : Echec - Expression does not match with the regular expression
UNICODE match pas      : Echec - Expression does not match with the regular expression