Subject: [Boost-commit] svn:boost r58156 - in sandbox/itl: boost/itl boost/itl/detail boost/itl_xt boost/validate/driver boost/validate/gentor boost/validate/laws boost/validate/std/algorithm boost/validate/validater libs/itl/example/splititvmap_shell_ libs/validate/example/labat_single_
From: afojgo_at_[hidden]
Date: 2009-12-05 19:49:49
Author: jofaber
Date: 2009-12-05 19:49:47 EST (Sat, 05 Dec 2009)
New Revision: 58156
URL: http://svn.boost.org/trac/boost/changeset/58156
Log:
Modified law based tests 'sorted_associative_*' to check std::algorithms for element_iterators. Stable {msvc-9.0}
Text files modified:
sandbox/itl/boost/itl/detail/mapped_reference.hpp | 55 ++++++++++++++++++++
sandbox/itl/boost/itl/detail/set_algo.hpp | 23 +------
sandbox/itl/boost/itl/interval_base_map.hpp | 5 -
sandbox/itl/boost/itl/interval_base_set.hpp | 5 -
sandbox/itl/boost/itl/split_interval_set.hpp | 5 -
sandbox/itl/boost/itl_xt/interval_bitset.hpp | 1
sandbox/itl/boost/validate/driver/unsigned_quantifier_driver.hpp | 4
sandbox/itl/boost/validate/gentor/randomgentor.hpp | 11 +++
sandbox/itl/boost/validate/laws/atomic_equivalence.hpp | 110 +++++++++++++++++++++++++++++++++++----
sandbox/itl/boost/validate/std/algorithm/copy.hpp | 36 ++++++++----
sandbox/itl/boost/validate/std/algorithm/relation.hpp | 38 +++++++++----
sandbox/itl/boost/validate/std/algorithm/set_algo.hpp | 50 ++++++++++++------
sandbox/itl/boost/validate/validater/bit_collector_validater.hpp | 2
sandbox/itl/boost/validate/validater/sorted_associative_back_validater.hpp | 44 ++++++++++++---
sandbox/itl/boost/validate/validater/sorted_associative_validater.hpp | 46 ++++++++++++----
sandbox/itl/boost/validate/validater/unsigned_quantifier_validater.hpp | 14 ++++
sandbox/itl/libs/itl/example/splititvmap_shell_/splititvmap_shell.cpp | 2
sandbox/itl/libs/validate/example/labat_single_/labat_single.cpp | 13 ++-
18 files changed, 344 insertions(+), 120 deletions(-)
Modified: sandbox/itl/boost/itl/detail/mapped_reference.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/mapped_reference.hpp (original)
+++ sandbox/itl/boost/itl/detail/mapped_reference.hpp 2009-12-05 19:49:47 EST (Sat, 05 Dec 2009)
@@ -10,6 +10,7 @@
#include <boost/type_traits/is_const.hpp>
#include <boost/mpl/if.hpp>
+#include <boost/itl/type_traits/is_concept_equivalent.hpp>
namespace boost{namespace itl
{
@@ -47,26 +48,80 @@
{ return left.first == right.first && left.second == right.second; }
template<class FirstT, class SecondT>
+inline bool operator == (const mapped_reference<FirstT, SecondT>& left, const std::pair<const FirstT, SecondT>& right)
+{ return left.first == right.first && left.second == right.second; }
+
+template<class FirstT, class SecondT>
+inline bool operator == (const std::pair<const FirstT, SecondT>& left, const mapped_reference<FirstT, SecondT>& right)
+{ return left.first == right.first && left.second == right.second; }
+
+//------------------------------------------------------------------------------
+template<class FirstT, class SecondT>
inline bool operator < (const mapped_reference<FirstT, SecondT>& left, const mapped_reference<FirstT, SecondT>& right)
{ return left.first < right.first || (!(right.first < left.first) && left.second < right.second); }
template<class FirstT, class SecondT>
+inline bool operator < (const mapped_reference<FirstT, SecondT>& left, const std::pair<const FirstT, SecondT>& right)
+{ return left.first < right.first || (!(right.first < left.first) && left.second < right.second); }
+
+template<class FirstT, class SecondT>
+inline bool operator < (const std::pair<const FirstT, SecondT>& left, const mapped_reference<FirstT, SecondT>& right)
+{ return left.first < right.first || (!(right.first < left.first) && left.second < right.second); }
+
+//------------------------------------------------------------------------------
+template<class FirstT, class SecondT>
inline bool operator != (const mapped_reference<FirstT, SecondT>& left, const mapped_reference<FirstT, SecondT>& right)
{ return !(left == right); }
template<class FirstT, class SecondT>
+inline bool operator != (const mapped_reference<FirstT, SecondT>& left, const std::pair<const FirstT, SecondT>& right)
+{ return !(left == right); }
+
+template<class FirstT, class SecondT>
+inline bool operator != (const std::pair<const FirstT, SecondT>& left, const mapped_reference<FirstT, SecondT>& right)
+{ return !(left == right); }
+
+//------------------------------------------------------------------------------
+template<class FirstT, class SecondT>
inline bool operator > (const mapped_reference<FirstT, SecondT>& left, const mapped_reference<FirstT, SecondT>& right)
{ return right < left; }
template<class FirstT, class SecondT>
+inline bool operator > (const mapped_reference<FirstT, SecondT>& left, const std::pair<const FirstT, SecondT>& right)
+{ return right < left; }
+
+template<class FirstT, class SecondT>
+inline bool operator > (const std::pair<const FirstT, SecondT>& left, const mapped_reference<FirstT, SecondT>& right)
+{ return right < left; }
+
+//------------------------------------------------------------------------------
+template<class FirstT, class SecondT>
inline bool operator <= (const mapped_reference<FirstT, SecondT>& left, const mapped_reference<FirstT, SecondT>& right)
{ return !(right < left); }
template<class FirstT, class SecondT>
+inline bool operator <= (const mapped_reference<FirstT, SecondT>& left, const std::pair<const FirstT, SecondT>& right)
+{ return !(right < left); }
+
+template<class FirstT, class SecondT>
+inline bool operator <= (const std::pair<const FirstT, SecondT>& left, const mapped_reference<FirstT, SecondT>& right)
+{ return !(right < left); }
+
+//------------------------------------------------------------------------------
+template<class FirstT, class SecondT>
inline bool operator >= (const mapped_reference<FirstT, SecondT>& left, const mapped_reference<FirstT, SecondT>& right)
{ return !(left < right); }
template<class FirstT, class SecondT>
+inline bool operator >= (const mapped_reference<FirstT, SecondT>& left, const std::pair<const FirstT, SecondT>& right)
+{ return !(left < right); }
+
+template<class FirstT, class SecondT>
+inline bool operator >= (const std::pair<const FirstT, SecondT>& left, const mapped_reference<FirstT, SecondT>& right)
+{ return !(left < right); }
+
+//------------------------------------------------------------------------------
+template<class FirstT, class SecondT>
inline mapped_reference<FirstT, SecondT> make_mapped_reference(const FirstT& left, SecondT& right)
{ return mapped_reference<FirstT, SecondT>(left, right); }
Modified: sandbox/itl/boost/itl/detail/set_algo.hpp
==============================================================================
--- sandbox/itl/boost/itl/detail/set_algo.hpp (original)
+++ sandbox/itl/boost/itl/detail/set_algo.hpp 2009-12-05 19:49:47 EST (Sat, 05 Dec 2009)
@@ -164,27 +164,14 @@
/** Function template <tt>lexicographical_equal</tt> implements
- lexicographical equality. */
+ lexicographical equality. */
template<class SetType>
bool lexicographical_equal(const SetType& left, const SetType& right)
{
- if(&left == &right) return true;
- if(left.iterative_size() != right.iterative_size())
- return false;
-
- // so we have two sorted containers with equal element counts
- typename SetType::const_iterator left_ = left.begin();
- typename SetType::const_iterator right_ = right.begin();
-
- while(left_ != left.end())
- {
- if(!(*left_==*right_))
- return false;
-
- ++left_; ++right_;
- }
-
- return true;
+ if(&left == &right)
+ return true;
+ else return left.iterative_size() == right.iterative_size()
+ && std::equal(left.begin(), left.end(), right.begin());
}
Modified: sandbox/itl/boost/itl/interval_base_map.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_base_map.hpp (original)
+++ sandbox/itl/boost/itl/interval_base_map.hpp 2009-12-05 19:49:47 EST (Sat, 05 Dec 2009)
@@ -1417,11 +1417,6 @@
inline bool operator == (const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& lhs,
const interval_base_map<SubType,DomainT,CodomainT,Traits,Compare,Combine,Section,Interval,Alloc>& rhs)
{
- //MEMO PORT: This implementation worked with stlport, sgi and gnu
- // implementations of the stl. But using MSVC-implementation
- // results in runtime error! So I had to provide an independent
- // safe implementation.
- //return std::equal(lhs.begin(), lhs.end(), rhs.begin());
return Set::lexicographical_equal(lhs, rhs);
}
Modified: sandbox/itl/boost/itl/interval_base_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/interval_base_set.hpp (original)
+++ sandbox/itl/boost/itl/interval_base_set.hpp 2009-12-05 19:49:47 EST (Sat, 05 Dec 2009)
@@ -715,11 +715,6 @@
inline bool operator == (const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& lhs,
const interval_base_set<SubType,DomainT,Compare,Interval,Alloc>& rhs)
{
- //MEMO PORT: This implementation worked with stlport, sgi and gnu
- // implementations of the stl. But using MSVC-implementation
- // results in runtime error! So I had to provide an independent
- // safe implementation.
- //return std::equal(lhs.begin(), lhs.end(), rhs.begin());
return Set::lexicographical_equal(lhs, rhs);
}
Modified: sandbox/itl/boost/itl/split_interval_set.hpp
==============================================================================
--- sandbox/itl/boost/itl/split_interval_set.hpp (original)
+++ sandbox/itl/boost/itl/split_interval_set.hpp 2009-12-05 19:49:47 EST (Sat, 05 Dec 2009)
@@ -325,11 +325,6 @@
inline bool operator == (const split_interval_set<DomainT,Compare,Interval,Alloc>& lhs,
const split_interval_set<DomainT,Compare,Interval,Alloc>& rhs)
{
- //MEMO PORT: This implementation worked with stlport, sgi and gnu
- // implementations of the stl. But using MSVC-implementation
- // results in runtime error! So I had to provide an independent
- // safe implementation.
- //return std::equal(lhs.begin(), lhs.end(), rhs.begin());
return Set::lexicographical_equal(lhs, rhs);
}
Modified: sandbox/itl/boost/itl_xt/interval_bitset.hpp
==============================================================================
--- sandbox/itl/boost/itl_xt/interval_bitset.hpp (original)
+++ sandbox/itl/boost/itl_xt/interval_bitset.hpp 2009-12-05 19:49:47 EST (Sat, 05 Dec 2009)
@@ -63,6 +63,7 @@
std::less, boost::itl::inplace_bit_add, boost::itl::inplace_bit_and> interval_bitmap_type;
typedef DomainT domain_type;
+ typedef DomainT codomain_type;
typedef DomainT element_type; // 0 .. 2^digits(element_type)-1
typedef DomainT condensed_type; // 0 .. (2^digits(element_type)-1)/digits(word_type)
typedef typename BitSetT::word_type word_type; // 0 .. 2^digits(word_type)-1
Modified: sandbox/itl/boost/validate/driver/unsigned_quantifier_driver.hpp
==============================================================================
--- sandbox/itl/boost/validate/driver/unsigned_quantifier_driver.hpp (original)
+++ sandbox/itl/boost/validate/driver/unsigned_quantifier_driver.hpp 2009-12-05 19:49:47 EST (Sat, 05 Dec 2009)
@@ -94,8 +94,8 @@
algebra_validater* chooseValidater()
{
int rootChoice = _rootChoice.some();
- int domainChoice = _domainChoice.some();
- int codomainChoice = _codomainChoice.some();
+ //int domainChoice = _domainChoice.some();
+ //int codomainChoice = _codomainChoice.some();
int neutronizerChoice = _neutronizerChoice.some();
switch(rootChoice)
Modified: sandbox/itl/boost/validate/gentor/randomgentor.hpp
==============================================================================
--- sandbox/itl/boost/validate/gentor/randomgentor.hpp (original)
+++ sandbox/itl/boost/validate/gentor/randomgentor.hpp 2009-12-05 19:49:47 EST (Sat, 05 Dec 2009)
@@ -320,7 +320,16 @@
template <>
struct Calibrater<std::pair<int,int>, RandomGentor>
{
- static void apply(RandomGentor< std::pair<int,int> >&){}
+ static void apply(RandomGentor< std::pair<int,int> >& gentor)
+ {
+ // Set the range within which the sizes of the generated object varies.
+ NumberGentorT<int>* int_gentor_1 = new NumberGentorT<int>;
+ NumberGentorT<int>* int_gentor_2 = new NumberGentorT<int>;
+ int_gentor_1->setRange(GentorProfileSgl::it()->range_int());
+ int_gentor_2->setRange(GentorProfileSgl::it()->range_int());
+ gentor.set_first_gentor(int_gentor_1);
+ gentor.set_second_gentor(int_gentor_2);
+ }
};
template <>
Modified: sandbox/itl/boost/validate/laws/atomic_equivalence.hpp
==============================================================================
--- sandbox/itl/boost/validate/laws/atomic_equivalence.hpp (original)
+++ sandbox/itl/boost/validate/laws/atomic_equivalence.hpp 2009-12-05 19:49:47 EST (Sat, 05 Dec 2009)
@@ -16,9 +16,6 @@
#include <boost/itl/predicates.hpp>
#include <boost/itl/interval_morphism.hpp>
#include <boost/validate/laws/law.hpp>
-#include <boost/validate/std/algorithm/copy.hpp>
-#include <boost/validate/std/algorithm/set_algo.hpp>
-#include <boost/validate/std/algorithm/relation.hpp>
namespace boost{namespace itl
{
@@ -40,7 +37,7 @@
// -----------------------------------------------------------------------------
template <typename SegmentsT,
typename TargetsT = typename SegmentsT::atomized_type,
- template<class,class,template<class>class>class Algorithm = itl::std_copy,
+ template<class,class,template<class>class>class Algorithm,
template<class>class TargetIterator = std::insert_iterator,
template<class,class>class Atomizer = itl::Interval::Atomize,
template<class>class Equality = itl::std_equal >
@@ -60,6 +57,7 @@
*/
public:
typedef typename SegmentsT::atomized_type ElementsT;
+ typedef Algorithm<SegmentsT,TargetsT,TargetIterator> Algo;
std::string name()const { return "UnaryAtomicEquivalence"; }
std::string formula()const { return "For all S a: Alg<E,T,I>(atomize(a)) == Alg<S,T,I>(a)"; }
@@ -70,7 +68,7 @@
"EleEq<"
+ type_to_string<SegmentsT>::apply()+","
+ type_to_string<TargetsT>::apply() +","
- + Algorithm<ElementsT,TargetsT,TargetIterator>::struct_abbreviation() +">";
+ + Algo::struct_abbreviation() +">";
}
public:
@@ -83,11 +81,98 @@
SegmentsT segmental_a = this->template getInputValue<operand_a>();
ElementsT elemental_a;
Atomizer<ElementsT,SegmentsT>()(elemental_a, segmental_a);
- Algorithm<ElementsT,TargetsT,TargetIterator>::apply(elemental_a, lhs);
+ Algo()(elemental_a, lhs);
// --- right hand side -------------------------------------------------
TargetsT rhs;
- Algorithm<SegmentsT,TargetsT,TargetIterator>::apply_elemental(segmental_a, rhs);
+ Algo()(segmental_a, rhs);
+
+ this->template setOutputValue<lhs_result>(lhs);
+ this->template setOutputValue<rhs_result>(rhs);
+
+ return Equality<TargetsT>()(lhs, rhs);
+ }
+
+ bool debug_holds()
+ {
+ return holds();
+ }
+
+ size_t size()const
+ {
+ return value_size<SegmentsT>::apply(this->template getInputValue<operand_a>());
+ }
+};
+
+
+
+// -----------------------------------------------------------------------------
+// S: Segment container
+// f: Atomize function transforming an interval container into an element container
+// E: Element container
+// g: A function (specifically std::algorithm) applicable to S and E
+// T: Target container
+//
+// S
+// / \
+// f / \ g
+// / = \
+// V V
+// E ------> T
+// g
+// -----------------------------------------------------------------------------
+template <typename SegmentsT,
+ typename TargetsT = typename SegmentsT::atomized_type,
+ template<class,class>class Algorithm,
+ template<class,class>class Atomizer = itl::Interval::Atomize,
+ template<class>class Equality = itl::std_equal >
+class UnaryAtomicEquivalence2 :
+ public Law<UnaryAtomicEquivalence2<SegmentsT, TargetsT,
+ Algorithm, Atomizer, Equality>,
+ LOKI_TYPELIST_2(SegmentsT, TargetsT),
+ LOKI_TYPELIST_2(TargetsT, TargetsT) >
+{
+ /** S: SegmentsT, T: TargetsT, I: InputIterator
+ Alg<S,T,I>: an algortihm on interval containers S
+ that results in a container T via iterator I.
+ For all S a: Alg<E,T,I>(c)(atomize(a)) == Alg<S,T,I>(c)(a)
+ Input = (a := inVal1)
+ Output = (lhs_result, rhs_result)
+ */
+public:
+ typedef typename SegmentsT::atomized_type ElementsT;
+ typedef typename ElementsT::value_type value_type;
+ typedef TargetsT element_type;
+
+ typedef Algorithm<SegmentsT,TargetsT> Algo;
+
+ std::string name()const { return "UnaryAtomicEquivalence2"; }
+ std::string formula()const { return "For all S a: Alg<E,T,I>(c)(atomize(a)) == Alg<S,T,I>(c)(a)"; }
+
+ std::string typeString()const
+ {
+ return
+ "EleEq2<"
+ + type_to_string<SegmentsT>::apply()+","
+ + type_to_string<TargetsT>::apply() +","
+ + Algo::struct_abbreviation() +">";
+ }
+
+public:
+
+ bool holds()
+ {
+ // For all S a: Alg<E,T,I>(c)(atomize(a)) == Alg<S,T,I>(c)(a)
+ // --- left hand side --------------------------------------------------
+ SegmentsT segmental_a = this->template getInputValue<operand_a>();
+ element_type comparand = this->template getInputValue<operand_b>();
+ ElementsT elemental_a;
+ Atomizer<ElementsT,SegmentsT>()(elemental_a, segmental_a);
+ Algo algorithm(comparand);
+ TargetsT lhs = algorithm(elemental_a);
+
+ // --- right hand side -------------------------------------------------
+ TargetsT rhs = algorithm(segmental_a);
this->template setOutputValue<lhs_result>(lhs);
this->template setOutputValue<rhs_result>(rhs);
@@ -125,7 +210,7 @@
// -----------------------------------------------------------------------------
template <typename SegmentsT,
typename TargetsT = typename SegmentsT::atomized_type,
- template<class,class,template<class>class>class Algorithm = itl::std_set_union,
+ template<class,class,template<class>class>class Algorithm,
template<class>class TargetIterator = std::insert_iterator,
template<class,class>class Atomizer = itl::Interval::Atomize,
template<class>class Equality = itl::std_equal >
@@ -144,6 +229,7 @@
Output = (lhs_result, rhs_result)
*/
public:
+ typedef Algorithm<SegmentsT,TargetsT,TargetIterator> Algo;
typedef typename SegmentsT::atomized_type ElementsT;
std::string name()const { return "BinaryAtomicEquivalence"; }
@@ -156,7 +242,7 @@
"EleEq<"
+ type_to_string<SegmentsT>::apply()+","
+ type_to_string<TargetsT>::apply() +","
- + Algorithm<ElementsT,TargetsT,TargetIterator>::struct_abbreviation() +">";
+ + Algo::struct_abbreviation() +">";
}
public:
@@ -171,11 +257,11 @@
ElementsT elemental_a, elemental_b;
Atomizer<ElementsT,SegmentsT>()(elemental_a, segmental_a);
Atomizer<ElementsT,SegmentsT>()(elemental_b, segmental_b);
- Algorithm<ElementsT,TargetsT,TargetIterator>::apply(elemental_a, elemental_b, lhs);
+ Algo()(elemental_a, elemental_b, lhs);
// --- right hand side -------------------------------------------------
TargetsT rhs;
- Algorithm<SegmentsT,TargetsT,TargetIterator>::apply_elemental(segmental_a, segmental_b, rhs);
+ Algo()(segmental_a, segmental_b, rhs);
this->template setOutputValue<lhs_result>(lhs);
this->template setOutputValue<rhs_result>(rhs);
@@ -197,5 +283,5 @@
}} // namespace itl boost
-#endif BOOST_VALIDATE_LAWS_ATOMIC_EQUIVALENCE_HPP_JOFA_091124
+#endif // BOOST_VALIDATE_LAWS_ATOMIC_EQUIVALENCE_HPP_JOFA_091124
Modified: sandbox/itl/boost/validate/std/algorithm/copy.hpp
==============================================================================
--- sandbox/itl/boost/validate/std/algorithm/copy.hpp (original)
+++ sandbox/itl/boost/validate/std/algorithm/copy.hpp 2009-12-05 19:49:47 EST (Sat, 05 Dec 2009)
@@ -20,13 +20,15 @@
template<class SourceT, class TargetT, template<class>class InsertIterator>
struct std_copy
{
- static void apply(const SourceT& source, TargetT& target)
+ typedef typename SourceT::atomized_type AtomicT;
+
+ void operator()(const AtomicT& source, TargetT& target)const
{
std::copy(source.begin(), source.end(),
InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
}
- static void apply_elemental(const SourceT& source, TargetT& target)
+ void operator()(const SourceT& source, TargetT& target)const
{
std::copy(source.elements_begin(), source.elements_end(),
InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
@@ -38,13 +40,15 @@
template<class SourceT, class TargetT, template<class>class InsertIterator>
struct std_copy_back
{
- static void apply(const SourceT& source, TargetT& target)
+ typedef typename SourceT::atomized_type AtomicT;
+
+ void operator()(const AtomicT& source, TargetT& target)
{
std::copy(source.rbegin(), source.rend(),
InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
}
- static void apply_elemental(const SourceT& source, TargetT& target)
+ void operator()(const SourceT& source, TargetT& target)
{
std::copy(source.elements_rbegin(), source.elements_rend(),
InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
@@ -58,13 +62,15 @@
template<class SourceT, class TargetT, template<class>class InsertIterator>
struct std_reverse_copy
{
- static void apply(const SourceT& source, TargetT& target)
+ typedef typename SourceT::atomized_type AtomicT;
+
+ void operator()(const AtomicT& source, TargetT& target)
{
std::reverse_copy(source.begin(), source.end(),
InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
}
- static void apply_elemental(const SourceT& source, TargetT& target)
+ void operator()(const SourceT& source, TargetT& target)
{
std::reverse_copy(source.elements_begin(), source.elements_end(),
InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
@@ -76,13 +82,15 @@
template<class SourceT, class TargetT, template<class>class InsertIterator>
struct std_reverse_copy_back
{
- static void apply(const SourceT& source, TargetT& target)
+ typedef typename SourceT::atomized_type AtomicT;
+
+ void operator()(const AtomicT& source, TargetT& target)
{
std::reverse_copy(source.rbegin(), source.rend(),
InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
}
- static void apply_elemental(const SourceT& source, TargetT& target)
+ void operator()(const SourceT& source, TargetT& target)
{
std::reverse_copy(source.elements_rbegin(), source.elements_rend(),
InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
@@ -97,15 +105,16 @@
template<class SourceT, class TargetT, template<class>class InsertIterator>
struct std_copy_backward
{
+ typedef typename SourceT::atomized_type AtomicT;
typedef typename TargetT::value_type value_type;
- static void apply(const SourceT& source, TargetT& target)
+ void operator()(const AtomicT& source, TargetT& target)
{
fill_n(InsertIterator<TargetT>(target, target.end()), source.size(), neutron<value_type>::value());
std::copy_backward(source.begin(), source.end(), target.end());
}
- static void apply_elemental(const SourceT& source, TargetT& target)
+ void operator()(const SourceT& source, TargetT& target)
{
fill_n(InsertIterator<TargetT>(target, target.end()), source.size(), neutron<value_type>::value());
std::copy_backward(source.elements_begin(), source.elements_end(), target.end());
@@ -117,15 +126,16 @@
template<class SourceT, class TargetT, template<class>class InsertIterator>
struct std_copy_backward_back
{
+ typedef typename SourceT::atomized_type AtomicT;
typedef typename TargetT::value_type value_type;
- static void apply(const SourceT& source, TargetT& target)
+ void operator()(const AtomicT& source, TargetT& target)
{
fill_n(InsertIterator<TargetT>(target, target.end()), source.size(), neutron<value_type>::value());
std::copy_backward(source.rbegin(), source.rend(), target.end());
}
- static void apply_elemental(const SourceT& source, TargetT& target)
+ void operator()(const SourceT& source, TargetT& target)
{
fill_n(InsertIterator<TargetT>(target, target.end()), source.size(), neutron<value_type>::value());
std::copy_backward(source.elements_rbegin(), source.elements_rend(), target.end());
@@ -138,5 +148,5 @@
}} // namespace itl boost
-#endif BOOST_VALIDATE_STD_ALGORITHM_COPY_HPP_JOFA_091124
+#endif // BOOST_VALIDATE_STD_ALGORITHM_COPY_HPP_JOFA_091124
Modified: sandbox/itl/boost/validate/std/algorithm/relation.hpp
==============================================================================
--- sandbox/itl/boost/validate/std/algorithm/relation.hpp (original)
+++ sandbox/itl/boost/validate/std/algorithm/relation.hpp 2009-12-05 19:49:47 EST (Sat, 05 Dec 2009)
@@ -26,14 +26,16 @@
template<class SourceT, class TargetT, template<class>class InsertIterator>
struct std_equals
{
- static void apply(const SourceT& left, const SourceT& right, TargetT& target)
+ typedef typename SourceT::atomized_type AtomicT;
+
+ void operator()(const AtomicT& left, const AtomicT& right, TargetT& target)
{
target = false;
if(left.size() <= right.size())
target = std::equal(left.begin(), left.end(), right.begin());
}
- static void apply_elemental(const SourceT& left, const SourceT& right, TargetT& target)
+ void operator()(const SourceT& left, const SourceT& right, TargetT& target)
{
target = false;
if(left.size() <= right.size())
@@ -46,14 +48,16 @@
template<class SourceT, class TargetT, template<class>class InsertIterator>
struct std_equals_back
{
- static void apply(const SourceT& left, const SourceT& right, TargetT& target)
+ typedef typename SourceT::atomized_type AtomicT;
+
+ void operator()(const AtomicT& left, const AtomicT& right, TargetT& target)
{
target = false;
if(left.size() <= right.size())
target = std::equal(left.rbegin(), left.rend(), right.rbegin());
}
- static void apply_elemental(const SourceT& left, const SourceT& right, TargetT& target)
+ void operator()(const SourceT& left, const SourceT& right, TargetT& target)
{
target = false;
if(left.size() <= right.size())
@@ -73,13 +77,15 @@
template<class SourceT, class TargetT, template<class>class InsertIterator>
struct std_lexicographical_compare
{
- static void apply(const SourceT& left, const SourceT& right, TargetT& target)
+ typedef typename SourceT::atomized_type AtomicT;
+
+ void operator()(const AtomicT& left, const AtomicT& right, TargetT& target)
{
target = std::lexicographical_compare(left.begin(), left.end(),
right.begin(), right.end());
}
- static void apply_elemental(const SourceT& left, const SourceT& right, TargetT& target)
+ void operator()(const SourceT& left, const SourceT& right, TargetT& target)
{
target = std::lexicographical_compare
(left.elements_begin(), left.elements_end(),
@@ -93,13 +99,15 @@
template<class SourceT, class TargetT, template<class>class InsertIterator>
struct std_lexicographical_compare_back
{
- static void apply(const SourceT& left, const SourceT& right, TargetT& target)
+ typedef typename SourceT::atomized_type AtomicT;
+
+ void operator()(const AtomicT& left, const AtomicT& right, TargetT& target)
{
target = std::lexicographical_compare(left.rbegin(), left.rend(),
right.rbegin(), right.rend());
}
- static void apply_elemental(const SourceT& left, const SourceT& right, TargetT& target)
+ void operator()(const SourceT& left, const SourceT& right, TargetT& target)
{
target = std::lexicographical_compare
(left.elements_rbegin(), left.elements_rend(),
@@ -115,13 +123,15 @@
template<class SourceT, class TargetT, template<class>class InsertIterator>
struct std_includes
{
- static void apply(const SourceT& left, const SourceT& right, TargetT& target)
+ typedef typename SourceT::atomized_type AtomicT;
+
+ void operator()(const AtomicT& left, const AtomicT& right, TargetT& target)
{
target = std::includes(left.begin(), left.end(),
right.begin(), right.end());
}
- static void apply_elemental(const SourceT& left, const SourceT& right, TargetT& target)
+ void operator()(const SourceT& left, const SourceT& right, TargetT& target)
{
target = std::includes(left.elements_begin(), left.elements_end(),
right.elements_begin(), right.elements_end());
@@ -134,13 +144,15 @@
template<class SourceT, class TargetT, template<class>class InsertIterator>
struct std_includes_back
{
- static void apply(const SourceT& left, const SourceT& right, TargetT& target)
+ typedef typename SourceT::atomized_type AtomicT;
+
+ void operator()(const AtomicT& left, const AtomicT& right, TargetT& target)
{
target = std::includes(left.rbegin(), left.rend(),
right.rbegin(), right.rend());
}
- static void apply_elemental(const SourceT& left, const SourceT& right, TargetT& target)
+ void operator()(const SourceT& left, const SourceT& right, TargetT& target)
{
target = std::includes(left.elements_rbegin(), left.elements_rend(),
right.elements_rbegin(), right.elements_rend());
@@ -151,5 +163,5 @@
}} // namespace itl boost
-#endif BOOST_VALIDATE_STD_ALGORITHM_RELATION_HPP_JOFA_091202
+#endif // BOOST_VALIDATE_STD_ALGORITHM_RELATION_HPP_JOFA_091202
Modified: sandbox/itl/boost/validate/std/algorithm/set_algo.hpp
==============================================================================
--- sandbox/itl/boost/validate/std/algorithm/set_algo.hpp (original)
+++ sandbox/itl/boost/validate/std/algorithm/set_algo.hpp 2009-12-05 19:49:47 EST (Sat, 05 Dec 2009)
@@ -21,13 +21,15 @@
template<class SourceT, class TargetT, template<class>class InsertIterator>
struct std_set_union
{
- static void apply(const SourceT& left, const SourceT& right, TargetT& target)
+ typedef typename SourceT::atomized_type AtomicT;
+
+ void operator()(const AtomicT& left, const AtomicT& right, TargetT& target)
{
std::set_union(left.begin(), left.end(), right.begin(), right.end(),
InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
}
- static void apply_elemental(const SourceT& left, const SourceT& right, TargetT& target)
+ void operator()(const SourceT& left, const SourceT& right, TargetT& target)
{
std::set_union(
left.elements_begin(), left.elements_end(),
@@ -43,13 +45,15 @@
template<class SourceT, class TargetT, template<class>class InsertIterator>
struct std_set_union_back
{
- static void apply(const SourceT& left, const SourceT& right, TargetT& target)
+ typedef typename SourceT::atomized_type AtomicT;
+
+ void operator()(const AtomicT& left, const AtomicT& right, TargetT& target)
{
std::set_union(left.rbegin(), left.rend(), right.rbegin(), right.rend(),
InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
}
- static void apply_elemental(const SourceT& left, const SourceT& right, TargetT& target)
+ void operator()(const SourceT& left, const SourceT& right, TargetT& target)
{
std::set_union(
left.elements_rbegin(), left.elements_rend(),
@@ -67,13 +71,15 @@
template<class SourceT, class TargetT, template<class>class InsertIterator>
struct std_set_difference
{
- static void apply(const SourceT& left, const SourceT& right, TargetT& target)
+ typedef typename SourceT::atomized_type AtomicT;
+
+ void operator()(const AtomicT& left, const AtomicT& right, TargetT& target)
{
std::set_difference(left.begin(), left.end(), right.begin(), right.end(),
InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
}
- static void apply_elemental(const SourceT& left, const SourceT& right, TargetT& target)
+ void operator()(const SourceT& left, const SourceT& right, TargetT& target)
{
std::set_difference(
left.elements_begin(), left.elements_end(),
@@ -89,13 +95,15 @@
template<class SourceT, class TargetT, template<class>class InsertIterator>
struct std_set_difference_back
{
- static void apply(const SourceT& left, const SourceT& right, TargetT& target)
+ typedef typename SourceT::atomized_type AtomicT;
+
+ void operator()(const AtomicT& left, const AtomicT& right, TargetT& target)
{
std::set_difference(left.rbegin(), left.rend(), right.rbegin(), right.rend(),
InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
}
- static void apply_elemental(const SourceT& left, const SourceT& right, TargetT& target)
+ void operator()(const SourceT& left, const SourceT& right, TargetT& target)
{
std::set_difference(
left.elements_rbegin(), left.elements_rend(),
@@ -113,13 +121,15 @@
template<class SourceT, class TargetT, template<class>class InsertIterator>
struct std_set_intersection
{
- static void apply(const SourceT& left, const SourceT& right, TargetT& target)
+ typedef typename SourceT::atomized_type AtomicT;
+
+ void operator()(const AtomicT& left, const AtomicT& right, TargetT& target)
{
std::set_intersection(left.begin(), left.end(), right.begin(), right.end(),
InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
}
- static void apply_elemental(const SourceT& left, const SourceT& right, TargetT& target)
+ void operator()(const SourceT& left, const SourceT& right, TargetT& target)
{
std::set_intersection(
left.elements_begin(), left.elements_end(),
@@ -135,13 +145,15 @@
template<class SourceT, class TargetT, template<class>class InsertIterator>
struct std_set_intersection_back
{
- static void apply(const SourceT& left, const SourceT& right, TargetT& target)
+ typedef typename SourceT::atomized_type AtomicT;
+
+ void operator()(const AtomicT& left, const AtomicT& right, TargetT& target)
{
std::set_intersection(left.rbegin(), left.rend(), right.rbegin(), right.rend(),
InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
}
- static void apply_elemental(const SourceT& left, const SourceT& right, TargetT& target)
+ void operator()(const SourceT& left, const SourceT& right, TargetT& target)
{
std::set_intersection(
left.elements_rbegin(), left.elements_rend(),
@@ -159,13 +171,15 @@
template<class SourceT, class TargetT, template<class>class InsertIterator>
struct std_set_symmetric_difference
{
- static void apply(const SourceT& left, const SourceT& right, TargetT& target)
+ typedef typename SourceT::atomized_type AtomicT;
+
+ void operator()(const AtomicT& left, const AtomicT& right, TargetT& target)
{
std::set_symmetric_difference(left.begin(), left.end(), right.begin(), right.end(),
InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
}
- static void apply_elemental(const SourceT& left, const SourceT& right, TargetT& target)
+ void operator()(const SourceT& left, const SourceT& right, TargetT& target)
{
std::set_symmetric_difference(
left.elements_begin(), left.elements_end(),
@@ -181,13 +195,15 @@
template<class SourceT, class TargetT, template<class>class InsertIterator>
struct std_set_symmetric_difference_back
{
- static void apply(const SourceT& left, const SourceT& right, TargetT& target)
+ typedef typename SourceT::atomized_type AtomicT;
+
+ void operator()(const AtomicT& left, const AtomicT& right, TargetT& target)
{
std::set_symmetric_difference(left.rbegin(), left.rend(), right.rbegin(), right.rend(),
InsertIterator<TargetT>(target, typename TargetT::iterator(target.end())));
}
- static void apply_elemental(const SourceT& left, const SourceT& right, TargetT& target)
+ void operator()(const SourceT& left, const SourceT& right, TargetT& target)
{
std::set_symmetric_difference(
left.elements_rbegin(), left.elements_rend(),
@@ -202,5 +218,5 @@
}} // namespace itl boost
-#endif BOOST_VALIDATE_STD_ALGORITHM_SET_ALGO_HPP_JOFA_091125
+#endif // BOOST_VALIDATE_STD_ALGORITHM_SET_ALGO_HPP_JOFA_091125
Modified: sandbox/itl/boost/validate/validater/bit_collector_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/bit_collector_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/bit_collector_validater.hpp 2009-12-05 19:49:47 EST (Sat, 05 Dec 2009)
@@ -136,4 +136,4 @@
}} // namespace itl boost
-#endif BOOST_VALIDATE_VALIDATER_BIT_COLLECTOR_VALIDATER_HPP_JOFA_091009
+#endif // BOOST_VALIDATE_VALIDATER_BIT_COLLECTOR_VALIDATER_HPP_JOFA_091009
Modified: sandbox/itl/boost/validate/validater/sorted_associative_back_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/sorted_associative_back_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/sorted_associative_back_validater.hpp 2009-12-05 19:49:47 EST (Sat, 05 Dec 2009)
@@ -14,6 +14,11 @@
#include <boost/validate/validater/law_validater.hpp>
#include <boost/validate/validater/algebra_validater.hpp>
+#include <boost/validate/std/algorithm/copy.hpp>
+#include <boost/validate/std/algorithm/set_algo.hpp>
+#include <boost/validate/std/algorithm/relation.hpp>
+#include <boost/validate/std/algorithm/find.hpp>
+
namespace boost{namespace itl
{
@@ -23,6 +28,16 @@
class sorted_associative_back_validater : public algebra_validater
{
public:
+ typedef typename Type::atomized_type atomic_type;
+ typedef typename atomic_type::value_type value_type;
+ typedef typename Type::domain_type domain_type;
+ typedef typename Type::codomain_type codomain_type;
+
+ typedef typename mpl::if_< is_interval_map<Type>
+ , std::pair<domain_type, codomain_type>
+ , domain_type>::type element_type;
+
+public:
enum Laws
{
@@ -36,6 +51,9 @@
, set_difference
, set_intersection
, set_symmetric_difference
+ , find
+ , lower_bound
+ , upper_bound
, Laws_size
};
@@ -59,6 +77,9 @@
_lawChoice[set_difference ] = share(Laws_size, item_index, rest_shares);
_lawChoice[set_intersection ] = share(Laws_size, item_index, rest_shares);
_lawChoice[set_symmetric_difference] = share(Laws_size, item_index, rest_shares);
+ _lawChoice[find ] = share(Laws_size, item_index, rest_shares);
+ _lawChoice[lower_bound ] = share(Laws_size, item_index, rest_shares);
+ _lawChoice[upper_bound ] = share(Laws_size, item_index, rest_shares);
_lawChoice.init();
}
@@ -68,16 +89,19 @@
{
switch(_lawChoice.some())
{
- case copy : return new LawValidater< UnaryAtomicEquivalence<Type, TargetT, std_copy_back >, RandomGentor>;
- case copy_backward : return new LawValidater< UnaryAtomicEquivalence<Type, TargetT, std_copy_backward_back >, RandomGentor>;
- case reverse_copy : return new LawValidater< UnaryAtomicEquivalence<Type, TargetT, std_reverse_copy_back >, RandomGentor>;
- case equal : return new LawValidater<BinaryAtomicEquivalence<Type, bool, std_equals_back >, RandomGentor>;
- case lexicographical_compare : return new LawValidater<BinaryAtomicEquivalence<Type, bool, std_lexicographical_compare_back >, RandomGentor>;
- case includes : return new LawValidater<BinaryAtomicEquivalence<Type, bool, std_includes_back >, RandomGentor>;
- case set_union : return new LawValidater<BinaryAtomicEquivalence<Type, TargetT, std_set_union_back >, RandomGentor>;
- case set_difference : return new LawValidater<BinaryAtomicEquivalence<Type, TargetT, std_set_difference_back >, RandomGentor>;
- case set_intersection : return new LawValidater<BinaryAtomicEquivalence<Type, TargetT, std_set_intersection_back >, RandomGentor>;
- case set_symmetric_difference: return new LawValidater<BinaryAtomicEquivalence<Type, TargetT, std_set_symmetric_difference_back >, RandomGentor>;
+ case copy : return new LawValidater< UnaryAtomicEquivalence <Type, TargetT, std_copy_back >, RandomGentor>;
+ case copy_backward : return new LawValidater< UnaryAtomicEquivalence <Type, TargetT, std_copy_backward_back >, RandomGentor>;
+ case reverse_copy : return new LawValidater< UnaryAtomicEquivalence <Type, TargetT, std_reverse_copy_back >, RandomGentor>;
+ case equal : return new LawValidater<BinaryAtomicEquivalence <Type, bool, std_equals_back >, RandomGentor>;
+ case lexicographical_compare : return new LawValidater<BinaryAtomicEquivalence <Type, bool, std_lexicographical_compare_back >, RandomGentor>;
+ case includes : return new LawValidater<BinaryAtomicEquivalence <Type, bool, std_includes_back >, RandomGentor>;
+ case set_union : return new LawValidater<BinaryAtomicEquivalence <Type, TargetT, std_set_union_back >, RandomGentor>;
+ case set_difference : return new LawValidater<BinaryAtomicEquivalence <Type, TargetT, std_set_difference_back >, RandomGentor>;
+ case set_intersection : return new LawValidater<BinaryAtomicEquivalence <Type, TargetT, std_set_intersection_back >, RandomGentor>;
+ case set_symmetric_difference: return new LawValidater<BinaryAtomicEquivalence <Type, TargetT, std_set_symmetric_difference_back >, RandomGentor>;
+ case find : return new LawValidater< UnaryAtomicEquivalence2<Type, element_type, std_find_back >, RandomGentor>;
+ case lower_bound : return new LawValidater< UnaryAtomicEquivalence2<Type, element_type, std_lower_bound_back >, RandomGentor>;
+ case upper_bound : return new LawValidater< UnaryAtomicEquivalence2<Type, element_type, std_upper_bound_back >, RandomGentor>;
default: return NULL;
}
}
Modified: sandbox/itl/boost/validate/validater/sorted_associative_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/sorted_associative_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/sorted_associative_validater.hpp 2009-12-05 19:49:47 EST (Sat, 05 Dec 2009)
@@ -10,10 +10,17 @@
#ifndef BOOST_VALIDATE_VALIDATER_SORTED_ASSOCIATIVE_VALIDATER_HPP_JOFA_091125
#define BOOST_VALIDATE_VALIDATER_SORTED_ASSOCIATIVE_VALIDATER_HPP_JOFA_091125
+#include <boost/mpl/if.hpp>
#include <boost/validate/laws/atomic_equivalence.hpp>
#include <boost/validate/validater/law_validater.hpp>
#include <boost/validate/validater/algebra_validater.hpp>
+#include <boost/validate/std/algorithm/copy.hpp>
+#include <boost/validate/std/algorithm/set_algo.hpp>
+#include <boost/validate/std/algorithm/relation.hpp>
+#include <boost/validate/std/algorithm/find.hpp>
+
+
namespace boost{namespace itl
{
@@ -23,7 +30,15 @@
class sorted_associative_validater : public algebra_validater
{
public:
- typedef typename Type::value_type value_type;
+ typedef typename Type::atomized_type atomic_type;
+ typedef typename atomic_type::value_type value_type;
+ typedef typename Type::domain_type domain_type;
+ typedef typename Type::codomain_type codomain_type;
+
+ typedef typename mpl::if_< is_interval_map<Type>
+ , std::pair<domain_type, codomain_type>
+ , domain_type>::type element_type;
+
public:
enum Laws
@@ -38,6 +53,9 @@
, set_difference
, set_intersection
, set_symmetric_difference
+ , find
+ , lower_bound
+ , upper_bound
, Laws_size
};
@@ -61,6 +79,9 @@
_lawChoice[set_difference ] = share(Laws_size, item_index, rest_shares);
_lawChoice[set_intersection ] = share(Laws_size, item_index, rest_shares);
_lawChoice[set_symmetric_difference] = share(Laws_size, item_index, rest_shares);
+ _lawChoice[find ] = share(Laws_size, item_index, rest_shares);
+ _lawChoice[lower_bound ] = share(Laws_size, item_index, rest_shares);
+ _lawChoice[upper_bound ] = share(Laws_size, item_index, rest_shares);
_lawChoice.init();
}
@@ -70,16 +91,19 @@
{
switch(_lawChoice.some())
{
- case copy : return new LawValidater< UnaryAtomicEquivalence<Type, TargetT, std_copy >, RandomGentor>;
- case copy_backward : return new LawValidater< UnaryAtomicEquivalence<Type, TargetT, std_copy_backward >, RandomGentor>;
- case reverse_copy : return new LawValidater< UnaryAtomicEquivalence<Type, TargetT, std_reverse_copy >, RandomGentor>;
- case equal : return new LawValidater<BinaryAtomicEquivalence<Type, bool, std_equals >, RandomGentor>;
- case lexicographical_compare : return new LawValidater<BinaryAtomicEquivalence<Type, bool, std_lexicographical_compare >, RandomGentor>;
- case includes : return new LawValidater<BinaryAtomicEquivalence<Type, bool, std_includes >, RandomGentor>;
- case set_union : return new LawValidater<BinaryAtomicEquivalence<Type, TargetT, std_set_union >, RandomGentor>;
- case set_difference : return new LawValidater<BinaryAtomicEquivalence<Type, TargetT, std_set_difference >, RandomGentor>;
- case set_intersection : return new LawValidater<BinaryAtomicEquivalence<Type, TargetT, std_set_intersection >, RandomGentor>;
- case set_symmetric_difference: return new LawValidater<BinaryAtomicEquivalence<Type, TargetT, std_set_symmetric_difference >, RandomGentor>;
+ case copy : return new LawValidater< UnaryAtomicEquivalence <Type, TargetT, std_copy >, RandomGentor>;
+ case copy_backward : return new LawValidater< UnaryAtomicEquivalence <Type, TargetT, std_copy_backward >, RandomGentor>;
+ case reverse_copy : return new LawValidater< UnaryAtomicEquivalence <Type, TargetT, std_reverse_copy >, RandomGentor>;
+ case equal : return new LawValidater<BinaryAtomicEquivalence <Type, bool, std_equals >, RandomGentor>;
+ case lexicographical_compare : return new LawValidater<BinaryAtomicEquivalence <Type, bool, std_lexicographical_compare >, RandomGentor>;
+ case includes : return new LawValidater<BinaryAtomicEquivalence <Type, bool, std_includes >, RandomGentor>;
+ case set_union : return new LawValidater<BinaryAtomicEquivalence <Type, TargetT, std_set_union >, RandomGentor>;
+ case set_difference : return new LawValidater<BinaryAtomicEquivalence <Type, TargetT, std_set_difference >, RandomGentor>;
+ case set_intersection : return new LawValidater<BinaryAtomicEquivalence <Type, TargetT, std_set_intersection >, RandomGentor>;
+ case set_symmetric_difference: return new LawValidater<BinaryAtomicEquivalence <Type, TargetT, std_set_symmetric_difference >, RandomGentor>;
+ case find : return new LawValidater< UnaryAtomicEquivalence2<Type, element_type, std_find >, RandomGentor>;
+ case lower_bound : return new LawValidater< UnaryAtomicEquivalence2<Type, element_type, std_lower_bound >, RandomGentor>;
+ case upper_bound : return new LawValidater< UnaryAtomicEquivalence2<Type, element_type, std_upper_bound >, RandomGentor>;
default: return NULL;
}
}
Modified: sandbox/itl/boost/validate/validater/unsigned_quantifier_validater.hpp
==============================================================================
--- sandbox/itl/boost/validate/validater/unsigned_quantifier_validater.hpp (original)
+++ sandbox/itl/boost/validate/validater/unsigned_quantifier_validater.hpp 2009-12-05 19:49:47 EST (Sat, 05 Dec 2009)
@@ -7,7 +7,8 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#pragma once
+#ifndef BOOST_ITL_VALIDATE_VALIDATER_UNSIGNED_QUANTIFIER_VALIDATER_HPP_JOFA_090314
+#define BOOST_ITL_VALIDATE_VALIDATER_UNSIGNED_QUANTIFIER_VALIDATER_HPP_JOFA_090314
#include <boost/itl/functors.hpp>
#include <boost/itl/type_traits/absorbs_neutrons.hpp>
@@ -18,6 +19,11 @@
#include <boost/validate/validater/law_validater.hpp>
#include <boost/validate/validater/algebra_validater.hpp>
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4127) // conditional expression is constant
+#endif
+
namespace boost{namespace itl
{
@@ -113,3 +119,9 @@
}} // namespace itl boost
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_ITL_VALIDATE_VALIDATER_UNSIGNED_QUANTIFIER_VALIDATER_HPP_JOFA_090314
+
Modified: sandbox/itl/libs/itl/example/splititvmap_shell_/splititvmap_shell.cpp
==============================================================================
--- sandbox/itl/libs/itl/example/splititvmap_shell_/splititvmap_shell.cpp (original)
+++ sandbox/itl/libs/itl/example/splititvmap_shell_/splititvmap_shell.cpp 2009-12-05 19:49:47 EST (Sat, 05 Dec 2009)
@@ -55,7 +55,7 @@
instructions();
- while(true)
+ for(;;)
{
cout << "> ";
cin >> cmd ;
Modified: sandbox/itl/libs/validate/example/labat_single_/labat_single.cpp
==============================================================================
--- sandbox/itl/libs/validate/example/labat_single_/labat_single.cpp (original)
+++ sandbox/itl/libs/validate/example/labat_single_/labat_single.cpp 2009-12-05 19:49:47 EST (Sat, 05 Dec 2009)
@@ -27,6 +27,8 @@
//#include <boost/validate/laws/novial_tree.hpp>
#include <boost/validate/laws/inversion_laws.hpp>
#include <boost/validate/validater/law_validater.hpp>
+#include <boost/validate/std/algorithm/copy.hpp>
+#include <boost/validate/std/algorithm/find.hpp>
#include <boost/validate/gentor/gentorprofile.hpp>
#include <boost/validate/gentor/rangegentor.hpp>
#include <boost/itl/interval_set.hpp>
@@ -115,18 +117,19 @@
// itl::std_reverse_copy_forward
//> TestLawT;
- typedef UnaryAtomicEquivalence
+ typedef UnaryAtomicEquivalence2
<
- itl::interval_set<int>,
- itl::list<int>,
- itl::std_copy_backward_back
+ itl::interval_map<int,int>,
+ //itl::list<int>,
+ std::pair<int,int>,
+ itl::std_find
> TestLawT;
LawValidater<TestLawT, RandomGentor> test_law;
//-----------------------------------------------------------------------------
- int test_count = 1000;
+ int test_count = 10000;
ptime start, stop;
GentorProfileSgl::it()->set_std_profile(8,1);