Subject: [Boost-commit] svn:boost r77120 - sandbox/SOC/2011/checks/boost/checks
From: pierre.talbot.6114_at_[hidden]
Date: 2012-02-26 14:13:20
Author: trademark
Date: 2012-02-26 14:13:18 EST (Sun, 26 Feb 2012)
New Revision: 77120
URL: http://svn.boost.org/trac/boost/changeset/77120
Log:
Make a stand alone processor.
Text files modified:
sandbox/SOC/2011/checks/boost/checks/amex.hpp | 11 ++++
sandbox/SOC/2011/checks/boost/checks/basic_check_algorithm.hpp | 23 ----------
sandbox/SOC/2011/checks/boost/checks/basic_checks.hpp | 53 ++++++++++++++++--------
sandbox/SOC/2011/checks/boost/checks/ean.hpp | 27 ++++++++++--
sandbox/SOC/2011/checks/boost/checks/isbn.hpp | 11 ----
sandbox/SOC/2011/checks/boost/checks/luhn.hpp | 66 ++++++++++++++++---------------
sandbox/SOC/2011/checks/boost/checks/mastercard.hpp | 11 ++++
sandbox/SOC/2011/checks/boost/checks/modulus10.hpp | 3
sandbox/SOC/2011/checks/boost/checks/modulus11.hpp | 30 ++++++++++---
sandbox/SOC/2011/checks/boost/checks/modulus97.hpp | 45 +++++++++++++++++---
sandbox/SOC/2011/checks/boost/checks/upc.hpp | 16 ++++++-
sandbox/SOC/2011/checks/boost/checks/verhoeff.hpp | 84 +++++++++++++++++++++------------------
sandbox/SOC/2011/checks/boost/checks/visa.hpp | 11 ++++
sandbox/SOC/2011/checks/boost/checks/weighted_sum.hpp | 21 +++------
14 files changed, 244 insertions(+), 168 deletions(-)
Modified: sandbox/SOC/2011/checks/boost/checks/amex.hpp
==============================================================================
--- sandbox/SOC/2011/checks/boost/checks/amex.hpp (original)
+++ sandbox/SOC/2011/checks/boost/checks/amex.hpp 2012-02-26 14:13:18 EST (Sun, 26 Feb 2012)
@@ -51,7 +51,10 @@
template <typename check_range>
bool check_amex (const check_range& check_seq)
{
- return boost::checks::check_sequence<luhn_algorithm, digit_prechecksum, AMEX_SIZE>(boost::rbegin(check_seq), boost::rend(check_seq));
+ return boost::checks::check_sequence<luhn_algorithm,
+ luhn_processor,
+ digit_prechecksum,
+ AMEX_SIZE>(boost::rbegin(check_seq), boost::rend(check_seq));
}
/*!
@@ -71,7 +74,11 @@
template <typename check_range>
std::size_t compute_amex(const check_range& check_seq)
{
- return boost::checks::compute_checkdigit<luhn_algorithm, digit_prechecksum, AMEX_SIZE, basic_checkdigit>(boost::rbegin(check_seq), boost::rend(check_seq));
+ return boost::checks::compute_checkdigit<luhn_algorithm,
+ luhn_processor,
+ digit_prechecksum,
+ AMEX_SIZE,
+ basic_checkdigit>(boost::rbegin(check_seq), boost::rend(check_seq));
}
Modified: sandbox/SOC/2011/checks/boost/checks/basic_check_algorithm.hpp
==============================================================================
--- sandbox/SOC/2011/checks/boost/checks/basic_check_algorithm.hpp (original)
+++ sandbox/SOC/2011/checks/boost/checks/basic_check_algorithm.hpp 2012-02-26 14:13:18 EST (Sun, 26 Feb 2012)
@@ -88,29 +88,6 @@
{
return std::pair<std::size_t, std::size_t>();
}
-
- /*!
- \brief Compute an operation on the checksum with the current valid value.
- \post Do nothing. The checksum is unchanged.
-
- \param current_valid_value is the current valid value analysed.
- \param valid_value_counter is the number of valid value(s) already counted (the current value is not included).\n This is also the position (above the valid values) of the current value analysed (0 <= valid_value_counter < n).
- \param checksum is the current checksum.
-
- \remarks This function should be overloaded if you want to calculate the checksum of a sequence.
- */
- template <typename Function>
- struct processor
- {
- Function counter;
- processor(Function counter) : counter(counter) { }
-
- std::size_t operator()(std::size_t checksum, std::size_t value)
- {
- return std::size_t();
- }
- };
-
};
Modified: sandbox/SOC/2011/checks/boost/checks/basic_checks.hpp
==============================================================================
--- sandbox/SOC/2011/checks/boost/checks/basic_checks.hpp (original)
+++ sandbox/SOC/2011/checks/boost/checks/basic_checks.hpp 2012-02-26 14:13:18 EST (Sun, 26 Feb 2012)
@@ -57,14 +57,15 @@
}
};
-template <typename algorithm,
+template <typename algorithm,
+ template <class> class processor,
std::size_t size_expected,
typename seq_iterator,
typename counter_iter>
std::size_t compute_checksum(seq_iterator seq_begin, seq_iterator seq_end, counter_iter &counter)
{
- typedef typename algorithm::template processor<deref<counter_iter> > processor;
- processor process = processor(deref<counter_iter>(counter));
+ typedef typename processor<deref<counter_iter> > counter_processor;
+ counter_processor process = counter_processor(deref<counter_iter>(counter));
std::size_t checksum = 0;
for(; seq_begin != seq_end && *counter < size_expected; ++seq_begin, ++counter)
@@ -76,12 +77,13 @@
}
template <typename algorithm,
+ template <class> class processor,
typename seq_iterator,
typename counter_iter>
std::size_t compute_checksum(seq_iterator seq_begin, seq_iterator seq_end, counter_iter &counter)
{
- typedef typename algorithm::template processor<deref<counter_iter> > processor;
- processor process = processor(deref<counter_iter>(counter));
+ typedef typename processor<deref<counter_iter> > counter_processor;
+ counter_processor process = counter_processor(deref<counter_iter>(counter));
std::size_t checksum = 0;
for(; seq_begin != seq_end; ++seq_begin, ++counter)
@@ -103,6 +105,7 @@
\returns @c true if the checkdigit is correct, @c false otherwise.
*/
template <typename algorithm,
+ template <class> class processor,
typename prechecksum_type,
typename seq_iterator>
bool check_sequence(seq_iterator seq_begin, seq_iterator seq_end)
@@ -110,7 +113,8 @@
boost::checks::detail::simple_counter::type counter = boost::checks::detail::simple_counter()();
prechecksum_type prechecksum;
- std::size_t checksum = compute_checksum<algorithm>(prechecksum(seq_begin, seq_end),
+ std::size_t checksum = compute_checksum<algorithm,
+ processor>(prechecksum(seq_begin, seq_end),
prechecksum(seq_end, seq_end),
counter);
return algorithm::validate_checksum(checksum);
@@ -131,6 +135,7 @@
\returns @c true if the checkdigit is correct, @c false otherwise.
*/
template <typename algorithm,
+ template <class> class processor,
typename prechecksum_type,
std::size_t size_expected,
typename seq_iterator>
@@ -139,9 +144,11 @@
boost::checks::detail::simple_counter::type counter = boost::checks::detail::simple_counter()();
prechecksum_type prechecksum;
- std::size_t checksum = compute_checksum<algorithm, size_expected>(prechecksum(seq_begin, seq_end),
- prechecksum(seq_end, seq_end),
- counter);
+ std::size_t checksum = compute_checksum<algorithm,
+ processor,
+ size_expected>(prechecksum(seq_begin, seq_end),
+ prechecksum(seq_end, seq_end),
+ counter);
if(checksum != bad_sequence)
return algorithm::validate_checksum(checksum);
return false;
@@ -161,6 +168,7 @@
\returns The check digit of the type of a value in check_seq.
*/
template <typename algorithm,
+ template <class> class processor,
typename prechecksum_type,
typename checkdigit,
typename seq_iterator>
@@ -169,7 +177,8 @@
typedef typename boost::checks::detail::skip_counter<checkdigit::pos, checkdigit::size> counter_type;
typename counter_type::type counter = counter_type()();
prechecksum_type prechecksum;
- std::size_t checksum = compute_checksum<algorithm>(prechecksum(seq_begin, seq_end),
+ std::size_t checksum = compute_checksum<algorithm,
+ processor>(prechecksum(seq_begin, seq_end),
prechecksum(seq_end, seq_end),
counter);
return algorithm::compute_checkdigit(checksum);
@@ -190,6 +199,7 @@
\returns The check digit of the type of a value in check_seq.
*/
template <typename algorithm,
+ template <class> class processor,
typename prechecksum_type,
std::size_t size_expected,
typename checkdigit,
@@ -199,10 +209,12 @@
typedef typename boost::checks::detail::skip_counter<checkdigit::pos, checkdigit::size> counter_type;
typename counter_type::type counter = counter_type()();
prechecksum_type prechecksum;
- std::size_t checksum = compute_checksum<algorithm, size_expected>(prechecksum(seq_begin, seq_end),
- prechecksum(seq_end, seq_end),
- counter);
- if(checksum != size_expected)
+ std::size_t checksum = compute_checksum<algorithm,
+ processor,
+ size_expected>(prechecksum(seq_begin, seq_end),
+ prechecksum(seq_end, seq_end),
+ counter);
+ if(checksum != bad_sequence)
return algorithm::compute_checkdigit(checksum);
return bad_sequence;
}
@@ -224,6 +236,7 @@
\returns An iterator initialized at one pass the end of checkdigits.
*/
template <typename algorithm,
+ template <class> class processor,
typename prechecksum_type,
typename checkdigit,
typename seq_iterator>
@@ -232,7 +245,8 @@
typedef typename boost::checks::detail::skip_counter<checkdigit::pos, checkdigit::size> counter_type;
typename counter_type::type counter = counter_type()();
prechecksum_type prechecksum;
- std::size_t checksum = compute_checksum<algorithm>(prechecksum(seq_begin, seq_end),
+ std::size_t checksum = compute_checksum<algorithm,
+ processor>(prechecksum(seq_begin, seq_end),
prechecksum(seq_end, seq_end),
counter);
return algorithm::compute_multicheckdigit(checksum);
@@ -255,6 +269,7 @@
\returns An iterator initialized at one pass the end of checkdigits.
*/
template <typename algorithm,
+ template <class> class processor,
typename prechecksum_type,
std::size_t size_expected,
typename checkdigit,
@@ -264,9 +279,11 @@
typedef typename boost::checks::detail::skip_counter<checkdigit::pos, checkdigit::size> counter_type;
typename counter_type::type counter = counter_type()();
prechecksum_type prechecksum;
- std::size_t checksum = compute_checksum<algorithm, size_expected>(prechecksum(seq_begin, seq_end),
- prechecksum(seq_end, seq_end),
- counter);
+ std::size_t checksum = compute_checksum<algorithm,
+ processor,
+ size_expected>(prechecksum(seq_begin, seq_end),
+ prechecksum(seq_end, seq_end),
+ counter);
if(checksum != bad_sequence)
return algorithm::compute_multicheckdigit(checksum);
return std::pair<std::size_t, std::size_t>(bad_sequence, bad_sequence);
Modified: sandbox/SOC/2011/checks/boost/checks/ean.hpp
==============================================================================
--- sandbox/SOC/2011/checks/boost/checks/ean.hpp (original)
+++ sandbox/SOC/2011/checks/boost/checks/ean.hpp 2012-02-26 14:13:18 EST (Sun, 26 Feb 2012)
@@ -20,6 +20,7 @@
#include <boost/checks/checkdigit.hpp>
#include <boost/checks/basic_checks.hpp>
#include <boost/checks/modulus10.hpp>
+#include <boost/checks/weighted_sum.hpp>
#include <boost/range/rbegin.hpp>
#include <boost/range/rend.hpp>
@@ -40,11 +41,11 @@
/*!
\brief This is the weight used by EAN system.
*/
-typedef boost::checks::weight<1,3> ean_weight;
+typedef weighted_sum<weight<1,3> > ean_processor;
/*!
\brief This is the type of the EAN algorithm.
*/
-typedef boost::checks::modulus10_algorithm<ean_weight> ean_algorithm;
+typedef modulus10_algorithm ean_algorithm;
/*!
\brief Validate a sequence according to the ean_check_algorithm type.
@@ -61,7 +62,10 @@
template <typename check_range>
bool check_ean13(const check_range& check_seq)
{
- return boost::checks::check_sequence<ean_algorithm, digit_prechecksum, EAN13_SIZE> (boost::rbegin(check_seq), boost::rend(check_seq));
+ return boost::checks::check_sequence<ean_algorithm,
+ ean_processor::processor,
+ digit_prechecksum,
+ EAN13_SIZE> (boost::rbegin(check_seq), boost::rend(check_seq));
}
/*!
@@ -80,7 +84,11 @@
template <typename check_range>
std::size_t compute_ean13(const check_range& check_seq)
{
- return boost::checks::compute_checkdigit<ean_algorithm, digit_prechecksum, EAN13_SIZE, basic_checkdigit>(boost::rbegin(check_seq), boost::rend(check_seq));
+ return boost::checks::compute_checkdigit<ean_algorithm,
+ ean_processor::processor,
+ digit_prechecksum,
+ EAN13_SIZE,
+ basic_checkdigit>(boost::rbegin(check_seq), boost::rend(check_seq));
}
/*!
@@ -98,7 +106,10 @@
template <typename check_range>
bool check_ean8 (const check_range& check_seq)
{
- return boost::checks::check_sequence<ean_algorithm, digit_prechecksum, EAN8_SIZE>(boost::rbegin(check_seq), boost::rend(check_seq));
+ return boost::checks::check_sequence<ean_algorithm,
+ ean_processor::processor,
+ digit_prechecksum,
+ EAN8_SIZE>(boost::rbegin(check_seq), boost::rend(check_seq));
}
/*!
@@ -117,7 +128,11 @@
template <typename check_range>
std::size_t compute_ean8(const check_range& check_seq)
{
- return boost::checks::compute_checkdigit<ean_algorithm, digit_prechecksum, EAN8_SIZE, boost::checks::basic_checkdigit>(boost::rbegin(check_seq), boost::rend(check_seq));
+ return boost::checks::compute_checkdigit<ean_algorithm,
+ ean_processor::processor,
+ digit_prechecksum,
+ EAN8_SIZE,
+ basic_checkdigit>(boost::rbegin(check_seq), boost::rend(check_seq));
}
Modified: sandbox/SOC/2011/checks/boost/checks/isbn.hpp
==============================================================================
--- sandbox/SOC/2011/checks/boost/checks/isbn.hpp (original)
+++ sandbox/SOC/2011/checks/boost/checks/isbn.hpp 2012-02-26 14:13:18 EST (Sun, 26 Feb 2012)
@@ -34,13 +34,6 @@
namespace boost {
namespace checks{
-/*! \class isbn13_algorithm
- \brief This class can be used to compute or validate checksum with a basic modulus 10 but using a custom filter for the ISBN-13 prefix.
-
- \tparam checkdigit_size Help functions to provide same behavior on sequence with and without check digits. No "real" value in the sequence will be skipped.
-*/
-typedef boost::checks::modulus10_algorithm<boost::checks::ean_weight> isbn13_algorithm;
-
/*!
\brief Validate a sequence according to the isbn13_check_algorithm type.
@@ -56,7 +49,7 @@
template <typename check_range>
bool check_isbn13 (const check_range& check_seq)
{
- return boost::checks::check_sequence<isbn13_algorithm, digit_prechecksum, EAN13_SIZE>(boost::rbegin(check_seq), boost::rend(check_seq));
+ return check_ean13(check_seq);
}
/*!
@@ -75,7 +68,7 @@
template <typename check_range>
std::size_t compute_isbn13 (const check_range& check_seq)
{
- return boost::checks::compute_checkdigit<isbn13_algorithm, digit_prechecksum, EAN13_SIZE, boost::checks::basic_checkdigit>(boost::rbegin(check_seq), boost::rend(check_seq));
+ return compute_ean13(check_seq);
}
/*!
Modified: sandbox/SOC/2011/checks/boost/checks/luhn.hpp
==============================================================================
--- sandbox/SOC/2011/checks/boost/checks/luhn.hpp (original)
+++ sandbox/SOC/2011/checks/boost/checks/luhn.hpp 2012-02-26 14:13:18 EST (Sun, 26 Feb 2012)
@@ -26,43 +26,33 @@
namespace boost {
namespace checks{
+typedef modulus10_algorithm luhn_algorithm;
+
/*!
- \brief This is the weight used by the Luhn algorithm.
-*/
-typedef boost::checks::weight<1,2> luhn_weight;
+ \brief Compute the Luhn algorithm operation on the checksum.
+
+ \post checksum is equal to the new computed checksum.
-/*! \class luhn_algorithm
- \brief This class can be used to compute or validate checksum with the Luhn algorithm.
+ \param current_valid_value is the current valid value analysed.
+ \param valid_value_counter is the number of valid value already counted (the current value is not included).\n This is also the position (above the valid values) of the current value analysed (0 <= valid_value_counter < n).
+ \param checksum is the current checksum.
- \tparam checkdigit_size Help functions to provide same behavior on sequence with and without check digits. No "real" value in the sequence will be skipped.
+ \remarks This function become obsolete if you don't use luhn_weight. It is using operator "<<" to make internal multiplication.
*/
-struct luhn_algorithm : boost::checks::modulus10_algorithm <luhn_weight>
+template <typename Function>
+struct luhn_processor
{
- /*!
- \brief Compute the Luhn algorithm operation on the checksum.
+ int weight;
+ luhn_processor(Function counter) : weight((counter() & 1)^1) { }
- \post checksum is equal to the new computed checksum.
-
- \param current_valid_value is the current valid value analysed.
- \param valid_value_counter is the number of valid value already counted (the current value is not included).\n This is also the position (above the valid values) of the current value analysed (0 <= valid_value_counter < n).
- \param checksum is the current checksum.
-
- \remarks This function become obsolete if you don't use luhn_weight. It is using operator "<<" to make internal multiplication.
- */
- template <typename Function>
- struct processor
+ std::size_t operator()(std::size_t checksum, std::size_t value)
{
- Function counter;
- processor(Function counter) : counter(counter) { }
-
- std::size_t operator()(std::size_t checksum, std::size_t value)
- {
- std::size_t weighted_value = value << (luhn_weight::at(counter()) -1);
- return checksum + weighted_value % 10 + weighted_value / 10;
- }
- };
+ std::size_t weighted_value = value << (weight ^= 1);
+ return checksum + weighted_value % 10 + weighted_value / 10;
+ }
};
+
/*!
\brief Validate a sequence according to the luhn_check_algorithm type.
@@ -79,7 +69,10 @@
template <size_t size_expected, typename check_range>
bool check_luhn (const check_range& check_seq)
{
- return boost::checks::check_sequence<luhn_algorithm, digit_prechecksum, size_expected>(boost::rbegin(check_seq), boost::rend(check_seq));
+ return boost::checks::check_sequence<luhn_algorithm,
+ luhn_processor,
+ digit_prechecksum,
+ size_expected>(boost::rbegin(check_seq), boost::rend(check_seq));
}
/*!
@@ -97,7 +90,9 @@
template <typename check_range>
bool check_luhn (const check_range& check_seq)
{
- return boost::checks::check_sequence<luhn_algorithm, digit_prechecksum> (boost::rbegin(check_seq), boost::rend(check_seq));
+ return boost::checks::check_sequence<luhn_algorithm,
+ luhn_processor,
+ digit_prechecksum>(boost::rbegin(check_seq), boost::rend(check_seq));
}
/*!
@@ -117,7 +112,11 @@
template <size_t size_expected, typename check_range>
std::size_t compute_luhn(const check_range& check_seq)
{
- return boost::checks::compute_checkdigit<luhn_algorithm, digit_prechecksum, size_expected, boost::checks::basic_checkdigit>(boost::rbegin(check_seq), boost::rend(check_seq));
+ return boost::checks::compute_checkdigit<luhn_algorithm,
+ luhn_processor,
+ digit_prechecksum,
+ size_expected,
+ basic_checkdigit>(boost::rbegin(check_seq), boost::rend(check_seq));
}
/*!
@@ -136,7 +135,10 @@
template <typename check_range>
std::size_t compute_luhn (const check_range& check_seq)
{
- return boost::checks::compute_checkdigit<luhn_algorithm, digit_prechecksum, boost::checks::basic_checkdigit>(boost::rbegin(check_seq), boost::rend(check_seq));
+ return boost::checks::compute_checkdigit<luhn_algorithm,
+ luhn_processor,
+ digit_prechecksum,
+ basic_checkdigit>(boost::rbegin(check_seq), boost::rend(check_seq));
}
Modified: sandbox/SOC/2011/checks/boost/checks/mastercard.hpp
==============================================================================
--- sandbox/SOC/2011/checks/boost/checks/mastercard.hpp (original)
+++ sandbox/SOC/2011/checks/boost/checks/mastercard.hpp 2012-02-26 14:13:18 EST (Sun, 26 Feb 2012)
@@ -47,7 +47,10 @@
template <typename check_range>
bool check_mastercard(const check_range& check_seq)
{
- return boost::checks::check_sequence<luhn_algorithm, digit_prechecksum, MASTERCARD_SIZE>(boost::rbegin(check_seq), boost::rend(check_seq));
+ return check_sequence<luhn_algorithm,
+ luhn_processor,
+ digit_prechecksum,
+ MASTERCARD_SIZE>(boost::rbegin(check_seq), boost::rend(check_seq));
}
/*!
@@ -67,7 +70,11 @@
template <typename check_range>
std::size_t compute_mastercard(const check_range& check_seq)
{
- return boost::checks::compute_checkdigit<luhn_algorithm, digit_prechecksum, MASTERCARD_SIZE, boost::checks::basic_checkdigit>(boost::rbegin(check_seq), boost::rend(check_seq));
+ return compute_checkdigit<luhn_algorithm,
+ luhn_processor,
+ digit_prechecksum,
+ MASTERCARD_SIZE,
+ basic_checkdigit>(boost::rbegin(check_seq), boost::rend(check_seq));
}
Modified: sandbox/SOC/2011/checks/boost/checks/modulus10.hpp
==============================================================================
--- sandbox/SOC/2011/checks/boost/checks/modulus10.hpp (original)
+++ sandbox/SOC/2011/checks/boost/checks/modulus10.hpp 2012-02-26 14:13:18 EST (Sun, 26 Feb 2012)
@@ -29,8 +29,7 @@
\tparam iteration_sense must meet the iteration_sense concept requirements.
\tparam checkdigit_size Help functions to provide same behavior on sequence with and without check digits. No "real" value in the sequence will be skipped.
*/
-template <typename mod10_weight>
-struct modulus10_algorithm : boost::checks::weighted_sum_algorithm<mod10_weight>
+struct modulus10_algorithm
{
/*!
\brief Validate a checksum with a simple modulus 10.
Modified: sandbox/SOC/2011/checks/boost/checks/modulus11.hpp
==============================================================================
--- sandbox/SOC/2011/checks/boost/checks/modulus11.hpp (original)
+++ sandbox/SOC/2011/checks/boost/checks/modulus11.hpp 2012-02-26 14:13:18 EST (Sun, 26 Feb 2012)
@@ -36,8 +36,8 @@
\remarks The range of the check digit is [0..10], the tenth element is translated as the letter 'X'.
*/
-template <typename mod11_weight>
-struct modulus11_algorithm : boost::checks::weighted_sum_algorithm<mod11_weight>
+
+struct modulus11_algorithm
{
/*!
\brief Validate a checksum with a simple modulus 11.
@@ -70,12 +70,14 @@
/*!
\brief The most common weight pattern used with a modulus 11 algorithm.
*/
-typedef boost::checks::weight<1,2,3,4,5,6,7,8,9,10> mod11_weight;
+typedef weight<1,2,3,4,5,6,7,8,9,10> mod11_weight;
/*!
\brief This is the type of the most common modulus 11 algorithm.
*/
-typedef modulus11_algorithm<mod11_weight> mod11_algorithm;
+typedef modulus11_algorithm mod11_algorithm;
+
+typedef weighted_sum<mod11_weight> mod11_processor;
/*!
\brief Validate a sequence according to the mod11_check_algorithm type.
@@ -93,7 +95,10 @@
template <size_t size_expected, typename check_range>
bool check_modulus11(const check_range& check_seq)
{
- return boost::checks::check_sequence<mod11_algorithm, digitx_prechecksum, size_expected>(boost::rbegin(check_seq), boost::rend(check_seq));
+ return boost::checks::check_sequence<mod11_algorithm,
+ mod11_processor::processor,
+ digitx_prechecksum,
+ size_expected>(boost::rbegin(check_seq), boost::rend(check_seq));
}
/*!
@@ -111,7 +116,9 @@
template <typename check_range>
bool check_modulus11(const check_range& check_seq)
{
- return boost::checks::check_sequence<mod11_algorithm, digitx_prechecksum>(boost::rbegin(check_seq), boost::rend(check_seq));
+ return boost::checks::check_sequence<mod11_algorithm,
+ mod11_processor::processor,
+ digitx_prechecksum>(boost::rbegin(check_seq), boost::rend(check_seq));
}
/*!
@@ -131,7 +138,11 @@
template <std::size_t size_expected, typename check_range>
std::size_t compute_modulus11(const check_range& check_seq)
{
- return boost::checks::compute_checkdigit<mod11_algorithm, digitx_prechecksum, size_expected, boost::checks::basic_checkdigit>(boost::rbegin(check_seq), boost::rend(check_seq));
+ return compute_checkdigit<mod11_algorithm,
+ mod11_processor::processor,
+ digitx_prechecksum,
+ size_expected,
+ basic_checkdigit>(boost::rbegin(check_seq), boost::rend(check_seq));
}
/*!
@@ -150,7 +161,10 @@
template <typename check_range>
std::size_t compute_modulus11(const check_range& check_seq)
{
- return boost::checks::compute_checkdigit<mod11_algorithm, digitx_prechecksum, boost::checks::basic_checkdigit>(boost::rbegin(check_seq), boost::rend(check_seq));
+ return compute_checkdigit<mod11_algorithm,
+ mod11_processor::processor,
+ digitx_prechecksum,
+ basic_checkdigit>(boost::rbegin(check_seq), boost::rend(check_seq));
}
}} // namespace boost namespace checks
Modified: sandbox/SOC/2011/checks/boost/checks/modulus97.hpp
==============================================================================
--- sandbox/SOC/2011/checks/boost/checks/modulus97.hpp (original)
+++ sandbox/SOC/2011/checks/boost/checks/modulus97.hpp 2012-02-26 14:13:18 EST (Sun, 26 Feb 2012)
@@ -35,8 +35,8 @@
\remarks This algorithm use two check digits.
*/
-template <typename mod97_weight>
-struct modulus97_algorithm : boost::checks::weighted_sum_algorithm<mod97_weight>
+
+struct modulus97_algorithm
{
/*!
\brief Validate a checksum with a simple modulus 97.
@@ -113,15 +113,32 @@
/*!
\brief This is weight of the mod97-10 algorithm.
*/
-typedef boost::checks::weight<BOOST_PP_ENUM(96, MOD97_weight_maker, ~)> mod97_10_weight;
+typedef weight<BOOST_PP_ENUM(96, MOD97_weight_maker, ~)> mod97_10_weight;
/*!
\brief This is the type of the modulus 97-10 algorithm.
*/
-typedef modulus97_algorithm<mod97_10_weight> mod97_10_algorithm;
+typedef modulus97_algorithm mod97_10_algorithm;
+
+// typedef weighted_sum<mod97_10_weight> mod97_10_processor;
typedef checkdigit<0, 2> mod97_10_checkdigit;
+typedef weighted_sum<mod97_10_weight> mod97_10_processor;
+/*
+template <typename Function>
+struct mod97_10_processor
+{
+ unsigned char weight;
+ mod97_10_processor(Function counter) : weight(68) { }
+
+ std::size_t operator()(std::size_t checksum, std::size_t value)
+ {
+ weight = weight * 10 % 97;
+ return checksum + value * weight;
+ }
+};*/
+
/*!
\brief Validate a sequence according to the mod97_10_check_algorithm type.
@@ -138,7 +155,10 @@
template <size_t size_expected, typename check_range>
bool check_mod97_10 (const check_range& check_seq)
{
- return boost::checks::check_sequence<mod97_10_algorithm, digit_prechecksum, size_expected> (boost::rbegin(check_seq), boost::rend(check_seq));
+ return boost::checks::check_sequence<mod97_10_algorithm,
+ mod97_10_processor::processor,
+ digit_prechecksum,
+ size_expected>(boost::rbegin(check_seq), boost::rend(check_seq));
}
/*!
@@ -156,7 +176,9 @@
template <typename check_range>
bool check_mod97_10(const check_range& check_seq)
{
- return boost::checks::check_sequence<mod97_10_algorithm, digit_prechecksum >(boost::rbegin(check_seq), boost::rend(check_seq));
+ return boost::checks::check_sequence<mod97_10_algorithm,
+ mod97_10_processor::processor,
+ digit_prechecksum>(boost::rbegin(check_seq), boost::rend(check_seq));
}
/*!
@@ -178,7 +200,11 @@
template <size_t size_expected, typename check_range>
std::pair<std::size_t, std::size_t> compute_mod97_10(const check_range& check_seq)
{
- return boost::checks::compute_multicheckdigit<mod97_10_algorithm, digit_prechecksum, mod97_10_checkdigit, size_expected>(boost::rbegin(check_seq), boost::rend(check_seq));
+ return boost::checks::compute_multicheckdigit<mod97_10_algorithm,
+ mod97_10_processor::processor,
+ digit_prechecksum,
+ mod97_10_checkdigit,
+ size_expected>(boost::rbegin(check_seq), boost::rend(check_seq));
}
/*!
@@ -199,7 +225,10 @@
template <typename check_range>
std::pair<std::size_t, std::size_t> compute_mod97_10(const check_range& check_seq)
{
- return boost::checks::compute_multicheckdigit<mod97_10_algorithm, digit_prechecksum, mod97_10_checkdigit>(boost::rbegin(check_seq), boost::rend(check_seq));
+ return boost::checks::compute_multicheckdigit<mod97_10_algorithm,
+ mod97_10_processor::processor,
+ digit_prechecksum,
+ mod97_10_checkdigit>(boost::rbegin(check_seq), boost::rend(check_seq));
}
Modified: sandbox/SOC/2011/checks/boost/checks/upc.hpp
==============================================================================
--- sandbox/SOC/2011/checks/boost/checks/upc.hpp (original)
+++ sandbox/SOC/2011/checks/boost/checks/upc.hpp 2012-02-26 14:13:18 EST (Sun, 26 Feb 2012)
@@ -23,6 +23,7 @@
#include <boost/checks/weight.hpp>
#include <boost/checks/basic_checks.hpp>
#include <boost/checks/modulus10.hpp>
+#include <boost/checks/weighted_sum.hpp>
/*!
\brief This macro defines the size of an UPC-A.
@@ -40,7 +41,9 @@
/*!
\brief This is the type of the UPC algorithm.
*/
-typedef boost::checks::modulus10_algorithm<upc_weight> upc_algorithm;
+typedef modulus10_algorithm upc_algorithm;
+
+typedef weighted_sum<upc_weight> upc_processor;
/*!
\brief Validate a sequence according to the upc_check_algorithm type.
@@ -57,7 +60,10 @@
template <typename check_range>
bool check_upca (const check_range& check_seq)
{
- return boost::checks::check_sequence<upc_algorithm, digit_prechecksum, UPCA_SIZE>(boost::rbegin(check_seq), boost::rend(check_seq));
+ return boost::checks::check_sequence<upc_algorithm,
+ upc_processor::processor,
+ digit_prechecksum,
+ UPCA_SIZE>(boost::rbegin(check_seq), boost::rend(check_seq));
}
/*!
@@ -76,7 +82,11 @@
template <typename check_range>
std::size_t compute_upca(const check_range& check_seq)
{
- return boost::checks::compute_checkdigit<upc_algorithm, digit_prechecksum, UPCA_SIZE, boost::checks::basic_checkdigit>(boost::rbegin(check_seq), boost::rend(check_seq));
+ return boost::checks::compute_checkdigit<upc_algorithm,
+ upc_processor::processor,
+ digit_prechecksum,
+ UPCA_SIZE,
+ basic_checkdigit>(boost::rbegin(check_seq), boost::rend(check_seq));
}
}} // namespace boost namespace checks
Modified: sandbox/SOC/2011/checks/boost/checks/verhoeff.hpp
==============================================================================
--- sandbox/SOC/2011/checks/boost/checks/verhoeff.hpp (original)
+++ sandbox/SOC/2011/checks/boost/checks/verhoeff.hpp 2012-02-26 14:13:18 EST (Sun, 26 Feb 2012)
@@ -36,34 +36,9 @@
\tparam checkdigit_size Help functions to provide same behavior on sequence with and without check digits. No "real" value in the sequence will be skipped.
*/
-struct verhoeff_algorithm : boost::checks::basic_check_algorithm
+struct verhoeff_algorithm
{
/*!
- \brief Compute the Verhoeff scheme on the checksum with the current valid value.
-
- \post checksum is equal to the new computed checksum.
-
- \param current_valid_value is the current valid value analysed.
- \param valid_value_counter is the number of valid value already counted(the current value is not included).\n This is also the position(above the valid values)of the current value analysed(0 <= valid_value_counter < n).
- \param checksum is the current checksum.
-
- \remarks This function use the classic table d and p of the Verhoeff algorithm.
- */
- template <typename Function>
- struct processor
- {
- static const unsigned char d[10][10];
- static const unsigned char p[8][10];
-
- Function counter;
- processor(Function counter) : counter(counter) { }
-
- std::size_t operator()(std::size_t checksum, std::size_t value)
- {
- return d[checksum][p[counter() % 8][value]];
- }
- };
- /*!
\brief Validate the Verhoeff checksum.
\param checksum is the checksum to validate.
@@ -93,8 +68,34 @@
}
};
+/*!
+ \brief Compute the Verhoeff scheme on the checksum with the current valid value.
+
+ \post checksum is equal to the new computed checksum.
+
+ \param current_valid_value is the current valid value analysed.
+ \param valid_value_counter is the number of valid value already counted(the current value is not included).\n This is also the position(above the valid values)of the current value analysed(0 <= valid_value_counter < n).
+ \param checksum is the current checksum.
+
+ \remarks This function use the classic table d and p of the Verhoeff algorithm.
+*/
+template <typename Function>
+struct verhoeff_processor
+{
+ static const unsigned char d[10][10];
+ static const unsigned char p[8][10];
+
+ Function counter;
+ verhoeff_processor(Function counter) : counter(counter) { }
+
+ std::size_t operator()(std::size_t checksum, std::size_t value)
+ {
+ return d[checksum][p[counter() % 8][value]];
+ }
+};
+
template <typename Function>
-const unsigned char verhoeff_algorithm::processor<Function>::d[10][10] =
+const unsigned char verhoeff_processor<Function>::d[10][10] =
{
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },
{ 1, 2, 3, 4, 0, 6, 7, 8, 9, 5 },
@@ -109,7 +110,7 @@
};
template <typename Function>
-const unsigned char verhoeff_algorithm::processor<Function>::p[8][10] =
+const unsigned char verhoeff_processor<Function>::p[8][10] =
{
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },
{ 1, 5, 7, 6, 2, 8, 3, 0, 9, 4 },
@@ -137,7 +138,10 @@
template <size_t size_expected, typename check_range>
bool check_verhoeff(const check_range& check_seq)
{
- return boost::checks::check_sequence<verhoeff_algorithm, digit_prechecksum, size_expected>(boost::rbegin(check_seq), boost::rend(check_seq));
+ return boost::checks::check_sequence<verhoeff_algorithm,
+ verhoeff_processor,
+ digit_prechecksum,
+ size_expected>(boost::rbegin(check_seq), boost::rend(check_seq));
}
/*!
@@ -155,7 +159,9 @@
template <typename check_range>
bool check_verhoeff(const check_range& check_seq)
{
- return boost::checks::check_sequence<verhoeff_algorithm, digit_prechecksum >(boost::rbegin(check_seq), boost::rend(check_seq));
+ return boost::checks::check_sequence<verhoeff_algorithm,
+ verhoeff_processor,
+ digit_prechecksum >(boost::rbegin(check_seq), boost::rend(check_seq));
}
/*!
@@ -175,11 +181,11 @@
template <size_t size_expected, typename check_range>
std::size_t compute_verhoeff(const check_range& check_seq)
{
- return boost::checks::compute_checkdigit<verhoeff_algorithm,
- digit_prechecksum,
- size_expected,
- basic_checkdigit>
- (boost::rbegin(check_seq), boost::rend(check_seq));
+ return compute_checkdigit<verhoeff_algorithm,
+ verhoeff_processor,
+ digit_prechecksum,
+ size_expected,
+ basic_checkdigit>(boost::rbegin(check_seq), boost::rend(check_seq));
}
/*!
@@ -198,10 +204,10 @@
template <typename check_range>
std::size_t compute_verhoeff(const check_range& check_seq)
{
- return boost::checks::compute_checkdigit<verhoeff_algorithm,
- digit_prechecksum,
- basic_checkdigit>
- (boost::rbegin(check_seq), boost::rend(check_seq));
+ return compute_checkdigit<verhoeff_algorithm,
+ verhoeff_processor,
+ digit_prechecksum,
+ basic_checkdigit>(boost::rbegin(check_seq), boost::rend(check_seq));
}
}}
Modified: sandbox/SOC/2011/checks/boost/checks/visa.hpp
==============================================================================
--- sandbox/SOC/2011/checks/boost/checks/visa.hpp (original)
+++ sandbox/SOC/2011/checks/boost/checks/visa.hpp 2012-02-26 14:13:18 EST (Sun, 26 Feb 2012)
@@ -47,7 +47,10 @@
template <typename check_range>
bool check_visa(const check_range& check_seq)
{
- return boost::checks::check_sequence<luhn_algorithm, digit_prechecksum, VISA_SIZE>(boost::rbegin(check_seq), boost::rend(check_seq));
+ return check_sequence<luhn_algorithm,
+ luhn_processor,
+ digit_prechecksum,
+ VISA_SIZE>(boost::rbegin(check_seq), boost::rend(check_seq));
}
/*!
@@ -67,7 +70,11 @@
template <typename check_range>
std::size_t compute_visa(const check_range& check_seq)
{
- return boost::checks::compute_checkdigit<luhn_algorithm, digit_prechecksum, VISA_SIZE, boost::checks::basic_checkdigit>(boost::rbegin(check_seq), boost::rend(check_seq));
+ return compute_checkdigit<luhn_algorithm,
+ luhn_processor,
+ digit_prechecksum,
+ VISA_SIZE,
+ basic_checkdigit>(boost::rbegin(check_seq), boost::rend(check_seq));
}
Modified: sandbox/SOC/2011/checks/boost/checks/weighted_sum.hpp
==============================================================================
--- sandbox/SOC/2011/checks/boost/checks/weighted_sum.hpp (original)
+++ sandbox/SOC/2011/checks/boost/checks/weighted_sum.hpp 2012-02-26 14:13:18 EST (Sun, 26 Feb 2012)
@@ -24,24 +24,17 @@
namespace checks{
/*!
- \brief This class permits to add to the current checksum the weight multiplied by the current value.
+ \brief Compute an operation on the checksum with the current valid value.
- \tparam weight must meet the weight concept requirements.
- \tparam iteration_sense must meet the iteration_sense concept requirements.
- \tparam checkdigit_size Helper function to provide same behavior on sequence with and without checkdigits. No "real" value in the sequence will be skipped.
+ \post The current weight multiplied by the current value is added to the checksum.
+
+ \param current_valid_value is the current valid value analysed.
+ \param valid_value_counter is the number of valid values already counted (the current value is not included).\n This is also the position (above the valid values) of the current value analysed (0 <= valid_value_counter < n).
+ \param checksum is the current checksum.
*/
template <typename weight>
-struct weighted_sum_algorithm : boost::checks::basic_check_algorithm
+struct weighted_sum
{
- /*!
- \brief Compute an operation on the checksum with the current valid value.
-
- \post The current weight multiplied by the current value is added to the checksum.
-
- \param current_valid_value is the current valid value analysed.
- \param valid_value_counter is the number of valid values already counted (the current value is not included).\n This is also the position (above the valid values) of the current value analysed (0 <= valid_value_counter < n).
- \param checksum is the current checksum.
- */
template <typename Function>
struct processor
{