flyweight/detail/flyweight_core.hpp

0001 /* Copyright 2006-2020 Joaquin M Lopez Munoz.
0002  * Distributed under the Boost Software License, Version 1.0.
0003  * (See accompanying file LICENSE_1_0.txt or copy at
0004  * http://www.boost.org/LICENSE_1_0.txt)
0005  *
0006  * See http://www.boost.org/libs/flyweight for library home page.
0007  */
0008
0009 #ifndef BOOST_FLYWEIGHT_DETAIL_FLYWEIGHT_CORE_HPP
0010 #define BOOST_FLYWEIGHT_DETAIL_FLYWEIGHT_CORE_HPP
0011
0012 #if defined(_MSC_VER)
0013 #pragma once
0014 #endif
0015
0016 #include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
0017 #include <boost/core/no_exceptions_support.hpp>
0018 #include <boost/detail/workaround.hpp>
0019 #include <boost/flyweight/detail/perfect_fwd.hpp>
0020 #include <boost/mpl/apply.hpp>
0021
0022 #if BOOST_WORKAROUND(BOOST_MSVC,BOOST_TESTED_AT(1400))
0023 #pragma warning(push)
0024 #pragma warning(disable:4101)  /* unreferenced local vars */
0025 #endif
0026
0027 /* flyweight_core provides the inner implementation of flyweight<> by
0028  * weaving together a value policy, a flyweight factory, a holder for the
0029  * factory,a tracking policy and a locking policy.
0030  */
0031
0032 namespace boost{
0033
0034 namespace flyweights{
0035
0036 namespace detail{
0037
0038 template<
0039   typename ValuePolicy,typename Tag,typename TrackingPolicy,
0040   typename FactorySpecifier,typename LockingPolicy,typename HolderSpecifier
0041 >
0042 class flyweight_core;
0043
0044 template<
0045   typename ValuePolicy,typename Tag,typename TrackingPolicy,
0046   typename FactorySpecifier,typename LockingPolicy,typename HolderSpecifier
0047 >
0048 struct flyweight_core_tracking_helper
0049 {
0050 private:
0051   typedef flyweight_core<
0052     ValuePolicy,Tag,TrackingPolicy,
0053     FactorySpecifier,LockingPolicy,
0054     HolderSpecifier
0055   >                                   core;
0056   typedef typename core::handle_type  handle_type;
0057   typedef typename core::entry_type   entry_type;
0058
0059 public:
0060   static const entry_type& entry(const handle_type& h)
0061   {
0062     return core::entry(h);
0063   }
0064
0065   template<typename Checker>
0066   static void erase(const handle_type& h,Checker chk)
0067   {
0068     typedef typename core::lock_type lock_type;
0069     core::init();
0070     lock_type lock(core::mutex());(void)lock;
0071     if(chk(h))core::factory().erase(h);
0072   }
0073 };
0074
0075 template<
0076   typename ValuePolicy,typename Tag,typename TrackingPolicy,
0077   typename FactorySpecifier,typename LockingPolicy,typename HolderSpecifier
0078 >
0079 class flyweight_core
0080 {
0081 public:
0082   typedef typename ValuePolicy::key_type     key_type;
0083   typedef typename ValuePolicy::value_type   value_type;
0084   typedef typename ValuePolicy::rep_type     rep_type;
0085   typedef typename mpl::apply2<
0086     typename TrackingPolicy::entry_type,
0087     rep_type,
0088     key_type
0089   >::type                                    entry_type;
0090   typedef typename mpl::apply2<
0091     FactorySpecifier,
0092     entry_type,
0093     key_type
0094   >::type                                    factory_type;
0095   typedef typename factory_type::handle_type base_handle_type;
0096   typedef typename mpl::apply2<
0097     typename TrackingPolicy::handle_type,
0098     base_handle_type,
0099     flyweight_core_tracking_helper<
0100       ValuePolicy,Tag,TrackingPolicy,
0101       FactorySpecifier,LockingPolicy,
0102       HolderSpecifier
0103     >
0104   >::type                                    handle_type;
0105   typedef typename LockingPolicy::mutex_type mutex_type;
0106   typedef typename LockingPolicy::lock_type  lock_type;
0107
0108   static bool init()
0109   {
0110     if(static_initializer)return true;
0111     else{
0112       holder_arg& a=holder_type::get();
0113       static_factory_ptr=&a.factory;
0114       static_mutex_ptr=&a.mutex;
0115       static_initializer=(static_factory_ptr!=0);
0116       return static_initializer;
0117     }
0118   }
0119
0120   /* insert overloads*/
0121
0122 #define BOOST_FLYWEIGHT_PERFECT_FWD_INSERT_BODY(args)         \
0123 {                                                             \
0124   return insert_rep(rep_type(BOOST_FLYWEIGHT_FORWARD(args))); \
0125 }
0126
0127   BOOST_FLYWEIGHT_PERFECT_FWD(
0128     static handle_type insert,
0129     BOOST_FLYWEIGHT_PERFECT_FWD_INSERT_BODY)
0130
0131 #undef BOOST_FLYWEIGHT_PERFECT_FWD_INSERT_BODY
0132
0133   static handle_type insert(const value_type& x){return insert_value(x);}
0134   static handle_type insert(value_type& x){return insert_value(x);}
0135
0136 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
0137   static handle_type insert(const value_type&& x){return insert_value(x);}
0138   static handle_type insert(value_type&& x){return insert_value(std::move(x));}
0139 #endif
0140
0141   static const entry_type& entry(const base_handle_type& h)
0142   {
0143     return factory().entry(h);
0144   }
0145
0146   static const value_type& value(const handle_type& h)
0147   {
0148     return static_cast<const rep_type&>(entry(h));
0149   }
0150
0151   static const key_type& key(const handle_type& h)
0152   {
0153     return static_cast<const rep_type&>(entry(h));
0154   }
0155
0156   static factory_type& factory()
0157   {
0158     return *static_factory_ptr;
0159   }
0160
0161   static mutex_type& mutex()
0162   {
0163     return *static_mutex_ptr;
0164   }
0165
0166 private:
0167   struct                              holder_arg
0168   {
0169     factory_type factory;
0170     mutex_type   mutex;
0171   };
0172   typedef typename mpl::apply1<
0173     HolderSpecifier,
0174     holder_arg
0175   >::type                             holder_type;
0176
0177   static handle_type insert_rep(const rep_type& x)
0178   {
0179     init();
0180     entry_type       e(x);
0181     lock_type        lock(mutex());(void)lock;
0182 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
0183     base_handle_type h(factory().insert(std::move(e)));
0184 #else
0185     base_handle_type h(factory().insert(e));
0186 #endif
0187
0188     BOOST_TRY{
0189       ValuePolicy::construct_value(
0190         static_cast<const rep_type&>(entry(h)));
0191     }
0192     BOOST_CATCH(...){
0193       factory().erase(h);
0194       BOOST_RETHROW;
0195     }
0196     BOOST_CATCH_END
0197     return static_cast<handle_type>(h);
0198   }
0199
0200   static handle_type insert_value(const value_type& x)
0201   {
0202     init();
0203     entry_type       e((rep_type(x)));
0204     lock_type        lock(mutex());(void)lock;
0205
0206 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
0207     base_handle_type h(factory().insert(std::move(e)));
0208 #else
0209     base_handle_type h(factory().insert(e));
0210 #endif
0211
0212     BOOST_TRY{
0213       ValuePolicy::copy_value(
0214         static_cast<const rep_type&>(entry(h)));
0215     }
0216     BOOST_CATCH(...){
0217       factory().erase(h);
0218       BOOST_RETHROW;
0219     }
0220     BOOST_CATCH_END
0221     return static_cast<handle_type>(h);
0222   }
0223
0224 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
0225   static handle_type insert_rep(rep_type&& x)
0226   {
0227     init();
0228     entry_type       e(std::move(x));
0229     lock_type        lock(mutex());(void)lock;
0230     base_handle_type h(factory().insert(std::move(e)));
0231
0232     BOOST_TRY{
0233       ValuePolicy::construct_value(
0234         static_cast<const rep_type&>(entry(h)));
0235     }
0236     BOOST_CATCH(...){
0237       factory().erase(h);
0238       BOOST_RETHROW;
0239     }
0240     BOOST_CATCH_END
0241     return static_cast<handle_type>(h);
0242   }
0243
0244   static handle_type insert_value(value_type&& x)
0245   {
0246     init();
0247     entry_type       e(rep_type(std::move(x)));
0248     lock_type        lock(mutex());(void)lock;
0249     base_handle_type h(factory().insert(std::move(e)));
0250     BOOST_TRY{
0251       ValuePolicy::move_value(
0252         static_cast<const rep_type&>(entry(h)));
0253     }
0254     BOOST_CATCH(...){
0255       factory().erase(h);
0256       BOOST_RETHROW;
0257     }
0258     BOOST_CATCH_END
0259     return static_cast<handle_type>(h);
0260   }
0261 #endif
0262
0263   static bool          static_initializer;
0264   static factory_type* static_factory_ptr;
0265   static mutex_type*   static_mutex_ptr;
0266 };
0267
0268 template<
0269   typename ValuePolicy,typename Tag,typename TrackingPolicy,
0270   typename FactorySpecifier,typename LockingPolicy,typename HolderSpecifier
0271 >
0272 bool
0273 flyweight_core<
0274   ValuePolicy,Tag,TrackingPolicy,
0275   FactorySpecifier,LockingPolicy,HolderSpecifier>::static_initializer=
0276   flyweight_core<
0277       ValuePolicy,Tag,TrackingPolicy,
0278       FactorySpecifier,LockingPolicy,HolderSpecifier>::init();
0279
0280 template<
0281   typename ValuePolicy,typename Tag,typename TrackingPolicy,
0282   typename FactorySpecifier,typename LockingPolicy,typename HolderSpecifier
0283 >
0284 typename flyweight_core<
0285   ValuePolicy,Tag,TrackingPolicy,
0286   FactorySpecifier,LockingPolicy,HolderSpecifier>::factory_type*
0287 flyweight_core<
0288   ValuePolicy,Tag,TrackingPolicy,
0289   FactorySpecifier,LockingPolicy,HolderSpecifier>::static_factory_ptr=0;
0290
0291 template<
0292   typename ValuePolicy,typename Tag,typename TrackingPolicy,
0293   typename FactorySpecifier,typename LockingPolicy,typename HolderSpecifier
0294 >
0295 typename flyweight_core<
0296   ValuePolicy,Tag,TrackingPolicy,
0297   FactorySpecifier,LockingPolicy,HolderSpecifier>::mutex_type*
0298 flyweight_core<
0299   ValuePolicy,Tag,TrackingPolicy,
0300   FactorySpecifier,LockingPolicy,HolderSpecifier>::static_mutex_ptr=0;
0301
0302 } /* namespace flyweights::detail */
0303
0304 } /* namespace flyweights */
0305
0306 } /* namespace boost */
0307
0308 #if BOOST_WORKAROUND(BOOST_MSVC,BOOST_TESTED_AT(1400))
0309 #pragma warning(pop)
0310 #endif
0311
0312 #endif