epoc32/include/stdapis/boost/assign/list_inserter.hpp
author William Roberts <williamr@symbian.org>
Tue, 16 Mar 2010 16:12:26 +0000
branchSymbian2
changeset 2 2fe1408b6811
permissions -rw-r--r--
Final list of Symbian^2 public API header files
williamr@2
     1
// Boost.Assign library
williamr@2
     2
//
williamr@2
     3
//  Copyright Thorsten Ottosen 2003-2004. Use, modification and
williamr@2
     4
//  distribution is subject to the Boost Software License, Version
williamr@2
     5
//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
williamr@2
     6
//  http://www.boost.org/LICENSE_1_0.txt)
williamr@2
     7
//
williamr@2
     8
// For more information, see http://www.boost.org/libs/assign/
williamr@2
     9
//
williamr@2
    10
williamr@2
    11
#ifndef BOOST_ASSIGN_LIST_INSERTER_HPP
williamr@2
    12
#define BOOST_ASSIGN_LIST_INSERTER_HPP
williamr@2
    13
williamr@2
    14
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
williamr@2
    15
# pragma once
williamr@2
    16
#endif
williamr@2
    17
williamr@2
    18
#include <boost/detail/workaround.hpp>
williamr@2
    19
williamr@2
    20
#include <boost/mpl/if.hpp>
williamr@2
    21
#include <boost/type_traits/is_same.hpp>
williamr@2
    22
#include <boost/range/begin.hpp>
williamr@2
    23
#include <boost/range/end.hpp>
williamr@2
    24
#include <boost/config.hpp>
williamr@2
    25
#include <cstddef>
williamr@2
    26
williamr@2
    27
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
williamr@2
    28
#include <boost/preprocessor/repetition/enum_params.hpp>
williamr@2
    29
#include <boost/preprocessor/cat.hpp>
williamr@2
    30
#include <boost/preprocessor/iteration/local.hpp>
williamr@2
    31
#include <boost/preprocessor/arithmetic/inc.hpp>
williamr@2
    32
williamr@2
    33
namespace boost
williamr@2
    34
{
williamr@2
    35
namespace assign_detail
williamr@2
    36
{
williamr@2
    37
    template< class T >
williamr@2
    38
    struct repeater
williamr@2
    39
    {
williamr@2
    40
        std::size_t  sz;
williamr@2
    41
        T            val;
williamr@2
    42
williamr@2
    43
        repeater( std::size_t sz, T r ) : sz( sz ), val( r )
williamr@2
    44
        { }
williamr@2
    45
    };
williamr@2
    46
    
williamr@2
    47
    template< class Fun >
williamr@2
    48
    struct fun_repeater
williamr@2
    49
    {
williamr@2
    50
        std::size_t  sz;
williamr@2
    51
        Fun          val;
williamr@2
    52
        
williamr@2
    53
        fun_repeater( std::size_t sz, Fun r ) : sz( sz ), val( r )
williamr@2
    54
        { }
williamr@2
    55
    };
williamr@2
    56
    
williamr@2
    57
    template< class C >
williamr@2
    58
    class call_push_back
williamr@2
    59
    {
williamr@2
    60
        C& c_;
williamr@2
    61
    public:
williamr@2
    62
        call_push_back( C& c ) : c_( c )
williamr@2
    63
        { }
williamr@2
    64
        
williamr@2
    65
        template< class T >
williamr@2
    66
        void operator()( T r ) 
williamr@2
    67
        {
williamr@2
    68
            c_.push_back( r );
williamr@2
    69
        }
williamr@2
    70
    };
williamr@2
    71
    
williamr@2
    72
    template< class C >
williamr@2
    73
    class call_push_front
williamr@2
    74
    {
williamr@2
    75
        C& c_;
williamr@2
    76
    public:
williamr@2
    77
        call_push_front( C& c ) : c_( c )
williamr@2
    78
        { }
williamr@2
    79
        
williamr@2
    80
        template< class T >
williamr@2
    81
        void operator()( T r ) 
williamr@2
    82
        {
williamr@2
    83
            c_.push_front( r );
williamr@2
    84
        }
williamr@2
    85
    };
williamr@2
    86
    
williamr@2
    87
    template< class C >
williamr@2
    88
    class call_push
williamr@2
    89
    {
williamr@2
    90
        C& c_;
williamr@2
    91
    public:
williamr@2
    92
        call_push( C& c ) : c_( c )
williamr@2
    93
        { }
williamr@2
    94
    
williamr@2
    95
        template< class T >
williamr@2
    96
        void operator()( T r ) 
williamr@2
    97
        {
williamr@2
    98
            c_.push( r );
williamr@2
    99
        }
williamr@2
   100
    };
williamr@2
   101
    
williamr@2
   102
    template< class C >
williamr@2
   103
    class call_insert
williamr@2
   104
    {
williamr@2
   105
        C& c_;
williamr@2
   106
    public:
williamr@2
   107
        call_insert( C& c ) : c_( c )
williamr@2
   108
        { }
williamr@2
   109
    
williamr@2
   110
        template< class T >
williamr@2
   111
        void operator()( T r ) 
williamr@2
   112
        {
williamr@2
   113
            c_.insert( r );
williamr@2
   114
        }
williamr@2
   115
    };
williamr@2
   116
williamr@2
   117
    template< class C >
williamr@2
   118
    class call_add_edge
williamr@2
   119
    {
williamr@2
   120
        C& c_;
williamr@2
   121
    public:
williamr@2
   122
        call_add_edge( C& c ) : c_(c)
williamr@2
   123
        { }
williamr@2
   124
williamr@2
   125
        template< class T >
williamr@2
   126
        void operator()( T l, T r )
williamr@2
   127
        {
williamr@2
   128
            add_edge( l, r, c_ );
williamr@2
   129
        }
williamr@2
   130
williamr@2
   131
        template< class T, class EP >
williamr@2
   132
        void operator()( T l, T r, const EP& ep )
williamr@2
   133
        {
williamr@2
   134
            add_edge( l, r, ep, c_ );
williamr@2
   135
        }
williamr@2
   136
williamr@2
   137
    };
williamr@2
   138
    
williamr@2
   139
    struct forward_n_arguments {};
williamr@2
   140
    
williamr@2
   141
} // namespace 'assign_detail'
williamr@2
   142
williamr@2
   143
namespace assign
williamr@2
   144
{
williamr@2
   145
williamr@2
   146
    template< class T >
williamr@2
   147
    inline assign_detail::repeater<T>
williamr@2
   148
    repeat( std::size_t sz, T r )
williamr@2
   149
    {
williamr@2
   150
        return assign_detail::repeater<T>( sz, r );
williamr@2
   151
    }
williamr@2
   152
    
williamr@2
   153
    template< class Function >
williamr@2
   154
    inline assign_detail::fun_repeater<Function>
williamr@2
   155
    repeat_fun( std::size_t sz, Function r )
williamr@2
   156
    {
williamr@2
   157
        return assign_detail::fun_repeater<Function>( sz, r );
williamr@2
   158
    }
williamr@2
   159
    
williamr@2
   160
williamr@2
   161
    template< class Function, class Argument = assign_detail::forward_n_arguments > 
williamr@2
   162
    class list_inserter
williamr@2
   163
    {
williamr@2
   164
        struct single_arg_type {};
williamr@2
   165
        struct n_arg_type      {};
williamr@2
   166
williamr@2
   167
        typedef BOOST_DEDUCED_TYPENAME mpl::if_c< is_same<Argument,assign_detail::forward_n_arguments>::value,
williamr@2
   168
                                                  n_arg_type,
williamr@2
   169
                                                  single_arg_type >::type arg_type;  
williamr@2
   170
            
williamr@2
   171
    public:
williamr@2
   172
        
williamr@2
   173
        list_inserter( Function fun ) : insert_( fun )
williamr@2
   174
        {}
williamr@2
   175
        
williamr@2
   176
        template< class Function2, class Arg >
williamr@2
   177
        list_inserter( const list_inserter<Function2,Arg>& r ) 
williamr@2
   178
        : insert_( r.fun_private() ) 
williamr@2
   179
        {}
williamr@2
   180
williamr@2
   181
        list_inserter( const list_inserter& r ) : insert_( r.insert_ )
williamr@2
   182
        {}
williamr@2
   183
williamr@2
   184
        list_inserter& operator()()
williamr@2
   185
        {
williamr@2
   186
            insert_( Argument() );
williamr@2
   187
            return *this;
williamr@2
   188
        }
williamr@2
   189
        
williamr@2
   190
        template< class T >
williamr@2
   191
        list_inserter& operator=( const T& r )
williamr@2
   192
        {
williamr@2
   193
            insert_( r );
williamr@2
   194
            return *this;
williamr@2
   195
        }
williamr@2
   196
        
williamr@2
   197
        template< class T >
williamr@2
   198
        list_inserter& operator=( assign_detail::repeater<T> r )
williamr@2
   199
        {
williamr@2
   200
            return operator,( r );
williamr@2
   201
        }
williamr@2
   202
        
williamr@2
   203
        template< class Nullary_function >
williamr@2
   204
        list_inserter& operator=( const assign_detail::fun_repeater<Nullary_function>& r )
williamr@2
   205
        {
williamr@2
   206
            //BOOST_STATIC_ASSERT( function_traits<Nullary_function>::arity == 0 );
williamr@2
   207
            //BOOST_STATIC_ASSERT( is_convertible< BOOST_DEDUCED_TYPENAME function_traits<
williamr@2
   208
            //                      Nullary_function>::result_type >,T>::value );
williamr@2
   209
williamr@2
   210
            return operator,( r );
williamr@2
   211
        }
williamr@2
   212
        
williamr@2
   213
        template< class T >
williamr@2
   214
        list_inserter& operator,( const T& r )
williamr@2
   215
        {
williamr@2
   216
            insert_( r  );
williamr@2
   217
            return *this;
williamr@2
   218
        }
williamr@2
   219
williamr@2
   220
#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
williamr@2
   221
        template< class T >
williamr@2
   222
        list_inserter& operator,( const assign_detail::repeater<T> & r )
williamr@2
   223
        {
williamr@2
   224
            return repeat( r.sz, r.val ); 
williamr@2
   225
        }
williamr@2
   226
#else
williamr@2
   227
        template< class T >
williamr@2
   228
        list_inserter& operator,( assign_detail::repeater<T> r )
williamr@2
   229
        {
williamr@2
   230
            return repeat( r.sz, r.val ); 
williamr@2
   231
        }
williamr@2
   232
#endif
williamr@2
   233
        
williamr@2
   234
        template< class Nullary_function >
williamr@2
   235
        list_inserter& operator,( const assign_detail::fun_repeater<Nullary_function>& r )
williamr@2
   236
        {
williamr@2
   237
            return repeat_fun( r.sz, r.val ); 
williamr@2
   238
        }
williamr@2
   239
williamr@2
   240
        template< class T >
williamr@2
   241
        list_inserter& repeat( std::size_t sz, T r )
williamr@2
   242
        {
williamr@2
   243
            std::size_t i = 0;
williamr@2
   244
            while( i++ != sz )
williamr@2
   245
                insert_( r );
williamr@2
   246
            return *this;
williamr@2
   247
        }
williamr@2
   248
        
williamr@2
   249
        template< class Nullary_function >
williamr@2
   250
        list_inserter& repeat_fun( std::size_t sz, Nullary_function fun )
williamr@2
   251
        {
williamr@2
   252
            std::size_t i = 0;
williamr@2
   253
            while( i++ != sz )
williamr@2
   254
                insert_( fun() );
williamr@2
   255
            return *this;
williamr@2
   256
        }
williamr@2
   257
williamr@2
   258
        template< class SinglePassIterator >
williamr@2
   259
        list_inserter& range( SinglePassIterator first, 
williamr@2
   260
                              SinglePassIterator last )
williamr@2
   261
        {
williamr@2
   262
            for( ; first != last; ++first )
williamr@2
   263
                insert_( *first );
williamr@2
   264
            return *this;
williamr@2
   265
        }
williamr@2
   266
        
williamr@2
   267
        template< class SinglePassRange >
williamr@2
   268
        list_inserter& range( const SinglePassRange& r )
williamr@2
   269
        {
williamr@2
   270
            return range( boost::begin(r), boost::end(r) );
williamr@2
   271
        }
williamr@2
   272
        
williamr@2
   273
        template< class T >
williamr@2
   274
        list_inserter& operator()( const T& t )
williamr@2
   275
        {
williamr@2
   276
            insert_( t );
williamr@2
   277
            return *this;
williamr@2
   278
        }
williamr@2
   279
williamr@2
   280
#ifndef BOOST_ASSIGN_MAX_PARAMS // use user's value
williamr@2
   281
#define BOOST_ASSIGN_MAX_PARAMS 5        
williamr@2
   282
#endif
williamr@2
   283
#define BOOST_ASSIGN_MAX_PARAMETERS (BOOST_ASSIGN_MAX_PARAMS - 1)
williamr@2
   284
#define BOOST_ASSIGN_PARAMS1(n) BOOST_PP_ENUM_PARAMS(n, class T)
williamr@2
   285
#define BOOST_ASSIGN_PARAMS2(n) BOOST_PP_ENUM_BINARY_PARAMS(n, T, const& t)
williamr@2
   286
#define BOOST_ASSIGN_PARAMS3(n) BOOST_PP_ENUM_PARAMS(n, t)
williamr@2
   287
        
williamr@2
   288
#define BOOST_PP_LOCAL_LIMITS (1, BOOST_ASSIGN_MAX_PARAMETERS)
williamr@2
   289
#define BOOST_PP_LOCAL_MACRO(n) \
williamr@2
   290
    template< class T, BOOST_ASSIGN_PARAMS1(n) > \
williamr@2
   291
    list_inserter& operator()(T t, BOOST_ASSIGN_PARAMS2(n) ) \
williamr@2
   292
        { \
williamr@2
   293
            BOOST_PP_CAT(insert, BOOST_PP_INC(n))(t, BOOST_ASSIGN_PARAMS3(n), arg_type()); \
williamr@2
   294
            return *this; \
williamr@2
   295
        } \
williamr@2
   296
        /**/
williamr@2
   297
williamr@2
   298
#include BOOST_PP_LOCAL_ITERATE()
williamr@2
   299
        
williamr@2
   300
williamr@2
   301
#define BOOST_PP_LOCAL_LIMITS (1, BOOST_ASSIGN_MAX_PARAMETERS)
williamr@2
   302
#define BOOST_PP_LOCAL_MACRO(n) \
williamr@2
   303
    template< class T, BOOST_ASSIGN_PARAMS1(n) > \
williamr@2
   304
    void BOOST_PP_CAT(insert, BOOST_PP_INC(n))(T const& t, BOOST_ASSIGN_PARAMS2(n), single_arg_type) \
williamr@2
   305
    { \
williamr@2
   306
        insert_( Argument(t, BOOST_ASSIGN_PARAMS3(n) )); \
williamr@2
   307
    } \
williamr@2
   308
    /**/
williamr@2
   309
        
williamr@2
   310
#include BOOST_PP_LOCAL_ITERATE()
williamr@2
   311
williamr@2
   312
#define BOOST_PP_LOCAL_LIMITS (1, BOOST_ASSIGN_MAX_PARAMETERS)
williamr@2
   313
#define BOOST_PP_LOCAL_MACRO(n) \
williamr@2
   314
    template< class T, BOOST_ASSIGN_PARAMS1(n) > \
williamr@2
   315
    void BOOST_PP_CAT(insert, BOOST_PP_INC(n))(T const& t, BOOST_ASSIGN_PARAMS2(n), n_arg_type) \
williamr@2
   316
    { \
williamr@2
   317
        insert_(t, BOOST_ASSIGN_PARAMS3(n) ); \
williamr@2
   318
    } \
williamr@2
   319
    /**/
williamr@2
   320
        
williamr@2
   321
#include BOOST_PP_LOCAL_ITERATE()
williamr@2
   322
williamr@2
   323
        
williamr@2
   324
        Function fun_private() const
williamr@2
   325
        {
williamr@2
   326
            return insert_;
williamr@2
   327
        }
williamr@2
   328
williamr@2
   329
    private:
williamr@2
   330
        
williamr@2
   331
        list_inserter& operator=( const list_inserter& );
williamr@2
   332
        Function insert_;
williamr@2
   333
    };
williamr@2
   334
    
williamr@2
   335
    template< class Function >
williamr@2
   336
    inline list_inserter< Function >
williamr@2
   337
    make_list_inserter( Function fun )
williamr@2
   338
    {
williamr@2
   339
        return list_inserter< Function >( fun );
williamr@2
   340
    }
williamr@2
   341
    
williamr@2
   342
    template< class Function, class Argument >
williamr@2
   343
    inline list_inserter<Function,Argument>
williamr@2
   344
    make_list_inserter( Function fun, Argument* )
williamr@2
   345
    {
williamr@2
   346
        return list_inserter<Function,Argument>( fun );
williamr@2
   347
    }
williamr@2
   348
williamr@2
   349
    template< class C >
williamr@2
   350
    inline list_inserter< assign_detail::call_push_back<C>, 
williamr@2
   351
                          BOOST_DEDUCED_TYPENAME C::value_type >
williamr@2
   352
    push_back( C& c )
williamr@2
   353
    {
williamr@2
   354
        static BOOST_DEDUCED_TYPENAME C::value_type* p = 0;
williamr@2
   355
        return make_list_inserter( assign_detail::call_push_back<C>( c ), 
williamr@2
   356
                                   p );
williamr@2
   357
    }
williamr@2
   358
    
williamr@2
   359
    template< class C >
williamr@2
   360
    inline list_inserter< assign_detail::call_push_front<C>,
williamr@2
   361
                          BOOST_DEDUCED_TYPENAME C::value_type >
williamr@2
   362
    push_front( C& c )
williamr@2
   363
    {
williamr@2
   364
        static BOOST_DEDUCED_TYPENAME C::value_type* p = 0;
williamr@2
   365
        return make_list_inserter( assign_detail::call_push_front<C>( c ),
williamr@2
   366
                                   p );
williamr@2
   367
    }
williamr@2
   368
williamr@2
   369
    template< class C >
williamr@2
   370
    inline list_inserter< assign_detail::call_insert<C>, 
williamr@2
   371
                          BOOST_DEDUCED_TYPENAME C::value_type >
williamr@2
   372
    insert( C& c )
williamr@2
   373
    {
williamr@2
   374
        static BOOST_DEDUCED_TYPENAME C::value_type* p = 0;
williamr@2
   375
        return make_list_inserter( assign_detail::call_insert<C>( c ),
williamr@2
   376
                                   p );
williamr@2
   377
    }
williamr@2
   378
williamr@2
   379
    template< class C >
williamr@2
   380
    inline list_inserter< assign_detail::call_push<C>, 
williamr@2
   381
                          BOOST_DEDUCED_TYPENAME C::value_type >
williamr@2
   382
    push( C& c )
williamr@2
   383
    {
williamr@2
   384
        static BOOST_DEDUCED_TYPENAME C::value_type* p = 0;
williamr@2
   385
        return make_list_inserter( assign_detail::call_push<C>( c ),
williamr@2
   386
                                   p );
williamr@2
   387
    }
williamr@2
   388
williamr@2
   389
    template< class C >
williamr@2
   390
    inline list_inserter< assign_detail::call_add_edge<C> >
williamr@2
   391
    add_edge( C& c )   
williamr@2
   392
    {
williamr@2
   393
        return make_list_inserter( assign_detail::call_add_edge<C>( c ) );
williamr@2
   394
    }
williamr@2
   395
    
williamr@2
   396
} // namespace 'assign'
williamr@2
   397
} // namespace 'boost'
williamr@2
   398
williamr@2
   399
#undef BOOST_ASSIGN_PARAMS1
williamr@2
   400
#undef BOOST_ASSIGN_PARAMS2
williamr@2
   401
#undef BOOST_ASSIGN_PARAMS3
williamr@2
   402
#undef BOOST_ASSIGN_MAX_PARAMETERS
williamr@2
   403
williamr@2
   404
#endif