summaryrefslogtreecommitdiff
path: root/boost/test/data/monomorphic/zip.hpp
diff options
context:
space:
mode:
Diffstat (limited to 'boost/test/data/monomorphic/zip.hpp')
-rw-r--r--boost/test/data/monomorphic/zip.hpp130
1 files changed, 64 insertions, 66 deletions
diff --git a/boost/test/data/monomorphic/zip.hpp b/boost/test/data/monomorphic/zip.hpp
index 3ee91817a9..1c7f46472c 100644
--- a/boost/test/data/monomorphic/zip.hpp
+++ b/boost/test/data/monomorphic/zip.hpp
@@ -1,4 +1,4 @@
-// (C) Copyright Gennadiy Rozental 2011-2014.
+// (C) Copyright Gennadiy Rozental 2001.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
@@ -12,12 +12,14 @@
#ifndef BOOST_TEST_DATA_MONOMORPHIC_ZIP_HPP_102211GER
#define BOOST_TEST_DATA_MONOMORPHIC_ZIP_HPP_102211GER
+// Boost.Test
#include <boost/test/data/config.hpp>
#if !defined(BOOST_TEST_NO_ZIP_COMPOSITION_AVAILABLE) || defined(BOOST_TEST_DOXYGEN_DOC__)
-// Boost.Test
-#include <boost/test/data/monomorphic/dataset.hpp>
+#include <boost/test/data/traits.hpp>
+#include <boost/test/data/monomorphic/fwd.hpp>
+
#include <boost/test/detail/suppress_warnings.hpp>
@@ -28,14 +30,11 @@ namespace monomorphic {
namespace ds_detail {
-
-//____________________________________________________________________________//
-
// !! ?? variadic template implementation; use forward_as_tuple?
template<typename T1, typename T2>
struct zip_traits {
typedef std::tuple<T1,T2> type;
- typedef typename monomorphic::traits<type>::ref_type ref_type;
+ typedef typename data::traits<type>::ref_type ref_type;
static ref_type
tuple_merge(T1 const& a1, T2 const& a2)
@@ -49,7 +48,7 @@ struct zip_traits {
template<typename T1, typename T2,typename T3>
struct zip_traits<T1,std::tuple<T2,T3>> {
typedef std::tuple<T1,T2,T3> type;
- typedef typename monomorphic::traits<type>::ref_type ref_type;
+ typedef typename data::traits<type>::ref_type ref_type;
static ref_type
tuple_merge(T1 const& a1, std::tuple<T2 const&,T3 const&> const& a2)
@@ -63,7 +62,7 @@ struct zip_traits<T1,std::tuple<T2,T3>> {
template<typename T1, typename T2,typename T3>
struct zip_traits<std::tuple<T1,T2>,T3> {
typedef std::tuple<T1,T2,T3> type;
- typedef typename monomorphic::traits<type>::ref_type ref_type;
+ typedef typename data::traits<type>::ref_type ref_type;
static ref_type
tuple_merge(std::tuple<T1 const&,T2 const&> const& a1, T3 const& a2)
@@ -72,8 +71,6 @@ struct zip_traits<std::tuple<T1,T2>,T3> {
}
};
-//____________________________________________________________________________//
-
} // namespace ds_detail
// ************************************************************************** //
@@ -84,82 +81,82 @@ struct zip_traits<std::tuple<T1,T2>,T3> {
//!
//! A zip of two datasets is a dataset whose arity is the sum of the operand datasets arity. The size is given by
//! the function creating the instance (see @c operator^ on datasets).
-template<typename DS1, typename DS2>
-class zip : public monomorphic::dataset<typename ds_detail::zip_traits<typename boost::decay<DS1>::type::data_type,
- typename boost::decay<DS2>::type::data_type>::type> {
- typedef typename boost::decay<DS1>::type::data_type T1;
- typedef typename boost::decay<DS2>::type::data_type T2;
+template<typename DataSet1, typename DataSet2>
+class zip {
+ typedef typename boost::decay<DataSet1>::type dataset1_decay;
+ typedef typename boost::decay<DataSet2>::type dataset2_decay;
+
+ typedef typename dataset1_decay::iterator dataset1_iter;
+ typedef typename dataset2_decay::iterator dataset2_iter;
- typedef typename monomorphic::dataset<T1>::iter_ptr ds1_iter_ptr;
- typedef typename monomorphic::dataset<T2>::iter_ptr ds2_iter_ptr;
+ typedef typename dataset1_decay::sample sample1;
+ typedef typename dataset2_decay::sample sample2;
+
+public:
+ typedef typename ds_detail::zip_traits<sample1,sample2>::type sample;
- typedef typename ds_detail::zip_traits<T1,T2>::type T;
- typedef monomorphic::dataset<T> base;
- typedef typename base::iter_ptr iter_ptr;
+ enum { arity = dataset1_decay::arity + dataset2_decay::arity };
- struct iterator : public base::iterator {
- typedef typename monomorphic::traits<T>::ref_type ref_type;
+ struct iterator {
+ typedef typename data::traits<sample>::ref_type ref_type;
// Constructor
- explicit iterator( ds1_iter_ptr iter1, ds2_iter_ptr iter2 )
- : m_iter1( iter1 )
- , m_iter2( iter2 )
+ explicit iterator( dataset1_iter iter1, dataset2_iter iter2 )
+ : m_iter1( std::move( iter1 ) )
+ , m_iter2( std::move( iter2 ) )
{}
// forward iterator interface
- virtual ref_type operator*() { return ds_detail::zip_traits<T1,T2>::tuple_merge( **m_iter1, **m_iter2 ); }
- virtual void operator++() { ++(*m_iter1); ++(*m_iter2); }
+ ref_type operator*() const { return ds_detail::zip_traits<sample1,sample2>::tuple_merge( *m_iter1, *m_iter2 ); }
+ void operator++() { ++m_iter1; ++m_iter2; }
private:
// Data members
- ds1_iter_ptr m_iter1;
- ds2_iter_ptr m_iter2;
+ dataset1_iter m_iter1;
+ dataset2_iter m_iter2;
};
-public:
- enum { arity = boost::decay<DS1>::type::arity + boost::decay<DS2>::type::arity };
-
//! Constructor
//!
//! The datasets are moved and not copied.
- zip( DS1&& ds1, DS2&& ds2, data::size_t size )
- : m_ds1( std::forward<DS1>( ds1 ) )
- , m_ds2( std::forward<DS2>( ds2 ) )
+ zip( DataSet1&& ds1, DataSet2&& ds2, data::size_t size )
+ : m_ds1( std::forward<DataSet1>( ds1 ) )
+ , m_ds2( std::forward<DataSet2>( ds2 ) )
, m_size( size )
{}
//! Move constructor
zip( zip&& j )
- : m_ds1( std::forward<DS1>( j.m_ds1 ) )
- , m_ds2( std::forward<DS2>( j.m_ds2 ) )
+ : m_ds1( std::forward<DataSet1>( j.m_ds1 ) )
+ , m_ds2( std::forward<DataSet2>( j.m_ds2 ) )
, m_size( j.m_size )
{}
// dataset interface
- virtual data::size_t size() const { return m_size; }
- virtual iter_ptr begin() const { return boost::make_shared<iterator>( m_ds1.begin(), m_ds2.begin() ); }
+ data::size_t size() const { return m_size; }
+ iterator begin() const { return iterator( m_ds1.begin(), m_ds2.begin() ); }
private:
// Data members
- DS1 m_ds1;
- DS2 m_ds2;
+ DataSet1 m_ds1;
+ DataSet2 m_ds2;
data::size_t m_size;
};
//____________________________________________________________________________//
//! Zipped datasets results in a dataset.
-template<typename DS1, typename DS2>
-struct is_dataset<zip<DS1,DS2> > : mpl::true_ {};
+template<typename DataSet1, typename DataSet2>
+struct is_dataset<zip<DataSet1,DataSet2>> : mpl::true_ {};
//____________________________________________________________________________//
namespace ds_detail {
//! Handles the sise of the resulting zipped dataset.
-template<typename DS1, typename DS2>
+template<typename DataSet1, typename DataSet2>
inline data::size_t
-zip_size( DS1&& ds1, DS2&& ds2 )
+zip_size( DataSet1&& ds1, DataSet2&& ds2 )
{
data::size_t ds1_size = ds1.size();
data::size_t ds2_size = ds2.size();
@@ -190,44 +187,45 @@ struct zip {
} // namespace result_of
-
//____________________________________________________________________________//
-
//! Overload operator for zip support
-template<typename DS1, typename DS2>
-inline typename boost::lazy_enable_if_c<is_dataset<DS1>::value && is_dataset<DS2>::value,
- result_of::zip<mpl::identity<DS1>,mpl::identity<DS2>>
+template<typename DataSet1, typename DataSet2>
+inline typename boost::lazy_enable_if_c<is_dataset<DataSet1>::value && is_dataset<DataSet2>::value,
+ result_of::zip<mpl::identity<DataSet1>,mpl::identity<DataSet2>>
>::type
-operator^( DS1&& ds1, DS2&& ds2 )
+operator^( DataSet1&& ds1, DataSet2&& ds2 )
{
- return zip<DS1,DS2>( std::forward<DS1>( ds1 ), std::forward<DS2>( ds2 ), ds_detail::zip_size( ds1, ds2 ) );
+ return zip<DataSet1,DataSet2>( std::forward<DataSet1>( ds1 ),
+ std::forward<DataSet2>( ds2 ),
+ ds_detail::zip_size( ds1, ds2 ) );
}
+//____________________________________________________________________________//
+
//! @overload boost::unit_test::data::monomorphic::operator^()
-template<typename DS1, typename DS2>
-inline typename boost::lazy_enable_if_c<is_dataset<DS1>::value && !is_dataset<DS2>::value,
- result_of::zip<mpl::identity<DS1>,data::result_of::make<DS2>>
+template<typename DataSet1, typename DataSet2>
+inline typename boost::lazy_enable_if_c<is_dataset<DataSet1>::value && !is_dataset<DataSet2>::value,
+ result_of::zip<mpl::identity<DataSet1>,data::result_of::make<DataSet2>>
>::type
-operator^( DS1&& ds1, DS2&& ds2 )
+operator^( DataSet1&& ds1, DataSet2&& ds2 )
{
- return std::forward<DS1>(ds1) ^ data::make(std::forward<DS2>(ds2));
+ return std::forward<DataSet1>( ds1 ) ^ data::make( std::forward<DataSet2>( ds2 ) );
}
+//____________________________________________________________________________//
+
//! @overload boost::unit_test::data::monomorphic::operator^()
-template<typename DS1, typename DS2>
-inline typename boost::lazy_enable_if_c<!is_dataset<DS1>::value && is_dataset<DS2>::value,
- result_of::zip<data::result_of::make<DS1>,mpl::identity<DS2>>
+template<typename DataSet1, typename DataSet2>
+inline typename boost::lazy_enable_if_c<!is_dataset<DataSet1>::value && is_dataset<DataSet2>::value,
+ result_of::zip<data::result_of::make<DataSet1>,mpl::identity<DataSet2>>
>::type
-operator^( DS1&& ds1, DS2&& ds2 )
+operator^( DataSet1&& ds1, DataSet2&& ds2 )
{
- return data::make(std::forward<DS1>(ds1)) ^ std::forward<DS2>(ds2);
+ return data::make( std::forward<DataSet1>( ds1 ) ) ^ std::forward<DataSet2>( ds2 );
}
-//____________________________________________________________________________//
-
} // namespace monomorphic
-
} // namespace data
} // namespace unit_test
} // namespace boost
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-23 10:09:45 +0000