src/thirdparty/boost_1_47_0/boost/multi_index/detail/scope_guard.hpp

   1 /* Copyright 2003-2011 Joaquin M Lopez Munoz.
   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/multi_index for library home page.
   7  */
   8
   9 #ifndef BOOST_MULTI_INDEX_DETAIL_SCOPE_GUARD_HPP
  10 #define BOOST_MULTI_INDEX_DETAIL_SCOPE_GUARD_HPP
  11
  12 #if defined(_MSC_VER)&&(_MSC_VER>=1200)
  13 #pragma once
  14 #endif
  15
  16 #include <boost/detail/no_exceptions_support.hpp>
  17
  18 namespace boost{
  19
  20 namespace multi_index{
  21
  22 namespace detail{
  23
  24 /* Until some official version of the ScopeGuard idiom makes it into Boost,
  25  * we locally define our own. This is a merely reformated version of
  26  * ScopeGuard.h as defined in:
  27  *   Alexandrescu, A., Marginean, P.:"Generic<Programming>: Change the Way You
  28  *     Write Exception-Safe Code - Forever", C/C++ Users Jornal, Dec 2000,
  29  *     http://www.drdobbs.com/184403758
  30  * with the following modifications:
  31  *   - General pretty formatting (pretty to my taste at least.)
  32  *   - Naming style changed to standard C++ library requirements.
  33  *   - Added scope_guard_impl4 and obj_scope_guard_impl3, (Boost.MultiIndex
  34  *     needs them). A better design would provide guards for many more
  35  *     arguments through the Boost Preprocessor Library.
  36  *   - Added scope_guard_impl_base::touch (see below.)
  37  *   - Removed RefHolder and ByRef, whose functionality is provided
  38  *     already by Boost.Ref.
  39  *   - Removed static make_guard's and make_obj_guard's, so that the code
  40  *     will work even if BOOST_NO_MEMBER_TEMPLATES is defined. This forces
  41  *     us to move some private ctors to public, though.
  42  *
  43  * NB: CodeWarrior Pro 8 seems to have problems looking up safe_execute
  44  * without an explicit qualification.
  45  *
  46  * We also define the following variants of the idiom:
  47  *
  48  *   - make_guard_if_c<bool>( ... )
  49  *   - make_guard_if<IntegralConstant>( ... )
  50  *   - make_obj_guard_if_c<bool>( ... )
  51  *   - make_obj_guard_if<IntegralConstant>( ... )
  52  * which may be used with a compile-time constant to yield
  53  * a "null_guard" if the boolean compile-time parameter is false,
  54  * or conversely, the guard is only constructed if the constant is true.
  55  * This is useful to avoid extra tagging, because the returned
  56  * null_guard can be optimzed comlpetely away by the compiler.
  57  */
  58
  59 class scope_guard_impl_base
  60 {
  61 public:
  62   scope_guard_impl_base():dismissed_(false){}
  63   void dismiss()const{dismissed_=true;}
  64
  65   /* This helps prevent some "unused variable" warnings under, for instance,
  66    * GCC 3.2.
  67    */
  68   void touch()const{}
  69
  70 protected:
  71   ~scope_guard_impl_base(){}
  72
  73   scope_guard_impl_base(const scope_guard_impl_base& other):
  74     dismissed_(other.dismissed_)
  75   {
  76     other.dismiss();
  77   }
  78
  79   template<typename J>
  80   static void safe_execute(J& j){
  81     BOOST_TRY{
  82       if(!j.dismissed_)j.execute();
  83     }
  84     BOOST_CATCH(...){}
  85     BOOST_CATCH_END
  86   }
  87
  88   mutable bool dismissed_;
  89
  90 private:
  91   scope_guard_impl_base& operator=(const scope_guard_impl_base&);
  92 };
  93
  94 typedef const scope_guard_impl_base& scope_guard;
  95
  96 struct null_guard : public scope_guard_impl_base
  97 {
  98     template< class T1 >
  99     null_guard( const T1& )
 100     { }
 101
 102     template< class T1, class T2 >
 103     null_guard( const T1&, const T2& )
 104     { }
 105
 106     template< class T1, class T2, class T3 >
 107     null_guard( const T1&, const T2&, const T3& )
 108     { }
 109
 110     template< class T1, class T2, class T3, class T4 >
 111     null_guard( const T1&, const T2&, const T3&, const T4& )
 112     { }
 113
 114     template< class T1, class T2, class T3, class T4, class T5 >
 115     null_guard( const T1&, const T2&, const T3&, const T4&, const T5& )
 116     { }
 117 };
 118
 119 template< bool cond, class T >
 120 struct null_guard_return
 121 {
 122     typedef typename boost::mpl::if_c<cond,T,null_guard>::type type;
 123 };
 124
 125 template<typename F>
 126 class scope_guard_impl0:public scope_guard_impl_base
 127 {
 128 public:
 129   scope_guard_impl0(F fun):fun_(fun){}
 130   ~scope_guard_impl0(){scope_guard_impl_base::safe_execute(*this);}
 131   void execute(){fun_();}
 132
 133 protected:
 134
 135   F fun_;
 136 };
 137
 138 template<typename F>
 139 inline scope_guard_impl0<F> make_guard(F fun)
 140 {
 141   return scope_guard_impl0<F>(fun);
 142 }
 143
 144 template<bool cond, typename F>
 145 inline typename null_guard_return<cond,scope_guard_impl0<F> >::type
 146 make_guard_if_c(F fun)
 147 {
 148   return typename null_guard_return<cond,scope_guard_impl0<F> >::type(fun);
 149 }
 150
 151 template<typename C, typename F>
 152 inline typename null_guard_return<C::value,scope_guard_impl0<F> >::type
 153 make_guard_if(F fun)
 154 {
 155   return make_guard_if<C::value>(fun);
 156 }
 157
 158 template<typename F,typename P1>
 159 class scope_guard_impl1:public scope_guard_impl_base
 160 {
 161 public:
 162   scope_guard_impl1(F fun,P1 p1):fun_(fun),p1_(p1){}
 163   ~scope_guard_impl1(){scope_guard_impl_base::safe_execute(*this);}
 164   void execute(){fun_(p1_);}
 165
 166 protected:
 167   F        fun_;
 168   const P1 p1_;
 169 };
 170
 171 template<typename F,typename P1>
 172 inline scope_guard_impl1<F,P1> make_guard(F fun,P1 p1)
 173 {
 174   return scope_guard_impl1<F,P1>(fun,p1);
 175 }
 176
 177 template<bool cond, typename F,typename P1>
 178 inline typename null_guard_return<cond,scope_guard_impl1<F,P1> >::type
 179 make_guard_if_c(F fun,P1 p1)
 180 {
 181   return typename null_guard_return<cond,scope_guard_impl1<F,P1> >::type(fun,p1);
 182 }
 183
 184 template<typename C, typename F,typename P1>
 185 inline typename null_guard_return<C::value,scope_guard_impl1<F,P1> >::type
 186 make_guard_if(F fun,P1 p1)
 187 {
 188   return make_guard_if_c<C::value>(fun,p1);
 189 }
 190
 191 template<typename F,typename P1,typename P2>
 192 class scope_guard_impl2:public scope_guard_impl_base
 193 {
 194 public:
 195   scope_guard_impl2(F fun,P1 p1,P2 p2):fun_(fun),p1_(p1),p2_(p2){}
 196   ~scope_guard_impl2(){scope_guard_impl_base::safe_execute(*this);}
 197   void execute(){fun_(p1_,p2_);}
 198
 199 protected:
 200   F        fun_;
 201   const P1 p1_;
 202   const P2 p2_;
 203 };
 204
 205 template<typename F,typename P1,typename P2>
 206 inline scope_guard_impl2<F,P1,P2> make_guard(F fun,P1 p1,P2 p2)
 207 {
 208   return scope_guard_impl2<F,P1,P2>(fun,p1,p2);
 209 }
 210
 211 template<bool cond, typename F,typename P1,typename P2>
 212 inline typename null_guard_return<cond,scope_guard_impl2<F,P1,P2> >::type
 213 make_guard_if_c(F fun,P1 p1,P2 p2)
 214 {
 215   return typename null_guard_return<cond,scope_guard_impl2<F,P1,P2> >::type(fun,p1,p2);
 216 }
 217
 218 template<typename C, typename F,typename P1,typename P2>
 219 inline typename null_guard_return<C::value,scope_guard_impl2<F,P1,P2> >::type
 220 make_guard_if(F fun,P1 p1,P2 p2)
 221 {
 222   return make_guard_if_c<C::value>(fun,p1,p2);
 223 }
 224
 225 template<typename F,typename P1,typename P2,typename P3>
 226 class scope_guard_impl3:public scope_guard_impl_base
 227 {
 228 public:
 229   scope_guard_impl3(F fun,P1 p1,P2 p2,P3 p3):fun_(fun),p1_(p1),p2_(p2),p3_(p3){}
 230   ~scope_guard_impl3(){scope_guard_impl_base::safe_execute(*this);}
 231   void execute(){fun_(p1_,p2_,p3_);}
 232
 233 protected:
 234   F        fun_;
 235   const P1 p1_;
 236   const P2 p2_;
 237   const P3 p3_;
 238 };
 239
 240 template<typename F,typename P1,typename P2,typename P3>
 241 inline scope_guard_impl3<F,P1,P2,P3> make_guard(F fun,P1 p1,P2 p2,P3 p3)
 242 {
 243   return scope_guard_impl3<F,P1,P2,P3>(fun,p1,p2,p3);
 244 }
 245
 246 template<bool cond,typename F,typename P1,typename P2,typename P3>
 247 inline typename null_guard_return<cond,scope_guard_impl3<F,P1,P2,P3> >::type
 248 make_guard_if_c(F fun,P1 p1,P2 p2,P3 p3)
 249 {
 250   return typename null_guard_return<cond,scope_guard_impl3<F,P1,P2,P3> >::type(fun,p1,p2,p3);
 251 }
 252
 253 template<typename C,typename F,typename P1,typename P2,typename P3>
 254 inline typename null_guard_return< C::value,scope_guard_impl3<F,P1,P2,P3> >::type
 255 make_guard_if(F fun,P1 p1,P2 p2,P3 p3)
 256 {
 257   return make_guard_if_c<C::value>(fun,p1,p2,p3);
 258 }
 259
 260 template<typename F,typename P1,typename P2,typename P3,typename P4>
 261 class scope_guard_impl4:public scope_guard_impl_base
 262 {
 263 public:
 264   scope_guard_impl4(F fun,P1 p1,P2 p2,P3 p3,P4 p4):
 265     fun_(fun),p1_(p1),p2_(p2),p3_(p3),p4_(p4){}
 266   ~scope_guard_impl4(){scope_guard_impl_base::safe_execute(*this);}
 267   void execute(){fun_(p1_,p2_,p3_,p4_);}
 268
 269 protected:
 270   F        fun_;
 271   const P1 p1_;
 272   const P2 p2_;
 273   const P3 p3_;
 274   const P4 p4_;
 275 };
 276
 277 template<typename F,typename P1,typename P2,typename P3,typename P4>
 278 inline scope_guard_impl4<F,P1,P2,P3,P4> make_guard(
 279   F fun,P1 p1,P2 p2,P3 p3,P4 p4)
 280 {
 281   return scope_guard_impl4<F,P1,P2,P3,P4>(fun,p1,p2,p3,p4);
 282 }
 283
 284 template<bool cond, typename F,typename P1,typename P2,typename P3,typename P4>
 285 inline typename null_guard_return<cond,scope_guard_impl4<F,P1,P2,P3,P4> >::type
 286 make_guard_if_c(
 287   F fun,P1 p1,P2 p2,P3 p3,P4 p4)
 288 {
 289   return typename null_guard_return<cond,scope_guard_impl4<F,P1,P2,P3,P4> >::type(fun,p1,p2,p3,p4);
 290 }
 291
 292 template<typename C, typename F,typename P1,typename P2,typename P3,typename P4>
 293 inline typename null_guard_return<C::value,scope_guard_impl4<F,P1,P2,P3,P4> >::type
 294 make_guard_if(
 295   F fun,P1 p1,P2 p2,P3 p3,P4 p4)
 296 {
 297   return make_guard_if_c<C::value>(fun,p1,p2,p3,p4);
 298 }
 299
 300 template<class Obj,typename MemFun>
 301 class obj_scope_guard_impl0:public scope_guard_impl_base
 302 {
 303 public:
 304   obj_scope_guard_impl0(Obj& obj,MemFun mem_fun):obj_(obj),mem_fun_(mem_fun){}
 305   ~obj_scope_guard_impl0(){scope_guard_impl_base::safe_execute(*this);}
 306   void execute(){(obj_.*mem_fun_)();}
 307
 308 protected:
 309   Obj&   obj_;
 310   MemFun mem_fun_;
 311 };
 312
 313 template<class Obj,typename MemFun>
 314 inline obj_scope_guard_impl0<Obj,MemFun> make_obj_guard(Obj& obj,MemFun mem_fun)
 315 {
 316   return obj_scope_guard_impl0<Obj,MemFun>(obj,mem_fun);
 317 }
 318
 319 template<bool cond, class Obj,typename MemFun>
 320 inline typename null_guard_return<cond,obj_scope_guard_impl0<Obj,MemFun> >::type
 321 make_obj_guard_if_c(Obj& obj,MemFun mem_fun)
 322 {
 323   return typename null_guard_return<cond,obj_scope_guard_impl0<Obj,MemFun> >::type(obj,mem_fun);
 324 }
 325
 326 template<typename C, class Obj,typename MemFun>
 327 inline typename null_guard_return<C::value,obj_scope_guard_impl0<Obj,MemFun> >::type
 328 make_obj_guard_if(Obj& obj,MemFun mem_fun)
 329 {
 330   return make_obj_guard_if_c<C::value>(obj,mem_fun);
 331 }
 332
 333 template<class Obj,typename MemFun,typename P1>
 334 class obj_scope_guard_impl1:public scope_guard_impl_base
 335 {
 336 public:
 337   obj_scope_guard_impl1(Obj& obj,MemFun mem_fun,P1 p1):
 338     obj_(obj),mem_fun_(mem_fun),p1_(p1){}
 339   ~obj_scope_guard_impl1(){scope_guard_impl_base::safe_execute(*this);}
 340   void execute(){(obj_.*mem_fun_)(p1_);}
 341
 342 protected:
 343   Obj&     obj_;
 344   MemFun   mem_fun_;
 345   const P1 p1_;
 346 };
 347
 348 template<class Obj,typename MemFun,typename P1>
 349 inline obj_scope_guard_impl1<Obj,MemFun,P1> make_obj_guard(
 350   Obj& obj,MemFun mem_fun,P1 p1)
 351 {
 352   return obj_scope_guard_impl1<Obj,MemFun,P1>(obj,mem_fun,p1);
 353 }
 354
 355 template<bool cond, class Obj,typename MemFun,typename P1>
 356 inline typename null_guard_return<cond,obj_scope_guard_impl1<Obj,MemFun,P1> >::type
 357 make_obj_guard_if_c(  Obj& obj,MemFun mem_fun,P1 p1)
 358 {
 359   return typename null_guard_return<cond,obj_scope_guard_impl1<Obj,MemFun,P1> >::type(obj,mem_fun,p1);
 360 }
 361
 362 template<typename C, class Obj,typename MemFun,typename P1>
 363 inline typename null_guard_return<C::value,obj_scope_guard_impl1<Obj,MemFun,P1> >::type
 364 make_obj_guard_if( Obj& obj,MemFun mem_fun,P1 p1)
 365 {
 366   return make_obj_guard_if_c<C::value>(obj,mem_fun,p1);
 367 }
 368
 369 template<class Obj,typename MemFun,typename P1,typename P2>
 370 class obj_scope_guard_impl2:public scope_guard_impl_base
 371 {
 372 public:
 373   obj_scope_guard_impl2(Obj& obj,MemFun mem_fun,P1 p1,P2 p2):
 374     obj_(obj),mem_fun_(mem_fun),p1_(p1),p2_(p2)
 375   {}
 376   ~obj_scope_guard_impl2(){scope_guard_impl_base::safe_execute(*this);}
 377   void execute(){(obj_.*mem_fun_)(p1_,p2_);}
 378
 379 protected:
 380   Obj&     obj_;
 381   MemFun   mem_fun_;
 382   const P1 p1_;
 383   const P2 p2_;
 384 };
 385
 386 template<class Obj,typename MemFun,typename P1,typename P2>
 387 inline obj_scope_guard_impl2<Obj,MemFun,P1,P2>
 388 make_obj_guard(Obj& obj,MemFun mem_fun,P1 p1,P2 p2)
 389 {
 390   return obj_scope_guard_impl2<Obj,MemFun,P1,P2>(obj,mem_fun,p1,p2);
 391 }
 392
 393 template<bool cond, class Obj,typename MemFun,typename P1,typename P2>
 394 inline typename null_guard_return<cond,obj_scope_guard_impl2<Obj,MemFun,P1,P2> >::type
 395 make_obj_guard_if_c(Obj& obj,MemFun mem_fun,P1 p1,P2 p2)
 396 {
 397   return typename null_guard_return<cond,obj_scope_guard_impl2<Obj,MemFun,P1,P2> >::type(obj,mem_fun,p1,p2);
 398 }
 399
 400 template<typename C, class Obj,typename MemFun,typename P1,typename P2>
 401 inline typename null_guard_return<C::value,obj_scope_guard_impl2<Obj,MemFun,P1,P2> >::type
 402 make_obj_guard_if(Obj& obj,MemFun mem_fun,P1 p1,P2 p2)
 403 {
 404   return make_obj_guard_if_c<C::value>(obj,mem_fun,p1,p2);
 405 }
 406
 407 template<class Obj,typename MemFun,typename P1,typename P2,typename P3>
 408 class obj_scope_guard_impl3:public scope_guard_impl_base
 409 {
 410 public:
 411   obj_scope_guard_impl3(Obj& obj,MemFun mem_fun,P1 p1,P2 p2,P3 p3):
 412     obj_(obj),mem_fun_(mem_fun),p1_(p1),p2_(p2),p3_(p3)
 413   {}
 414   ~obj_scope_guard_impl3(){scope_guard_impl_base::safe_execute(*this);}
 415   void execute(){(obj_.*mem_fun_)(p1_,p2_,p3_);}
 416
 417 protected:
 418   Obj&     obj_;
 419   MemFun   mem_fun_;
 420   const P1 p1_;
 421   const P2 p2_;
 422   const P3 p3_;
 423 };
 424
 425 template<class Obj,typename MemFun,typename P1,typename P2,typename P3>
 426 inline obj_scope_guard_impl3<Obj,MemFun,P1,P2,P3>
 427 make_obj_guard(Obj& obj,MemFun mem_fun,P1 p1,P2 p2,P3 p3)
 428 {
 429   return obj_scope_guard_impl3<Obj,MemFun,P1,P2,P3>(obj,mem_fun,p1,p2,p3);
 430 }
 431
 432 template<bool cond, class Obj,typename MemFun,typename P1,typename P2,typename P3>
 433 inline typename null_guard_return<cond,obj_scope_guard_impl3<Obj,MemFun,P1,P2,P3> >::type
 434 make_obj_guard_if_c(Obj& obj,MemFun mem_fun,P1 p1,P2 p2,P3 p3)
 435 {
 436   return typename null_guard_return<cond,obj_scope_guard_impl3<Obj,MemFun,P1,P2,P3> >::type(obj,mem_fun,p1,p2,p3);
 437 }
 438
 439 template<typename C, class Obj,typename MemFun,typename P1,typename P2,typename P3>
 440 inline typename null_guard_return<C::value,obj_scope_guard_impl3<Obj,MemFun,P1,P2,P3> >::type
 441 make_obj_guard_if(Obj& obj,MemFun mem_fun,P1 p1,P2 p2,P3 p3)
 442 {
 443   return make_obj_guard_if_c<C::value>(obj,mem_fun,p1,p2,p3);
 444 }
 445
 446 } /* namespace multi_index::detail */
 447
 448 } /* namespace multi_index */
 449
 450 } /* namespace boost */
 451
 452 #endif