ceph/src/boost/boost/test/data/monomorphic/zip.hpp

   1 //  (C) Copyright Gennadiy Rozental 2001.
   2 //  Distributed under the Boost Software License, Version 1.0.
   3 //  (See accompanying file LICENSE_1_0.txt or copy at
   4 //  http://www.boost.org/LICENSE_1_0.txt)
   5
   6 //  See http://www.boost.org/libs/test for the library home page.
   7 //
   8 /// @file
   9 /// Defines monomorphic dataset based on zipping of 2 other monomorphic datasets
  10 // ***************************************************************************
  11
  12 #ifndef BOOST_TEST_DATA_MONOMORPHIC_ZIP_HPP_102211GER
  13 #define BOOST_TEST_DATA_MONOMORPHIC_ZIP_HPP_102211GER
  14
  15 // Boost.Test
  16 #include <boost/test/data/config.hpp>
  17
  18 #if !defined(BOOST_TEST_NO_ZIP_COMPOSITION_AVAILABLE) || defined(BOOST_TEST_DOXYGEN_DOC__)
  19
  20 #include <boost/test/data/monomorphic/fwd.hpp>
  21 #include <boost/test/data/monomorphic/sample_merge.hpp>
  22
  23 #include <boost/test/detail/suppress_warnings.hpp>
  24
  25
  26 namespace boost {
  27 namespace unit_test {
  28 namespace data {
  29 namespace monomorphic {
  30
  31 // ************************************************************************** //
  32 // **************                       zip                    ************** //
  33 // ************************************************************************** //
  34
  35 //! Zip datasets
  36 //!
  37 //! A zip of two datasets is a dataset whose arity is the sum of the operand datasets arity. The size is given by
  38 //! the function creating the instance (see @c operator^ on datasets).
  39 template<typename DataSet1, typename DataSet2>
  40 class zip {
  41     typedef typename boost::decay<DataSet1>::type   dataset1_decay;
  42     typedef typename boost::decay<DataSet2>::type   dataset2_decay;
  43
  44     typedef typename dataset1_decay::iterator       dataset1_iter;
  45     typedef typename dataset2_decay::iterator       dataset2_iter;
  46
  47 public:
  48     enum { arity = dataset1_decay::arity + dataset2_decay::arity };
  49
  50     struct iterator {
  51         // Constructor
  52         explicit    iterator( dataset1_iter iter1, dataset2_iter iter2 )
  53         : m_iter1( std::move( iter1 ) )
  54         , m_iter2( std::move( iter2 ) )
  55         {}
  56
  57         using iterator_sample = decltype(
  58             sample_merge( *std::declval<dataset1_iter>(),
  59                           *std::declval<dataset2_iter>()) );
  60
  61         // forward iterator interface
  62         auto            operator*() const -> iterator_sample {
  63             return sample_merge( *m_iter1, *m_iter2 );
  64         }
  65         void            operator++()        { ++m_iter1; ++m_iter2; }
  66
  67     private:
  68         // Data members
  69         dataset1_iter   m_iter1;
  70         dataset2_iter   m_iter2;
  71     };
  72
  73     typedef typename iterator::iterator_sample   sample;
  74
  75     //! Constructor
  76     //!
  77     //! The datasets are moved and not copied.
  78     zip( DataSet1&& ds1, DataSet2&& ds2, data::size_t size )
  79     : m_ds1( std::forward<DataSet1>( ds1 ) )
  80     , m_ds2( std::forward<DataSet2>( ds2 ) )
  81     , m_size( size )
  82     {}
  83
  84     //! Move constructor
  85     zip( zip&& j )
  86     : m_ds1( std::forward<DataSet1>( j.m_ds1 ) )
  87     , m_ds2( std::forward<DataSet2>( j.m_ds2 ) )
  88     , m_size( j.m_size )
  89     {}
  90
  91     // dataset interface
  92     data::size_t    size() const    { return m_size; }
  93     iterator        begin() const   { return iterator( m_ds1.begin(), m_ds2.begin() ); }
  94
  95 private:
  96     // Data members
  97     DataSet1        m_ds1;
  98     DataSet2        m_ds2;
  99     data::size_t    m_size;
 100 };
 101
 102 //____________________________________________________________________________//
 103
 104 //! Zipped datasets results in a dataset.
 105 template<typename DataSet1, typename DataSet2>
 106 struct is_dataset<zip<DataSet1,DataSet2>> : mpl::true_ {};
 107
 108 //____________________________________________________________________________//
 109
 110 namespace ds_detail {
 111
 112 //! Handles the sise of the resulting zipped dataset.
 113 template<typename DataSet1, typename DataSet2>
 114 inline data::size_t
 115 zip_size( DataSet1&& ds1, DataSet2&& ds2 )
 116 {
 117     data::size_t ds1_size = ds1.size();
 118     data::size_t ds2_size = ds2.size();
 119
 120     if( ds1_size == ds2_size )
 121         return ds1_size;
 122
 123     if( ds1_size == 1 || ds1_size.is_inf() )
 124         return ds2_size;
 125
 126     if( ds2_size == 1  || ds2_size.is_inf() )
 127         return ds1_size;
 128
 129     BOOST_TEST_DS_ERROR( "Can't zip datasets of different sizes" );
 130 }
 131
 132 } // namespace ds_detail
 133
 134 //____________________________________________________________________________//
 135
 136 namespace result_of {
 137
 138 //! Result type of the zip operator.
 139 template<typename DS1Gen, typename DS2Gen>
 140 struct zip {
 141     typedef monomorphic::zip<typename DS1Gen::type,typename DS2Gen::type> type;
 142 };
 143
 144 } // namespace result_of
 145
 146 //____________________________________________________________________________//
 147
 148 //! Overload operator for zip support
 149 template<typename DataSet1, typename DataSet2>
 150 inline typename boost::lazy_enable_if_c<is_dataset<DataSet1>::value && is_dataset<DataSet2>::value,
 151                                         result_of::zip<mpl::identity<DataSet1>,mpl::identity<DataSet2>>
 152 >::type
 153 operator^( DataSet1&& ds1, DataSet2&& ds2 )
 154 {
 155     return zip<DataSet1,DataSet2>( std::forward<DataSet1>( ds1 ),
 156                                    std::forward<DataSet2>( ds2 ),
 157                                    ds_detail::zip_size( ds1, ds2 ) );
 158 }
 159
 160 //____________________________________________________________________________//
 161
 162 //! @overload boost::unit_test::data::monomorphic::operator^()
 163 template<typename DataSet1, typename DataSet2>
 164 inline typename boost::lazy_enable_if_c<is_dataset<DataSet1>::value && !is_dataset<DataSet2>::value,
 165                                         result_of::zip<mpl::identity<DataSet1>,data::result_of::make<DataSet2>>
 166 >::type
 167 operator^( DataSet1&& ds1, DataSet2&& ds2 )
 168 {
 169     return std::forward<DataSet1>( ds1 ) ^ data::make( std::forward<DataSet2>( ds2 ) );
 170 }
 171
 172 //____________________________________________________________________________//
 173
 174 //! @overload boost::unit_test::data::monomorphic::operator^()
 175 template<typename DataSet1, typename DataSet2>
 176 inline typename boost::lazy_enable_if_c<!is_dataset<DataSet1>::value && is_dataset<DataSet2>::value,
 177                                         result_of::zip<data::result_of::make<DataSet1>,mpl::identity<DataSet2>>
 178 >::type
 179 operator^( DataSet1&& ds1, DataSet2&& ds2 )
 180 {
 181     return data::make( std::forward<DataSet1>( ds1 ) ) ^ std::forward<DataSet2>( ds2 );
 182 }
 183
 184 } // namespace monomorphic
 185 } // namespace data
 186 } // namespace unit_test
 187 } // namespace boost
 188
 189 #include <boost/test/detail/enable_warnings.hpp>
 190
 191 #endif // BOOST_TEST_NO_ZIP_COMPOSITION_AVAILABLE
 192
 193 #endif // BOOST_TEST_DATA_MONOMORPHIC_ZIP_HPP_102211GER
 194