
BoostCommit : 
Subject: [Boostcommit] svn:boost r73104  sandbox/SOC/2011/checks/boost/checks
From: pierre.talbot.6114_at_[hidden]
Date: 20110714 10:42:32
Author: trademark
Date: 20110714 10:42:31 EDT (Thu, 14 Jul 2011)
New Revision: 73104
URL: http://svn.boost.org/trac/boost/changeset/73104
Log:
Move the doxygen documentation to the checks_fwd file.
Improved documentation.
Change the typename (in > <algo_name>_iter
out > <algo_name>_checkdigit )
Text files modified:
sandbox/SOC/2011/checks/boost/checks/checks_fwd.hpp  197 +++++++++++++++++++++++++++++
sandbox/SOC/2011/checks/boost/checks/modulus.hpp  205 +++++++++
2 files changed, 198 insertions(+), 204 deletions()
Modified: sandbox/SOC/2011/checks/boost/checks/checks_fwd.hpp
==============================================================================
 sandbox/SOC/2011/checks/boost/checks/checks_fwd.hpp (original)
+++ sandbox/SOC/2011/checks/boost/checks/checks_fwd.hpp 20110714 10:42:31 EDT (Thu, 14 Jul 2011)
@@ 51,62 +51,167 @@
*/
/*
+#ifndef BOOST_CHECK_CHECKS_FWD_HPP
+#define BOOST_CHECK_CHECKS_FWD_HPP
DELETE THIS AFTER READING!

It is redundant for production of html and pdf output,
but useful to allow just Doxygen manuals (no Quickbook text or indexing).

Standalone Doxygen can provide a more convenient compact index of
the classes, files, namespaces and functions.
They provide the Doxygen comments, but not any text from Quickbook.

These manuals are quickly produced using the Doxywizard GUI frontend.
A suitable doxyfile holding the list of files to include etc
is conveniently placed in a /doc/doxygen subfolder.
Selecting this as the working directory from which doxygen will run as Step 1,
and the run tab, and "run doxygen' in Step 2 should generate
an html with index.html in the /doxygen subfolder.

The mainpage should give a pointer to the full html and/or pdf versions
that provide the full Quickbook generated information.

I:/boostsandbox/tools/quick_auto_dox_index/libs/quick_auto_dox_index/doc/html/index.html
QuickBook Auto Doxygen Indexed Manual

*/
+#ifdef _MSC_VER
+ #pragma once
+#endif // _MSC_VER
namespace boost{
namespace checks{
// Provides forward declaration of all Boost.Checks functions:
 template <typename out, typename in>
 inline out compute_luhn(in &begin, const in &end, unsigned int nbr_digits=0);

 template <typename in>
 inline char compute_luhn(in &begin, const in &end, unsigned int nbr_digits=0);

 template <typename in>
 inline bool check_luhn(in &begin, const in &end, unsigned int nbr_digits=0);
+/** Validate the check digit of the number provided with the Luhn algorithm.
+ * \tparam luhn_iter Iterator with at least the caracteristics of an input iterator. It The beginning or the ending of a sequence of character.
+ * \param[in,out] begin The beginning of the sequence to check.
+ * \param[in] end One off the limit of the sequence to check.
+ * \param[in] nbr_digits 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 The parameters begin and end must be two valid initialized iterators. They represent a sequence of character encoded in bigendian 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 luhn_iter>
+ bool check_luhn(luhn_iter &begin, const luhn_iter &end, unsigned int nbr_digits=0);
+
+/** Calculate the check digit of the number provided with the Luhn algorithm.
+ * \tparam luhn_iter Iterator with at least the caracteristics of an input iterator. It The beginning or the ending of a sequence of character.
+ * \param[in,out] begin The beginning of the sequence to check.
+ * \param[in] end One off the limit of the sequence to check.
+ * \param[in] nbr_digits 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 bigendian 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 luhn_iter>
+ char compute_luhn(luhn_iter &begin, const luhn_iter &end, unsigned int nbr_digits=0);
 template <typename in>
 inline bool check_mod11(in &begin, const in &end, unsigned int nbr_digits=0);
+/** Calculate the check digit of the number provided with the Luhn algorithm.
+ * \tparam luhn_iter Iterator with at least the caracteristics of an input iterator. It The beginning or the ending of a sequence of character.
+ * \tparam luhn_checkdigit Type in which the check digit will be returned.
+ * \param[in,out] begin The beginning of the sequence to check.
+ * \param[in] end One off the limit of the sequence to check.
+ * \param[in] nbr_digits 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 bigendian 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 luhn_checkdigit, typename luhn_iter>
+ luhn_checkdigit compute_luhn(luhn_iter &begin, const luhn_iter &end, unsigned int nbr_digits=0);
+
+/** Validate the check digit of the number provided with the modulus 10 algorithm.
+ * \tparam mod10_iter Iterator with at least the caracteristics of an input iterator. It The beginning or the ending of a sequence of character.
+ * \param[in,out] begin The beginning of the sequence to check.
+ * \param[in] end One off the limit of the sequence to check.
+ * \param[in] weight 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[in] nbr_digits 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 bigendian 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 mod10_iter>
+ bool check_mod10(mod10_iter &begin, const mod10_iter &end, unsigned int weight[], unsigned int nbr_digits=0);
+
+/** Compute the check digit of the number provided with the modulus 10 algorithm.
+ * \tparam mod10_iter with at least the caracteristics of an input iterator. It The beginning or the ending of a sequence of character.
+ * \param[in,out] begin The beginning of the sequence to check.
+ * \param[in] end One off the limit of the sequence to check.
+ * \param[in] weight 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[in] nbr_digits 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 bigendian 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 mod10_iter>
+ char compute_mod10(mod10_iter &begin, const mod10_iter &end, unsigned int weight[], unsigned int nbr_digits=0);
+
+/** Compute the check digit of the number provided with the modulus 10 algorithm.
+ * \tparam mod10_iter Iterator with at least the caracteristics of an input iterator. It The beginning or the ending of a sequence of character.
+ * \tparam mod10_checkdigit Type in which the check digit will be returned.
+ * \param[in,out] begin The beginning of the sequence to check.
+ * \param[in] end One off the limit of the sequence to check.
+ * \param[in] weight 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[in] nbr_digits 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 bigendian 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 mod10_checkdigit, typename mod10_iter>
+ mod10_checkdigit compute_mod10(mod10_iter &begin, const mod10_iter &end, unsigned int weight[], unsigned int nbr_digits=0);
+
+/** Calculate the check digit of the number provided with the modulus 11 algorithm.
+ * \tparam mod11_iter Iterator with at least the caracteristics of an input iterator. It The beginning or the ending of a sequence of character.
+ * \param[in,out] begin The beginning of the sequence to check.
+ * \param[in] end One off the limit of the sequence to check.
+ * \param[in] nbr_digits 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.
+ If the size isn't precised and if the character 'X' or 'x' is encountered, the end of the number will be considered ;
+ if the size is precised, the character 'X' or 'x' will be ignored unless it is the last character.
+ * \pre begin and end are valid initialized iterators. They represent a sequence of character encoded in bigendian 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 mod11_iter>
+ bool check_mod11(mod11_iter &begin, const mod11_iter &end, unsigned int nbr_digits=0);
 template <typename out, typename in>
 inline out compute_mod11(in &begin, const in &end, unsigned int nbr_digits=0);
+/** Validate the check digit of the number provided with the modulus 11 algorithm.
+ * \tparam mod11_iter Iterator with at least the caracteristics of an input iterator. It The beginning or the ending of a sequence of character.
+ * \param[in,out] begin The beginning of the sequence to check.
+ * \param[in] end One off the limit of the sequence to check.
+ * \param[in] nbr_digits 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 bigendian 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 mod11_iter>
+ char compute_mod11(mod11_iter &begin, const mod11_iter &end, unsigned int nbr_digits=0);
+
+/** Validate the check digit of the number provided with the modulus 11 algorithm.
+ * \tparam mod11_iter Iterator with at least the caracteristics of an input iterator. It The beginning or the ending of a sequence of character.
+ * \tparam mod11_checkdigit Type in which the check digit will be returned.
+ * \param[in,out] begin The beginning of the sequence to check.
+ * \param[in] end One off the limit of the sequence to check.
+ * \param[in] nbr_digits 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 bigendian 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 mod11_checkdigit, typename mod11_iter>
+ mod11_checkdigit compute_mod11(mod11_iter &begin, const mod11_iter &end, unsigned int nbr_digits=0);
 template <typename in>
 inline char compute_mod11(in &begin, const in &end, unsigned int nbr_digits=0);
+
 template <typename in>
 inline bool check_mod10(in &begin, const in &end, unsigned int weight[], unsigned int nbr_digits=0);
 template <typename in>
 inline char compute_mod10(in &begin, const in &end, unsigned int weight[], unsigned int nbr_digits=0);

 template <typename out, typename in>
 inline out compute_mod10(in &begin, const in &end, unsigned int weight[], unsigned int nbr_digits=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 */
+
+/** Compute the check digit of the number provided with the modulus 97 algorithm.
+ * \tparam mod97_iter Iterator with at least the caracteristics of an input iterator. It represents the beginning or the ending of a sequence of character.
+ * \param[in,out] begin The beginning of the sequence to check.
+ * \param[in] end One off the limit of the sequence to check.
+ * \param[in] nbr_digits 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 bigendian 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 characters of the check digits are returned.
+ */
+
+ template <typename mod97_iter>
+ char compute_mod97(mod97_iter &begin, const mod97_iter &end, unsigned int nbr_digits=0);
+
+/** Validate the check digit of the number provided with the modulus 97 algorithm.
+ * \tparam mod97_iter Iterator with at least the caracteristics of an input iterator. It represents the beginning or the ending of a sequence of character.
+ * \param[in,out] begin The beginning of the sequence to check.
+ * \param[in] end One off the limit of the sequence to check.
+ * \param[in] nbr_digits 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 bigendian 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.
+ * \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 mod97_iter>
+ bool check_mod97(mod97_iter &begin, const mod97_iter &end, unsigned int nbr_digits=0);
+
}
}
\ No newline at end of file
+}
+
+#endif \\ BOOST_CHECK_CHECKS_FWD_HPP
\ No newline at end of file
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 20110714 10:42:31 EDT (Thu, 14 Jul 2011)
@@ 5,29 +5,23 @@
// http://www.boost.org/LICENSE_1_0.txt
// See http://www.boost.org for updates, documentation, and revision history.
#ifndef BOOST_CHECK_MOD_INCLUDED
#define BOOST_CHECK_MOD_INCLUDED
+#ifndef BOOST_CHECK_MODULUS_HPP
+#define BOOST_CHECK_MODULUS_HPP
+
+#ifdef _MSC_VER
+ #pragma once
+#endif // _MSC_VER
namespace boost {
namespace checks{
/** Validate the check digit of the number provided with the Luhn 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.
 * \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] 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 bigendian 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_luhn(in &begin, const in &end, unsigned int nbr_digits)
+template <typename luhn_iter>
+bool check_luhn(luhn_iter &begin, const luhn_iter &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;
+ luhn_iter iter = begin;
while(iter != end)
{
if(*iter >= '0' && *iter <= '9')
@@ 56,23 +50,13 @@
return !nbr_digits && !(sum % 10) ;
}
/** Calculate the check digit of the number provided with the Luhn 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.
 * \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] 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 bigendian 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 out, typename in>
inline out compute_luhn(in &begin, const in &end, unsigned int nbr_digits)
+template <typename luhn_iter>
+char compute_luhn(luhn_iter &begin, const luhn_iter &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;
+ luhn_iter iter = begin;
while(iter != end)
{
if(*iter >= '0' && *iter <= '9')
@@ 88,7 +72,7 @@
}
int sum = 0,v;
/* We start with the leftmost digit and we multiply by two
 * if the total number of digit is even. We alternate the multiplication
+ * if the total number of digit is odd. We alternate the multiplication
* for all the digits. We subtract 9 from the digit greater than 9
* after the multiplication. */
while(nbr_digits > 0 && begin != end)
@@ 97,16 +81,16 @@
sum += (v= (*begin & 15) << (nbr_digits&1))  9 * (v>9);
++begin;
}
 return ((10  sum % 10) % 10)  '0';
+ return (10  sum % 10) % 10  '0';
}
template <typename in>
inline char compute_luhn(in &begin, const in &end, unsigned int nbr_digits)
+template <typename out, typename luhn_iter>
+out compute_luhn(luhn_iter &begin, const luhn_iter &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;
+ luhn_iter iter = begin;
while(iter != end)
{
if(*iter >= '0' && *iter <= '9')
@@ 122,7 +106,7 @@
}
int sum = 0,v;
/* We start with the leftmost digit and we multiply by two
 * if the total number of digit is odd. We alternate the multiplication
+ * if the total number of digit is even. We alternate the multiplication
* for all the digits. We subtract 9 from the digit greater than 9
* after the multiplication. */
while(nbr_digits > 0 && begin != end)
@@ 131,24 +115,11 @@
sum += (v= (*begin & 15) << (nbr_digits&1))  9 * (v>9);
++begin;
}
 return (10  sum % 10) % 10  '0';
+ 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 bigendian 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)
+template <typename mod10_iter>
+bool check_mod10(mod10_iter &begin, const mod10_iter &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)
@@ 159,7 +130,7 @@
// If the number of digits isn't given (equal to 0), we count these.
if(!nbr_digits)
{
 in iter = begin;
+ mod10_iter iter = begin;
while(iter != end)
{
if(*iter >= '0' && *iter <= '9')
@@ 187,21 +158,8 @@
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 bigendian 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)
+template <typename mod10_iter>
+char compute_mod10(mod10_iter &begin, const mod10_iter &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)
@@ 212,7 +170,7 @@
// If the number of digits isn't given (equal to 0), we count these.
if(!nbr_digits)
{
 in iter = begin;
+ mod10_iter iter = begin;
while(iter != end)
{
if(*iter >= '0' && *iter <= '9')
@@ 244,21 +202,8 @@
return (10  sum % 10) % 10  '0' ;
}
/** 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 bigendian 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 out, typename in>
inline out compute_mod10(in &begin, const in &end, unsigned int weight[], unsigned int nbr_digits)
+template <typename out, typename mod10_iter>
+out compute_mod10(mod10_iter &begin, const mod10_iter &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)
@@ 269,7 +214,7 @@
// If the number of digits isn't given (equal to 0), we count these.
if(!nbr_digits)
{
 in iter = begin;
+ mod10_iter iter = begin;
while(iter != end)
{
if(*iter >= '0' && *iter <= '9')
@@ 301,20 +246,10 @@
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.
 * \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] 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 bigendian 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 bool check_mod11(in &begin, const in &end, unsigned int nbr_digits)
+template <typename mod11_iter>
+bool check_mod11(mod11_iter &begin, const mod11_iter &end, unsigned int nbr_digits)
{
 in iter = begin;
+ mod11_iter iter = begin;
// If the number of digits isn't given (equal to 0), we count these.
if(!nbr_digits)
{
@@ 367,20 +302,11 @@
// Return true if the number of digit is equal to the number specified and the sum is valid.
return !nbr_digits && !(sum % 11);
}
/** 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 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] 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 bigendian 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 out, typename in>
inline out compute_mod11(in &begin, const in &end, unsigned int nbr_digits)
+
+template <typename mod11_iter>
+char compute_mod11(mod11_iter &begin, const mod11_iter &end, unsigned int nbr_digits)
{
 in iter = begin;
+ mod11_iter iter = begin;
// If the number of digits isn't given (equal to 0), we count these.
if(!nbr_digits)
{
@@ 412,26 +338,16 @@
return 0;
// Compute the check digit.
 int check_digit = (11  sum % 11) %11;
+ char check_digit = (11  sum % 11) %11;
if(check_digit == 10)
return 'X';
 return check_digit + '0';
+ return check_digit  '0';
}
/** 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 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] 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 bigendian 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 char compute_mod11(in &begin, const in &end, unsigned int nbr_digits)
+template <typename out, typename mod11_iter>
+out compute_mod11(mod11_iter &begin, const mod11_iter &end, unsigned int nbr_digits)
{
 in iter = begin;
+ mod11_iter iter = begin;
// If the number of digits isn't given (equal to 0), we count these.
if(!nbr_digits)
{
@@ 463,47 +379,20 @@
return 0;
// Compute the check digit.
 char check_digit = (11  sum % 11) %11;
+ int check_digit = (11  sum % 11) %11;
if(check_digit == 10)
return 'X';
 return check_digit + '0';
+ 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 */

/** Validate the check digit of the number provided with the modulus 97 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.
 * \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] 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 bigendian 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.
 * \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 mod97_iter>
+bool check_mod97(mod97_iter &begin, const mod97_iter &end, unsigned int nbr_digits)
{
return false;
}
/** Compute the check digit of the number provided with the modulus 97 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.
 * \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] 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 bigendian 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 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 mod97_iter>
+char compute_mod97(mod97_iter &begin, const mod97_iter &end, unsigned int nbr_digits)
{
return false;
}
@@ 511,5 +400,5 @@
} // namespace checks
} // namespace boost
#endif // #define BOOST_CHECK_MOD_INCLUDED
+#endif // BOOST_CHECK_MODULUS_HPP
BoostCommit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk