[Boost-commit] svn:boost r73020 - sandbox/SOC/2011/checks/boost/checks

Subject: [Boost-commit] svn:boost r73020 - sandbox/SOC/2011/checks/boost/checks
From: pierre.talbot.6114_at_[hidden]
Date: 2011-07-12 12:38:54

Author: trademark
Date: 2011-07-12 12:38:53 EDT (Tue, 12 Jul 2011)
New Revision: 73020
URL: http://svn.boost.org/trac/boost/changeset/73020

Log:
Update of the syntax (typename In > in , Out > out)
Update of the functions mod11
Add prototype of mod97 functions
Text files modified: 
   sandbox/SOC/2011/checks/boost/checks/modulus.hpp |   268 ++++++++++++++++++++++++--------------- 
   1 files changed, 162 insertions(+), 106 deletions(-)

Modified: sandbox/SOC/2011/checks/boost/checks/modulus.hpp
==============================================================================
--- sandbox/SOC/2011/checks/boost/checks/modulus.hpp	(original)
+++ sandbox/SOC/2011/checks/boost/checks/modulus.hpp	2011-07-12 12:38:53 EDT (Tue, 12 Jul 2011)
@@ -19,15 +19,15 @@
  * \param [unsigned int] nbr_digits Represents the number of digits on which the Luhn algorithm will operate. If the size is < 1, the luhn algorithm will validate the check digit with all the digit encountered.
  * \pre begin and end are valid initialized iterators. They represent a sequence of character encoded in big-endian mode in a format compatible with the 7 bits ASCII.
  * \post begin is equal to the position of the check digit plus one if the expression provided is correct, otherwise is equal to end.
- * \result true is returned if the expression given have a valid check digit and have nbr_digits (or more than 0 digit if nbr_digits is equal to 0).
+ * \returns true is returned if the expression given have a valid check digit and have nbr_digits (or more than 0 digit if nbr_digits is equal to 0).
  */
-template <typename In>
-inline bool check_luhn(In &begin, const In &end, unsigned int nbr_digits)
+template <typename in>
+inline bool check_luhn(in &begin, const in &end, unsigned int nbr_digits)
 {
   // If the number of digits isn't given (equal to 0), we count these.
   if(!nbr_digits)
   {
-	In iter = begin;
+	in iter = begin;
         while(iter != end)
         {
       if(*iter >= '0' && *iter <= '9')
@@ -64,15 +64,15 @@
  * \param [unsigned int] nbr_digits Represents the number of digits on which the Luhn algorithm will operate. If the size is < 1, the luhn algorithm will calculate the check digit with all the digit encountered.
  * \pre begin and end are valid initialized iterators. They represent a sequence of character encoded in big-endian mode in a format compatible with the 7 bits ASCII.
  * \post begin is equal to the position of the last digit encountered plus one if the expression provided is correct, otherwise is equal to end.
- * \result 0 is returned if the expression given have not nbr_digits (or no digit if nbr_digits is equal to 0). Otherwise the ASCII character of the check digit is returned.
+ * \returns 0 is returned if the expression given have not nbr_digits (or no digit if nbr_digits is equal to 0). Otherwise the ASCII character of the check digit is returned.
  */
-template <typename Out, typename In>
-inline Out compute_luhn(In &begin, const In &end, unsigned int nbr_digits)
+template <typename out, typename in>
+inline out compute_luhn(in &begin, const in &end, unsigned int nbr_digits)
 {
   // If the number of digits isn't given (equal to 0), we count these.
   if(!nbr_digits)
   {
-	In iter = begin;
+	in iter = begin;
         while(iter != end)
         {
       if(*iter >= '0' && *iter <= '9')
@@ -100,13 +100,13 @@
   return ((10 - sum % 10) % 10) | '0';
 }
 
-template <typename In>
-inline char compute_luhn(In &begin, const In &end, unsigned int nbr_digits)
+template <typename in>
+inline char compute_luhn(in &begin, const in &end, unsigned int nbr_digits)
 {
   // If the number of digits isn't given (equal to 0), we count these.
   if(!nbr_digits)
   {
-	In iter = begin;
+	in iter = begin;
         while(iter != end)
         {
       if(*iter >= '0' && *iter <= '9')
@@ -133,6 +133,118 @@
   }
   return (10 - sum % 10) % 10 | '0';
 }
+
+/** Validate the check digit of the number provided with the modulus 10 algorithm.
+ * \tparam Iterator with at least the caracteristics of an input iterator. It represents the beginning or the ending of a sequence of character. 
+ * \tparam unsigned int[] which represents an array of weight.
+ * \tparam unsigned int which represents a size.
+ * \param [in] begin Represents the beginning of the sequence to check.
+ * \param [in] end Represents one off the limit of the sequence to check.
+ * \param [unsigned int\[\]] weight Represents the weight pattern of the sequence starting on the left of the expression. If weight is null, the algorithm will apply a weight of 1 on the sequence.
+ * \param [unsigned int] nbr_digits Represents the number of digits on which the modulus 10 algorithm will operate. If the size is < 1, the modulus 10 algorithm will validate the check digit with all the digit encountered.
+ * \pre begin and end are valid initialized iterators. They represent a sequence of character encoded in big-endian mode in a format compatible with the 7 bits ASCII.
+ * \post begin is equal to the position of the check digit plus one if the expression provided is correct, otherwise is equal to end. 
+ * \returns true is returned if the expression given have a valid check digit and have nbr_digits (or more than 0 digit if nbr_digits is equal to 0).
+ */
+
+template <typename in>
+inline bool check_mod10(in &begin, const in &end, unsigned int weight[], unsigned int nbr_digits)
+{
+  // If the weight is null or have a size of zero, we apply a weight of 1 on each digit.
+  if(weight == NULL)
+  {
+    unsigned int weight_tmp[] = {1};
+    weight = weight_tmp;
+  }
+  // If the number of digits isn't given (equal to 0), we count these.
+  if(!nbr_digits)
+  {
+	in iter = begin;
+	while(iter != end)
+	{
+      if(*iter >= '0' && *iter <= '9')
+        ++nbr_digits;
+	  ++iter;
+	}
+	// Return false if there is no digit in the expression given.
+	if(!nbr_digits)
+	{
+	  begin = end;
+	  return false;
+	}
+  }
+  int sum = 0;
+  int weight_size = sizeof(weight) / sizeof(weight[0]) ;
+  /* We start with the leftmost digit and we multiply by the weight indicated.
+   * The sum of all digits is computed. */
+  for(int i=0; nbr_digits > 0 && begin != end; ++i, --nbr_digits)
+  {
+    if(*begin >= '0' && *begin <= '9')
+		sum += (*begin & 15) * weight[i % weight_size] ;
+	++begin;
+  }
+  // Return true if the number of digit is equal to the number specified and the sum is valid.
+  return !nbr_digits && !(sum % 10) ;
+}
+
+/** Compute the check digit of the number provided with the modulus 10 algorithm.
+ * \tparam Iterator with at least the caracteristics of an input iterator. It represents the beginning or the ending of a sequence of character. 
+ * \tparam unsigned int[] which represents an array of weight.
+ * \tparam unsigned int which represents a size.
+ * \param [in] begin Represents the beginning of the sequence to check.
+ * \param [in] end Represents one off the limit of the sequence to check.
+ * \param [unsigned int\[\]] weight Represents the weight pattern of the sequence starting on the left of the expression. If weight is null, the algorithm will apply a weight of 1 on the sequence.
+ * \param [unsigned int] nbr_digits Represents the number of digits on which the modulus 10 algorithm will operate. If the size is < 1, the modulus 10 algorithm will calculate the check digit with all the digit encountered.
+ * \pre begin and end are valid initialized iterators. They represent a sequence of character encoded in big-endian mode in a format compatible with the 7 bits ASCII.
+ * \post begin is equal to the position of the last digit encountered plus one if the expression provided is correct, otherwise is equal to end.
+ * \returns 0 is returned if the expression given have not nbr_digits (or no digit if nbr_digits is equal to 0). Otherwise the ASCII character of the check digit is returned.
+ */
+
+template <typename in>
+inline char compute_mod10(in &begin, const in &end, unsigned int weight[], unsigned int nbr_digits)
+{
+  // If the weight is null we apply a weight of 1 on each digit.
+  if(weight == NULL)
+  {
+    unsigned int weight_tmp[] = {1};
+    weight = weight_tmp;
+  }
+  // If the number of digits isn't given (equal to 0), we count these.
+  if(!nbr_digits)
+  {
+	in iter = begin;
+	while(iter != end)
+	{
+      if(*iter >= '0' && *iter <= '9')
+        ++nbr_digits;
+	  ++iter;
+	}
+	// Return false if there is no digit in the expression given.
+	if(!nbr_digits)
+	{
+	  begin = end;
+	  return 0;
+	}
+  }
+  int sum = 0;
+  int weight_size = sizeof(weight) / sizeof(weight[0]) ;
+  /* We start with the leftmost digit and we multiply by the weight indicated.
+   * The sum of all digits is computed. */
+  for(int i=0; nbr_digits > 0 && begin != end; ++i, --nbr_digits)
+  {
+    if(*begin >= '0' && *begin <= '9')
+		sum += (*begin & 15) * weight[i % weight_size] ;
+	++begin;
+  }
+  if(nbr_digits > 0)
+  {
+    begin = end;
+    return 0;
+  }
+  return (10 - sum % 10) % 10 | '0' ;
+}
+
+
 /** Calculate the check digit of the number provided with the modulus 11 algorithm.
  * \tparam Iterator with at least the caracteristics of an input iterator. It represents the beginning or the ending of a sequence of character. 
  * \tparam unsigned int which represents a size.
@@ -141,15 +253,15 @@
  * \param [unsigned int] nbr_digits Represents the number of digits on which the MOD11 algorithm will operate. If the size is < 1, the MOD11 algorithm will calculate the check digit with all the digit encountered.
  * \pre begin and end are valid initialized iterators. They represent a sequence of character encoded in big-endian mode in a format compatible with the 7 bits ASCII.
  * \post begin is equal to the position of the last digit encountered plus one if the expression provided is correct, otherwise is equal to end.
- * \result 0 is returned if the expression given have not nbr_digits (or no digit if nbr_digits is equal to 0). Otherwise the ASCII character of the check digit is returned.
+ * \returns 0 is returned if the expression given have not nbr_digits (or no digit if nbr_digits is equal to 0). Otherwise the ASCII character of the check digit is returned.
 */
-template <typename In>
-inline bool check_mod11(In &begin, const In &end, unsigned int nbr_digits)
+template <typename in>
+inline bool check_mod11(in &begin, const in &end, unsigned int nbr_digits)
 {
+  in iter = begin;
   // If the number of digits isn't given (equal to 0), we count these.
   if(!nbr_digits)
   {
-	In iter = begin;
         while(iter != end)
         {
       if(*iter >= '0' && *iter <= '9')
@@ -162,6 +274,7 @@
           begin = end;
           return false;
         }
+    iter = begin;
   }
   int sum = 0;
   // Sum the n-1 first digit with a weigth of n. (The weigth is the contribution
@@ -201,15 +314,15 @@
  * \param [unsigned int] nbr_digits Represents the number of digits on which the Luhn algorithm will operate. If the size is < 1, the luhn algorithm will validate the check digit with all the digit encountered.
  * \pre begin and end are valid initialized iterators. They represent a sequence of character encoded in big-endian mode in a format compatible with the 7 bits ASCII.
  * \post begin is equal to the position of the check digit plus one if the expression provided is correct, otherwise is equal to end.
- * \result true is returned if the expression given have a valid check digit and have nbr_digits (or more than 0 digit if nbr_digits is equal to 0).
+ * \returns true is returned if the expression given have a valid check digit and have nbr_digits (or more than 0 digit if nbr_digits is equal to 0).
  */
-template <typename Out, typename In>
-inline Out compute_mod11(In &begin, const In &end, unsigned int nbr_digits)
+template <typename out, typename in>
+inline out compute_mod11(in &begin, const in &end, unsigned int nbr_digits)
 {
+  in iter = begin;
   // If the number of digits isn't given (equal to 0), we count these.
   if(!nbr_digits)
   {
-	In iter = begin;
         while(iter != end)
         {
       if(*iter >= '0' && *iter <= '9')
@@ -222,6 +335,7 @@
           begin = end;
           return 0;
         }
+    iter = begin;
   }
   int sum = 0;
   // Sum the digits with a weigth of nbr_digits. (The weigth is the contribution
@@ -240,119 +354,61 @@
   int check_digit = (11 - sum % 11) %11;
   if(check_digit == 10)
     return 'X';
-  return check_digit;
+  return check_digit + '0';
 }
 
-/** Validate the check digit of the number provided with the modulus 10 algorithm.
- * \tparam Iterator with at least the caracteristics of an input iterator. It represents the beginning or the ending of a sequence of character. 
- * \tparam unsigned int[] which represents an array of weight.
- * \tparam unsigned int which represents a size.
- * \param [in] begin Represents the beginning of the sequence to check.
- * \param [in] end Represents one off the limit of the sequence to check.
- * \param [unsigned int\[\]] weight Represents the weight pattern of the sequence starting on the left of the expression. If weight is null, the algorithm will apply a weight of 1 on the sequence.
- * \param [unsigned int] nbr_digits Represents the number of digits on which the modulus 10 algorithm will operate. If the size is < 1, the modulus 10 algorithm will validate the check digit with all the digit encountered.
- * \pre begin and end are valid initialized iterators. They represent a sequence of character encoded in big-endian mode in a format compatible with the 7 bits ASCII.
- * \post begin is equal to the position of the check digit plus one if the expression provided is correct, otherwise is equal to end. 
- * \result true is returned if the expression given have a valid check digit and have nbr_digits (or more than 0 digit if nbr_digits is equal to 0).
- */
-
-template <typename In>
-inline bool check_mod10(In &begin, const In &end, unsigned int weight[], unsigned int nbr_digits)
-{
-  // If the weight is null or have a size of zero, we apply a weight of 1 on each digit.
-  if(weight == NULL)
-  {
-    unsigned int weight_tmp[] = {1};
-    weight = weight_tmp;
-  }
-  int weight_size = sizeof(weight) / sizeof(weight[0]);
-  // If the number of digits isn't given (equal to 0), we count these.
-  if(!nbr_digits)
-  {
-	In iter = begin;
-	while(iter != end)
-	{
-      if(*iter >= '0' && *iter <= '9')
-        ++nbr_digits;
-	  ++iter;
-	}
-	// Return false if there is no digit in the expression given.
-	if(!nbr_digits)
-	{
-	  begin = end;
-	  return false;
-	}
-  }
-  int sum = 0;
-  /* We start with the leftmost digit and we multiply by the weight indicated.
-   * The sum of all digits is computed. */
-  for(int i=0; nbr_digits > 0 && begin != end; ++i)
-  {
-    if(*begin >= '0' && *begin <= '9')
-		sum += (*begin & 15) * weight[i % weight_size] ;
-	++begin;
-  }
-  // Return true if the number of digit is equal to the number specified and the sum is valid.
-  return !nbr_digits && !(sum % 10) ;
-}
-
-/** Compute the check digit of the number provided with the modulus 10 algorithm.
+/** Validate the check digit of the number provided with the modulus 11 algorithm.
  * \tparam Iterator with at least the caracteristics of an input iterator. It represents the beginning or the ending of a sequence of character. 
- * \tparam unsigned int[] which represents an array of weight.
  * \tparam unsigned int which represents a size.
  * \param [in] begin Represents the beginning of the sequence to check.
  * \param [in] end Represents one off the limit of the sequence to check.
- * \param [unsigned int\[\]] weight Represents the weight pattern of the sequence starting on the left of the expression. If weight is null, the algorithm will apply a weight of 1 on the sequence.
- * \param [unsigned int] nbr_digits Represents the number of digits on which the modulus 10 algorithm will operate. If the size is < 1, the modulus 10 algorithm will calculate the check digit with all the digit encountered.
+ * \param [unsigned int] nbr_digits Represents the number of digits on which the Luhn algorithm will operate. If the size is < 1, the luhn algorithm will validate the check digit with all the digit encountered.
  * \pre begin and end are valid initialized iterators. They represent a sequence of character encoded in big-endian mode in a format compatible with the 7 bits ASCII.
- * \post begin is equal to the position of the last digit encountered plus one if the expression provided is correct, otherwise is equal to end.
- * \result 0 is returned if the expression given have not nbr_digits (or no digit if nbr_digits is equal to 0). Otherwise the ASCII character of the check digit is returned.
+ * \post begin is equal to the position of the check digit plus one if the expression provided is correct, otherwise is equal to end.
+ * \returns true is returned if the expression given have a valid check digit and have nbr_digits (or more than 0 digit if nbr_digits is equal to 0).
  */
-
-template <typename In>
-inline char compute_mod10(In &begin, const In &end, unsigned int weight[], unsigned int nbr_digits)
+template <typename in>
+inline char compute_mod11(in &begin, const in &end, unsigned int nbr_digits)
 {
-  // If the weight is null we apply a weight of 1 on each digit.
-  if(weight == NULL)
-  {
-    unsigned int weight_tmp[] = {1};
-    weight = weight_tmp;
-  }
-  int weight_size = sizeof(weight) / sizeof(weight[0]);
+  in iter = begin;
   // If the number of digits isn't given (equal to 0), we count these.
   if(!nbr_digits)
   {
-	In iter = begin;
         while(iter != end)
         {
       if(*iter >= '0' && *iter <= '9')
         ++nbr_digits;
           ++iter;
         }
-	// Return false if there is no digit in the expression given.
+	// Return 0 if there is no digit in the expression given.
         if(!nbr_digits)
         {
           begin = end;
           return 0;
         }
+    iter = begin;
   }
   int sum = 0;
-  /* We start with the leftmost digit and we multiply by the weight indicated.
-   * The sum of all digits is computed. */
-  for(int i=0; nbr_digits > 0 && begin != end; ++i)
+  // Sum the digits with a weigth of nbr_digits. (The weigth is the contribution
+  // of a digit to the final sum).
+  ++nbr_digits; // Adding the unknown check digit to the size...
+  while(nbr_digits > 1 && iter != end)
   {
     if(*begin >= '0' && *begin <= '9')
-		sum += (*begin & 15) * weight[i % weight_size] ;
+	  sum += *begin & 15 * nbr_digits-- ;
         ++begin;
   }
-  if(nbr_digits > 0)
-  {
-    begin = end;
+  if(nbr_digits > 1)
     return 0;
-  }
-  return (10 - sum % 10) % 10 | '0' ;
+  
+  // Compute the check digit.
+  char check_digit = (11 - sum % 11) %11;
+  if(check_digit == 10)
+    return 'X';
+  return check_digit + '0';
 }
 
+
 /*!!!
 The modulus 97 algorithm wait for a sequence of numbers only ! and will not do anything else that sum the digits and calculate the modulus of this sum.
 If you need to check an IBAN use the algorithms in iban.hpp */
@@ -365,11 +421,11 @@
  * \param [unsigned int] nbr_digits Represents the number of digits on which the modulus 97 algorithm will operate. If the size is < 1, the modulus 97 algorithm will validate the check digit with all the digit encountered.
  * \pre begin and end are valid initialized iterators. They represent a sequence of character encoded in big-endian mode in a format compatible with the 7 bits ASCII.
  * \post begin is equal to the position of the check digits plus one if the expression provided is correct, otherwise is equal to end. 
- * \result true is returned if the expression given have a valid check digit and have nbr_digits (or more than 0 digit if nbr_digits is equal to 0).
+ * \returns true is returned if the expression given have a valid check digit and have nbr_digits (or more than 0 digit if nbr_digits is equal to 0).
  */
 
-template <typename In>
-inline bool check_mod97(In &begin, const In &end, unsigned int nbr_digit)
+template <typename in>
+inline bool check_mod97(in &begin, const in &end, unsigned int nbr_digit)
 {
   return false;
 }
@@ -382,11 +438,11 @@
  * \param [unsigned int] nbr_digits Represents the number of digits on which the modulus 97 algorithm will operate. If the size is < 1, the modulus 97 algorithm will calculate the check digit with all the digit encountered.
  * \pre begin and end are valid initialized iterators. They represent a sequence of character encoded in big-endian mode in a format compatible with the 7 bits ASCII.
  * \post begin is equal to the position of the last digit encountered plus one if the expression provided is correct, otherwise is equal to end.
- * \result 0 is returned if the expression given have not nbr_digits (or no digit if nbr_digits is equal to 0). Otherwise the ASCII characters of the check digits are returned.
+ * \returns 0 is returned if the expression given have not nbr_digits (or no digit if nbr_digits is equal to 0). Otherwise the ASCII characters of the check digits are returned.
  */
 
-template <typename In>
-inline char compute_mod97(In &begin, const In &end, unsigned int nbr_digit)
+template <typename in>
+inline char compute_mod97(in &begin, const in &end, unsigned int nbr_digit)
 {
   return false;
 }