Subject: [Boost-commit] svn:boost r58188 - sandbox/itl/boost/validate/std/algorithm
From: afojgo_at_[hidden]
Date: 2009-12-06 10:29:11
Author: jofaber
Date: 2009-12-06 10:29:10 EST (Sun, 06 Dec 2009)
New Revision: 58188
URL: http://svn.boost.org/trac/boost/changeset/58188
Log:
Added find.hpp wrapping std::{find, lower_bound, upper_bound} to be used in law based tests. Stable {msvc-9.0}
Added:
sandbox/itl/boost/validate/std/algorithm/find.hpp (contents, props changed)
Added: sandbox/itl/boost/validate/std/algorithm/find.hpp
==============================================================================
--- (empty file)
+++ sandbox/itl/boost/validate/std/algorithm/find.hpp 2009-12-06 10:29:10 EST (Sun, 06 Dec 2009)
@@ -0,0 +1,254 @@
+/*-----------------------------------------------------------------------------+
+A Law Based Test Automaton 'LaBatea'
+Author: Joachim Faulhaber
+Copyright (c) 2009-2009: Joachim Faulhaber
++------------------------------------------------------------------------------+
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENCE.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
++-----------------------------------------------------------------------------*/
+#ifndef BOOST_VALIDATE_STD_ALGORITHM_FIND_HPP_JOFA_091205
+#define BOOST_VALIDATE_STD_ALGORITHM_FIND_HPP_JOFA_091205
+
+#include <algorithm>
+
+namespace boost{namespace itl
+{
+
+//------------------------------------------------------------------------------
+//- std::find ------------------------------------------------------------------
+template<class SegmentalT, class TargetT>
+class std_find
+{
+public:
+ typedef typename SegmentalT::atomized_type AtomicT;
+ typedef typename AtomicT::value_type value_type;
+private:
+ std_find& operator = (const std_find&);
+public:
+ std_find(const TargetT& comparand)
+ : _comparand(comparand){}
+
+ TargetT operator()(const AtomicT& source)const
+ {
+ typename AtomicT::const_iterator found
+ = std::find(source.begin(), source.end(), _comparand);
+ if(found == source.end())
+ return neutron<TargetT>::value();
+ else
+ return *found;
+ }
+
+ TargetT operator()(const SegmentalT& source)const
+ {
+ typename SegmentalT::element_const_iterator found
+ = std::find(source.elements_begin(), source.elements_end(), _comparand);
+ if(found == source.elements_end())
+ return neutron<TargetT>::value();
+ else
+ return *found;
+ }
+
+ static std::string struct_abbreviation(){ return "find_f"; }
+
+private:
+ value_type _comparand;
+};
+
+
+template<class SegmentalT, class TargetT>
+class std_find_back
+{
+public:
+ typedef typename SegmentalT::atomized_type AtomicT;
+ typedef typename AtomicT::value_type value_type;
+private:
+ std_find_back& operator = (const std_find_back&);
+public:
+ std_find_back(const TargetT& comparand)
+ : _comparand(comparand){}
+
+ TargetT operator()(const AtomicT& source)const
+ {
+ AtomicT::const_reverse_iterator found = std::find(source.rbegin(), source.rend(), _comparand);
+ if(found == source.rend())
+ return neutron<TargetT>::value();
+ else
+ return *found;
+ }
+
+ TargetT operator()(const SegmentalT& source)const
+ {
+ SegmentalT::element_const_reverse_iterator found
+ = std::find(source.elements_rbegin(), source.elements_rend(), _comparand);
+ if(found == source.elements_rend())
+ return neutron<TargetT>::value();
+ else
+ return *found;
+ }
+
+ static std::string struct_abbreviation(){ return "find_b"; }
+
+private:
+ value_type _comparand;
+};
+
+
+//------------------------------------------------------------------------------
+//- std::lower_bound -----------------------------------------------------------
+template<class SegmentalT, class TargetT>
+class std_lower_bound
+{
+public:
+ typedef typename SegmentalT::atomized_type AtomicT;
+ typedef typename AtomicT::value_type value_type;
+private:
+ std_lower_bound& operator = (const std_lower_bound&);
+public:
+ std_lower_bound(const TargetT& comparand)
+ : _comparand(comparand){}
+
+ TargetT operator()(const AtomicT& source)const
+ {
+ AtomicT::const_iterator found = std::lower_bound(source.begin(), source.end(), _comparand);
+ if(found == source.end())
+ return neutron<TargetT>::value();
+ else
+ return *found;
+ }
+
+ TargetT operator()(const SegmentalT& source)const
+ {
+ SegmentalT::element_const_iterator found = std::lower_bound(source.elements_begin(), source.elements_end(), _comparand);
+ if(found == source.elements_end())
+ return neutron<TargetT>::value();
+ else
+ return *found;
+ }
+
+ static std::string struct_abbreviation(){ return "lwb_f"; }
+
+private:
+ value_type _comparand;
+};
+
+
+template<class SegmentalT, class TargetT>
+class std_lower_bound_back
+{
+public:
+ typedef typename SegmentalT::atomized_type AtomicT;
+ typedef typename AtomicT::value_type value_type;
+private:
+ std_lower_bound_back& operator = (const std_lower_bound_back&);
+public:
+ std_lower_bound_back(const TargetT& comparand)
+ : _comparand(comparand){}
+
+ TargetT operator()(const AtomicT& source)const
+ {
+ AtomicT::const_reverse_iterator found = std::lower_bound(source.rbegin(), source.rend(), _comparand);
+ if(found == source.rend())
+ return neutron<TargetT>::value();
+ else
+ return *found;
+ }
+
+ TargetT operator()(const SegmentalT& source)const
+ {
+ SegmentalT::element_const_reverse_iterator found
+ = std::lower_bound(source.elements_rbegin(), source.elements_rend(), _comparand);
+ if(found == source.elements_rend())
+ return neutron<TargetT>::value();
+ else
+ return *found;
+ }
+
+ static std::string struct_abbreviation(){ return "lwb_b"; }
+
+private:
+ value_type _comparand;
+};
+
+
+//------------------------------------------------------------------------------
+//- std::upper_bound -----------------------------------------------------------
+template<class SegmentalT, class TargetT>
+class std_upper_bound
+{
+public:
+ typedef typename SegmentalT::atomized_type AtomicT;
+ typedef typename AtomicT::value_type value_type;
+private:
+ std_upper_bound& operator = (const std_upper_bound&);
+public:
+ std_upper_bound(const TargetT& comparand)
+ : _comparand(comparand){}
+
+ TargetT operator()(const AtomicT& source)const
+ {
+ AtomicT::const_iterator found = std::upper_bound(source.begin(), source.end(), _comparand);
+ if(found == source.end())
+ return neutron<TargetT>::value();
+ else
+ return *found;
+ }
+
+ TargetT operator()(const SegmentalT& source)const
+ {
+ SegmentalT::element_const_iterator found = std::upper_bound(source.elements_begin(), source.elements_end(), _comparand);
+ if(found == source.elements_end())
+ return neutron<TargetT>::value();
+ else
+ return *found;
+ }
+
+ static std::string struct_abbreviation(){ return "upb_f"; }
+
+private:
+ value_type _comparand;
+};
+
+
+template<class SegmentalT, class TargetT>
+class std_upper_bound_back
+{
+public:
+ typedef typename SegmentalT::atomized_type AtomicT;
+ typedef typename AtomicT::value_type value_type;
+private:
+ std_upper_bound_back& operator = (const std_upper_bound_back&);
+public:
+ std_upper_bound_back(const TargetT& comparand)
+ : _comparand(comparand){}
+
+ TargetT operator()(const AtomicT& source)const
+ {
+ AtomicT::const_reverse_iterator found = std::upper_bound(source.rbegin(), source.rend(), _comparand);
+ if(found == source.rend())
+ return neutron<TargetT>::value();
+ else
+ return *found;
+ }
+
+ TargetT operator()(const SegmentalT& source)const
+ {
+ SegmentalT::element_const_reverse_iterator found
+ = std::upper_bound(source.elements_rbegin(), source.elements_rend(), _comparand);
+ if(found == source.elements_rend())
+ return neutron<TargetT>::value();
+ else
+ return *found;
+ }
+
+ static std::string struct_abbreviation(){ return "upb_b"; }
+
+private:
+ value_type _comparand;
+};
+
+
+}} // namespace itl boost
+
+#endif // BOOST_VALIDATE_STD_ALGORITHM_FIND_HPP_JOFA_091205
+