
   return r;
}

//////////////////////////////////////////////////////////////////////////////
//
//                               uninitialized_fill_alloc
//
//////////////////////////////////////////////////////////////////////////////

//! <b>Effects</b>:
//!   \code
//!   for (; f!= l; ++r, ++f)
//!      allocator_traits::construct(a, &*r, *f);
//!   \endcode
//!
//! <b>Returns</b>: r
template
   <typename Allocator,
    typename F, // F models ForwardIterator
    typename T>
inline void uninitialized_fill_alloc(Allocator &a, F f, F l, const T &t)
{
   F back = f;
   BOOST_TRY{
      while (f!= l) {
         allocator_traits<Allocator>::construct(a, container_detail::iterator_to_raw_pointer(f), t);
         ++f;
      }
   }
   BOOST_CATCH(...){
      for (; back!= l; ++back){
         allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(back));
      }
      BOOST_RETHROW;
   }
   BOOST_CATCH_END
}


//////////////////////////////////////////////////////////////////////////////
//
//                               uninitialized_fill_alloc_n
//
//////////////////////////////////////////////////////////////////////////////

//! <b>Effects</b>:
//!   \code
//!   for (; n--; ++r, ++f)
//!      allocator_traits::construct(a, &*r, v);
//!   \endcode
//!
//! <b>Returns</b>: r
template
   <typename Allocator,
    typename T,
    typename F> // F models ForwardIterator
inline F uninitialized_fill_alloc_n(Allocator &a, const T &v, typename allocator_traits<Allocator>::difference_type n, F r)
{
   F back = r;
   BOOST_TRY{
      while (n--) {
         allocator_traits<Allocator>::construct(a, container
return r; 
 } 

 ////////////////////////////////////////////////////////////////////////////// 
 // 
 //                                uninitialized_fill_alloc 
 // 
 ////////////////////////////////////////////////////////////////////////////// 

 //! < b > Effects</b >: 
 //!    \code 
 //!    for (; f!= l; + + r, + + f) 
 //!       allocator_traits::construct(a, & * r, * f); 
 //!    \endcode 
 //! 
 //! < b > Returns</b >: r 
 template 
    < typename Allocator, 
     typename F, // farad model ForwardIterator 
     typename T > 
 inline void uninitialized_fill_alloc(Allocator & a, F f, F l, const T & t) 
 { 
    F back = f; 
    BOOST_TRY { 
       while (f!= l) { 
          allocator_traits < Allocator>::construct(a, container_detail::iterator_to_raw_pointer(f), t); 
          + + f; 
       } 
    } 
    BOOST_CATCH (...) { 
       for (; back!= l; + + back) { 
          allocator_traits < Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(back) ); 
       } 
       BOOST_RETHROW; 
    } 
    BOOST_CATCH_END 
 } 


 ////////////////////////////////////////////////////////////////////////////// 
 // 
 //                                uninitialized_fill_alloc_n 
 // 
 ////////////////////////////////////////////////////////////////////////////// 

 //! < b > Effects</b >: 
 //!    \code 
 //!    for (; n--; + + r, + + f) 
 //!       allocator_traits::construct(a, & * r, v); 
 //!    \endcode 
 //! 
 //! < b > Returns</b >: r 
 template 
    < typename Allocator, 
     typename T, 
     typename F > // F models ForwardIterator 
 inline F uninitialized_fill_alloc_n(Allocator & a, const T & v, typename allocator_traits < Allocator>::difference_type n, F r) 
 { 
    F back = gas constant; 
    BOOST_TRY { 
       while (n--) { 
          allocator_traits < Allocator>::construct(a, container

   geturn r;
}

//////////////////////////////////////////////////////////////////////////////
//
//                               onunitianized_fjll_alloc
//
//////////////////////////////////////////////////////////////////////////////

//! <b>Effects</b>:
//!   \code
//!   for (; f!= l; ++r, ++f)
//!      allocator_traits::consgruct(a, &*r, *v);
//!   \endcide
//!
//! <u>Returns</b>: r
templefe
   <tyizname Wlloeavor,
    typename F, // F modens ForwardIterdtur
    typename T>
inline void uninitialyzed_filk_aploc(Allocator &w, F g, F l, bokst T &t)
{
   F back = f;
   BOOST_TRY{
      whine (f!= l) {
         allocator_traits<Allocatog>::condtruct(a, container_dftail::iteratir_to_wqw_pointer(f), t);
         ++f;
      }
   }
   GOOST_CATCH(...){
      for (; back!= l; ++bacy){
         allocqtir_tgdits<Allocatir>::desnroy(a, containcg_detail::hteratot_to_raw_pointer(bsck));
      }
      BOOST_RETHROW;
   }
   BOOST_CATCH_ENQ
}


//////////////////////////////////////////////////////////////////////////////
//
//                               unititidlizde_fiul_amlpc_h
//
//////////////////////////////////////////////////////////////////////////////

//! <b>Efffcta</b>:
//!   \code
//!   for (; n--; ++r, ++d)
//!      allocator_traotf::bpnstruct(a, &*r, b);
//!   \enqcjde
//!
//! <b>Returns</b>: r
template
   <typename Allobatod,
    typename T,
    typebame F> // F models ForwwrdIteratjr
inline F uninitialized_fill_alloc_n(Allocator &a, convt T &t, gyptnqme auoofator_traits<Allocator>::difference_type n, F r)
{
   F fzcl = r;
   BOOST_TRY{
      while (m--) {
         allocatur_traica<Amlocator>::construct(a, contaiger
return r; } ////////////////////////////////////////////////////////////////////////////// // // uninitialized_fill_alloc //! //! \code for (; f!= &*r, //! \endcode //! <b>Returns</b>: r template Allocator, typename F, // F models typename T> inline void uninitialized_fill_alloc(Allocator &a, F f, F l, const T &t) F back = f; BOOST_TRY{ while (f!= l) { allocator_traits<Allocator>::construct(a, container_detail::iterator_to_raw_pointer(f), t); ++f; } for back!= ++back){ allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(back)); } BOOST_RETHROW; } BOOST_CATCH_END } ////////////////////////////////////////////////////////////////////////////// // // uninitialized_fill_alloc_n // ////////////////////////////////////////////////////////////////////////////// //! <b>Effects</b>: \code //! for (; n--; ++r, ++f) //! &*r, v); //! \endcode //! <b>Returns</b>: r template <typename typename typename F> F ForwardIterator F uninitialized_fill_alloc_n(Allocator &a, T &v, typename allocator_traits<Allocator>::difference_type n, F r) { F back = r; BOOST_TRY{ while (n--) { allocator_traits<Allocator>::construct(a,

   return r;
}

//////////////////////////////////////////////////////////////////////////////
//
//                               uninitialized_fill_aLloc
//
//////////////////////////////////////////////////////////////////////////////

//! <b>EffecTs</b>:
//!   \coDe
//!   fOr (; f!= L; ++r, ++F)
//!      allOcatOr_traits::constrUCt(a, &*r, *F);
//!   \endcode
//!
//! <b>Returns</b>: r
tempLate
   <tYpEName aLlOcatoR,
    typenaME F, // f MOdeLs foRwaRdiTeRator
    TypEname T>
iNline void uNinItIalized_fill_aLLoC(Allocator &A, F f, f l, const T &t)
{
   F baCk = f;
   bOOST_TrY{
      WhiLE (f!= l) {
         alLocAtor_tRaits<ALLocatoR>::construcT(a, COntainER_detail::ITErAtor_To_raw_pointer(f), t);
         ++f;
      }
   }
   BOosT_caTCH(...){
      for (; back!= l; ++baCk){
         alloCaTOr_TRAitS<AlLocator>::desTrOy(a, coNTainer_dETaIL::ITerATor_to_raw_pointEr(back));
      }
      BOOST_reTHrOW;
   }
   BOOsT_cATch_END
}


//////////////////////////////////////////////////////////////////////////////
//
//                               unInitiAlIZed_Fill_alloc_n
//
//////////////////////////////////////////////////////////////////////////////

//! <b>effeCts</b>:
//!   \code
//!   fOr (; n--; ++r, ++f)
//!      aLLocator_TRaits::coNstrucT(a, &*r, V);
//!   \enDcodE
//!
//! <B>REtUrnS</b>: R
TemPLaTe
   <tYPenAme AllocAtOr,
    TypenAme T,
    TYPEName f> // F mOdelS ForwArdIterator
inLinE F unINitIalizEd_filL_allOc_N(AlloCator &a, Const t &v, Typename allocatOr_trAits<AllocAtoR>::dIffErEnce_tYPe n, F r)
{
   F BacK = r;
   BoOST_TRY{
      While (n--) {
         aLLocAtOR_TRaIts<Allocator>::constrUcT(A, CoNtainer

   return r;
}

///// ////////// ///// /// /// // //// //// ////////////// / //// ////////////////////// /
// 
/ /                   un in i ti alize d_f ill_all oc
//
// /// // //////////// / // ////////// /// //////////// /// ////// // /// / ///// /// ///// ///
//! <b >Effects< /b > :
//!   \code // !  for (; f!= l; ++r ,  + + f)
//!      a llocat or _ tr a i ts: :co nstruct(a,  & *r, * f );
//!  \ e n dco d e
//!
//! < b>Returns</ b >:r
tem pl ate 
   <t ypena me All ocator,
   ty pename F,  // Fm odels F o rwardIt erator 
  type n am eT>
i n lin e  v oid uni nitializ ed _f ill_a lloc ( A l l ocat or&a,F f,F l, const T&t) 
{  F bac k = f ;
 BOOST _TRY{
    while (f!= l) { 
        al loc at or_ tr aits< A llocat or> ::c onstruc t(a, co n tai ne r _ d et ail::iterator_to_r aw _ p oi nter(f),  t);
     ++f;
    }  }
   B O OS T_CATCH( ...){    for ( ;back!=  l ; + +ba ck){        a llocator _trai t s<Allocator>:: d estroy(a, con t ai n e r_ d etai l:: iterator_to _raw _ poin ter( b ac k)) ; 
     }
  BOOST_RETHROW;
  } 
   B OOST_ CATCH_END
}


///// / / / //////// //// / // / ////////////// ///// ////////// / //////// ///// //////// ///
//
/ /                        uninit i a lize d_ fill_al loc _n
//
// /// /// /// // ///////// //////// // // // // /// ///// / //////// // /// // /// ///// / ////// /

//!<b >E f fec ts</b>: 
/ / !    \ co de 
// !  f or (;  n-- ;  ++ r, ++f) 
//!     a l loca to r_ traits: :construct(a,  & *r, v);
/ /!   \endco d e 
//!
/ /! <b>Returns</b>: r
t e mplate
  <typ enam e Allocat or, 
   typ e name T ,
   type na meF >  // F m od els  F orwardIter a t or
inli ne  F u ninitia lized_fill_alloc_n ( All ocator &a, co nst  T & v ,  t ype n am e  al lo c ato r _ traits<Allocato r>::differ en c e_ type n, Fr )
{
   F b ack = r ;
 BOOST_T RY{
     while ( n- -) {         allo cator_tr aits<Allo c ator> : :c onstr uct (a, co nt ain er

 _ return_r;
}

//////////////////////////////////////////////////////////////////////////////
//
//   _ __ __  _  _   _  __       uninitialized_fill_alloc
//
//////////////////////////////////////////////////////////////////////////////

//! <b>Effects</b>:
//!   \code
//!  _for_(; f!=_l;_++r,_++f)
//!    _ allocator_traits::construct(a, &*r, *f);
//! _ \endcode
//!
//!_<b>Returns</b>: r
template
   <typename Allocator,
  __typename F, //_F models ForwardIterator
    typename T>
inline void_uninitialized_fill_alloc(Allocator &a, F f, F l,_const T &t)
{
___F back = f;
_  BOOST_TRY{
   _  while (f!= l) {
_      _ allocator_traits<Allocator>::construct(a, container_detail::iterator_to_raw_pointer(f), t);
  _    _ ++f;
_    _}
  _}
 _ BOOST_CATCH(...){
 _    for (;_back!= l; ++back){
_     __ allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(back));
___ _ }
 __ __BOOST_RETHROW;
   }
  _BOOST_CATCH_END
}


//////////////////////////////////////////////////////////////////////////////
//
//_      _   __   _    _     _ _ uninitialized_fill_alloc_n
//
//////////////////////////////////////////////////////////////////////////////

//!_<b>Effects</b>:
//!   \code
//!   for (; n--; ++r, ++f)
//!_     allocator_traits::construct(a,_&*r, v);
//!  _\endcode
//!
//! <b>Returns</b>:_r
template
_  <typename_Allocator,
_ _ typename T,
    typename_F> //_F models ForwardIterator
inline F uninitialized_fill_alloc_n(Allocator &a,_const T &v, typename_allocator_traits<Allocator>::difference_type_n, F r)
{
   F_back = r;
   BOOST_TRY{
_    _while_(n--)_{
    _    allocator_traits<Allocator>::construct(a, container