boost/ptr_container/ptr_inserter.hpp

   1 //
   2 // Boost.Pointer Container
   3 //
   4 //  Copyright Thorsten Ottosen 2008. Use, modification and
   5 //  distribution is subject to the Boost Software License, Version
   6 //  1.0. (See accompanying file LICENSE_1_0.txt or copy at
   7 //  http://www.boost.org/LICENSE_1_0.txt)
   8 //
   9 // For more information, see http://www.boost.org/libs/ptr_container/
  10 //
  11
  12 #ifndef BOOST_PTR_CONTAINER_PTR_INSERTER_HPP
  13 #define BOOST_PTR_CONTAINER_PTR_INSERTER_HPP
  14
  15 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
  16     #pragma once
  17 #endif
  18
  19 #include <boost/config.hpp>
  20 #include <iterator>
  21 #include <memory>
  22
  23 namespace boost
  24 {
  25 namespace ptr_container
  26 {
  27     template< class PtrContainer >
  28     class ptr_back_insert_iterator;
  29
  30     template< class PtrContainer >
  31     class ptr_front_insert_iterator;
  32
  33     template< class PtrContainer >
  34     class ptr_insert_iterator;
  35
  36     template< class PtrContainer >
  37     ptr_back_insert_iterator<PtrContainer>
  38     ptr_back_inserter( PtrContainer& cont );
  39
  40     template< class PtrContainer >
  41     ptr_front_insert_iterator<PtrContainer>
  42     ptr_front_inserter( PtrContainer& cont );
  43
  44     template< class PtrContainer >
  45     ptr_insert_iterator<PtrContainer>
  46     ptr_inserter( PtrContainer& cont, typename PtrContainer::iterator before );
  47
  48     //////////////////////////////////////////////////////////////////////////
  49     // Implementation
  50     //////////////////////////////////////////////////////////////////////////
  51
  52
  53     template< class PtrContainer >
  54     class ptr_back_insert_iterator :
  55         public std::iterator<std::output_iterator_tag,void,void,void,void>
  56     {
  57     public:
  58         typedef PtrContainer container_type;
  59
  60     public:
  61         explicit ptr_back_insert_iterator( PtrContainer& cont )
  62         : container(&cont)
  63         { }
  64
  65         ptr_back_insert_iterator&
  66         operator=( typename PtrContainer::value_type r )
  67         {
  68             typename PtrContainer::value_type obj = 0;
  69             if( r != 0 )
  70                 obj = container_type::clone_allocator_type::allocate_clone(*r);
  71
  72             container->push_back( obj );
  73             return *this;
  74         }
  75
  76         template< class T >
  77         ptr_back_insert_iterator&
  78         operator=( std::auto_ptr<T> r )
  79         {
  80             container->push_back( r );
  81             return *this;
  82         }
  83
  84         ptr_back_insert_iterator&
  85         operator=( typename PtrContainer::const_reference r )
  86         {
  87             container->push_back( container_type::clone_allocator_type::
  88                                   allocate_clone(r) );
  89             return *this;
  90         }
  91
  92         ptr_back_insert_iterator& operator*()
  93         {
  94             return *this;
  95         }
  96
  97         ptr_back_insert_iterator& operator++()
  98         {
  99             return *this;
 100         }
 101
 102         ptr_back_insert_iterator operator++(int)
 103         {
 104             return *this;
 105         }
 106
 107     protected:
 108         PtrContainer* container;
 109     };
 110
 111
 112
 113     template< class PtrContainer >
 114     class ptr_front_insert_iterator :
 115         public std::iterator<std::output_iterator_tag,void,void,void,void>
 116     {
 117     public:
 118         typedef PtrContainer container_type;
 119
 120     public:
 121         explicit ptr_front_insert_iterator( PtrContainer& cont )
 122         : container(&cont)
 123         { }
 124
 125         ptr_front_insert_iterator&
 126         operator=( typename PtrContainer::value_type r )
 127         {
 128             typename PtrContainer::value_type obj = 0;
 129             if( r != 0 )
 130                 obj = container_type::clone_allocator_type::allocate_clone(*r);
 131
 132             container->push_front( obj );
 133             return *this;
 134         }
 135
 136         template< class T >
 137         ptr_front_insert_iterator&
 138         operator=( std::auto_ptr<T> r )
 139         {
 140             container->push_front( r );
 141             return *this;
 142         }
 143
 144         ptr_front_insert_iterator&
 145         operator=( typename PtrContainer::const_reference r )
 146         {
 147             container->push_front( container_type::clone_allocator_type::
 148                                    allocate_clone(r) );
 149             return *this;
 150         }
 151
 152         ptr_front_insert_iterator& operator*()
 153         {
 154             return *this;
 155         }
 156
 157         ptr_front_insert_iterator& operator++()
 158         {
 159             return *this;
 160         }
 161
 162         ptr_front_insert_iterator operator++(int)
 163         {
 164             return *this;
 165         }
 166
 167     protected:
 168         PtrContainer* container;
 169     };
 170
 171
 172
 173     template< class PtrContainer >
 174     class ptr_insert_iterator :
 175         public std::iterator<std::output_iterator_tag,void,void,void,void>
 176     {
 177     public:
 178         typedef PtrContainer container_type;
 179
 180     public:
 181         ptr_insert_iterator( PtrContainer& cont,
 182                                typename PtrContainer::iterator before )
 183         : container(&cont), iter(before)
 184         { }
 185
 186         ptr_insert_iterator&
 187         operator=( typename PtrContainer::value_type r )
 188         {
 189             typename PtrContainer::value_type obj = 0;
 190             if( r != 0 )
 191                 obj = container_type::clone_allocator_type::allocate_clone(*r);
 192
 193             iter = container->insert( iter, obj );
 194             return *this;
 195         }
 196
 197         template< class T >
 198         ptr_insert_iterator&
 199         operator=( std::auto_ptr<T> r )
 200         {
 201             iter = container->insert( iter, r );
 202             return *this;
 203         }
 204
 205         ptr_insert_iterator&
 206         operator=( typename PtrContainer::const_reference r )
 207         {
 208             iter = container->insert( iter, container_type::clone_allocator_type::
 209                                             allocate_clone(r) );
 210             return *this;
 211         }
 212
 213         ptr_insert_iterator& operator*()
 214         {
 215             return *this;
 216         }
 217
 218         ptr_insert_iterator& operator++()
 219         {
 220             return *this;
 221         }
 222
 223         ptr_insert_iterator operator++(int)
 224         {
 225             return *this;
 226         }
 227
 228     protected:
 229         PtrContainer*                    container;
 230         typename PtrContainer::iterator  iter;
 231     };
 232
 233     template< class PtrContainer >
 234     inline ptr_back_insert_iterator<PtrContainer>
 235     ptr_back_inserter( PtrContainer& cont )
 236     {
 237         return ptr_back_insert_iterator<PtrContainer>( cont );
 238     }
 239
 240     template< class PtrContainer >
 241     inline ptr_front_insert_iterator<PtrContainer>
 242     ptr_front_inserter( PtrContainer& cont )
 243     {
 244         return ptr_front_insert_iterator<PtrContainer>( cont );
 245     }
 246
 247     template< class PtrContainer >
 248     inline ptr_insert_iterator<PtrContainer>
 249     ptr_inserter( PtrContainer& cont,
 250                     typename PtrContainer::iterator before )
 251     {
 252         return ptr_insert_iterator<PtrContainer>( cont, before );
 253     }
 254
 255 } // namespace 'ptr_container'
 256 } // namespace 'boost'
 257
 258 #endif