toast/singleton.hpp

Go to the documentation of this file.

#ifndef toast_singleton_hpp_INCLUDED
#define toast_singleton_hpp_INCLUDED

#include <sstream>
#include <boost/thread/mutex.hpp>
#include <boost/thread/tss.hpp>
#include <boost/optional.hpp>
#include <boost/none.hpp>
#include <boost/mpl/bool.hpp>
#include <toast/assert.hpp>
#include <toast/typeinfo.hpp>
#include <toast/typed_factory.hpp>
#include <toast/async/lockable.hpp>

#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_same.hpp>

#include <toast/static_init_protected.hpp>

namespace toast {

namespace detail {

template <typename T>
std::string no_factory()
{
        std::ostringstream os;
        os << "Attempt to get factory for " << type_id<T>().name() <<
          " when no factory has been set.";
        return os.str();
}

template <typename T>
std::string factory_already_exists()
{
  std::ostringstream os;
  os << "Attempt to set factory for " << type_id<T>().name() <<
    " when factory already exists.";
  return os.str();
}

template <typename T, typename U>
class holder;

template <typename T>
class holder<T, T>
{
  T data_;
public:
  T &get() { return data_; }
  void apply(typed_factory<T> const &) {}
  bool exists() { return true; }
};

template <typename T, typename U>
class sync_helper
{
  boost::thread_specific_ptr<int> sync_check_;
  boost::mutex mutex_;
  U data_;
  void apply(typed_factory<T> const &factory, boost::optional<T> &data)
  {
    data_ = factory;
  }
  void apply(typed_factory<T> const &factory, T*)
  {
    data_ = factory.create();
  }
  static void noop(int *) {}
  void init(boost::optional<T> const &) {}
  void init(T*&t) { t = 0; }
public:
  sync_helper() : sync_check_(&sync_helper::noop) { init(data_); }
  T &get() { return *data_; }
  void apply(typed_factory<T> const &factory)
  {
    boost::mutex::scoped_lock lock(mutex_);
    if(!data_)
      apply(factory, data_);
    sync_check_.reset(reinterpret_cast<int*>(1));
  }
  bool exists() { return sync_check_.get(); }
};

template <typename T>
class holder<T, boost::optional<T> >
        : public sync_helper<T, boost::optional<T> >
{};

template <typename T>
class holder<T, T*> : public sync_helper<T, T*>
{};

template <typename T>
class holder<T, boost::thread_specific_ptr<T> >
{
  boost::thread_specific_ptr<T> data_;
public:
  T &get() { return *data_; }
  bool exists() { return data_.get(); }
  void apply(typed_factory<T> const &factory)
  {
    data_.reset(factory.create()); 
  }
};

}

template <typename T>
struct default_factory
{
  static typed_factory<T> get() { return typed_factory<T>(); }
};

template <typename T>
class global_factory
{
  typedef async::lockable<boost::optional<typed_factory<T> > > factory_type;
  typedef detail::holder<factory_type, factory_type> holder_t;
  TOAST_STATIC_INIT_PROTECTED(holder_t, holder_);
public:
  static void set(typed_factory<T> const &f)
  {
        async::locked<boost::optional<typed_factory<T> > > factory(holder_::get().get());
    TOAST_ASSERT_MESSAGE(!*factory,
      detail::factory_already_exists<T>().c_str());
    *factory = f;
  }
  
  static typed_factory<T> get()
  {
        async::locked<boost::optional<typed_factory<T> > > factory(holder_::get().get());
    TOAST_ASSERT_MESSAGE( *factory, detail::no_factory<T>().c_str() );
    return **factory;
  }
};

template <typename T>
class thread_specific_factory
{
  typedef boost::thread_specific_ptr<typed_factory<T> > factory_type;
  typedef detail::holder<factory_type, factory_type> holder_t;
  TOAST_STATIC_INIT_PROTECTED(holder_t, holder_);
public:
  static void set( typed_factory<T> const &f )
  {
        TOAST_ASSERT_MESSAGE(!holder_::get().get().get(),
                                                 detail::factory_already_exists<T>().c_str());
        holder_::get().get().reset( new typed_factory<T>(f) );
  }
  
  static typed_factory<T> get()
  {
        TOAST_ASSERT_MESSAGE( holder_::get().get().get(),
                                                  detail::no_factory<T>().c_str() );
        return *holder_::get().get();
  }
};

template <typename T,
          typename HolderType = boost::optional<T>,
          typename FactoryType = toast::default_factory<T>,
                  typename Enable = void>
class singleton_helper
{
  typedef singleton_helper<T, HolderType, FactoryType, Enable> this_t;
  typedef detail::holder<T, HolderType> real_holder_t;
  TOAST_STATIC_INIT_PROTECTED(real_holder_t, holder_);
        
public:
  typedef T type;

  static void force_init()
  {
    holder_::get();
  }

  static T & instance()
  {
        if(!holder_::get().exists()) {
          holder_::get().apply(FactoryType::get());
        }

    return holder_::get().get();
  }

  static void set_factory( toast::typed_factory<T> const &f )
  {
    FactoryType::set(f);
  }
};

template<typename T>
class singleton_helper< T, boost::optional<T>, thread_specific_factory<T> >
{
public:
        // If you are getting an error here, that's because you're trying to use
        // boost::optional<T> as your holder type and thread_specific_factory<T>
        // as your factory type. This can't possibly be what you actually want.
        // Using this setup, you'd get one singleton per thread, but only one
        // boost optional. That means a bunch of the singletons you created are
        // inaccessible! Maybe instead of optional you want boost::thread_specific_ptr<A>?
        static void initialize_holder()
        {
                BOOST_STATIC_ASSERT(sizeof(T) == 0);
        }

        BOOST_STATIC_ASSERT(sizeof(T) == 0);
};

template<typename T>
class singleton_helper< T, T*, thread_specific_factory<T> >
{
public:
        // If you are getting an error here, that's because you're trying to use
        // T* as your holder type and thread_specific_factory<T>
        // as your factory type. This can't possibly be what you actually want.
        // Using this setup, you'd get one singleton per thread, but only one
        // T*. That means a bunch of the singletons you created are
        // inaccessible! Maybe instead of optional you want boost::thread_specific_ptr<A>?
        static void initialize_holder()
        {
                BOOST_STATIC_ASSERT(sizeof(T) == 0);
        }

        BOOST_STATIC_ASSERT(sizeof(T) == 0);
};

template<typename T, typename U>
class singleton_helper< T, T, U,
                                                typename boost::template disable_if< boost::is_same< U, default_factory<T> > >::type >
{
public:
        // If you're getting an error here, it's because you're using T as your
        // holder type but also trying to specify a custom factory. This is
        // pointless because if you're holding a T directly its default
        // constructor gets used regardless of any factory being set. The
        // factory will go unused. So this is not what you want.
        static void initialize_holder()
        {
                BOOST_STATIC_ASSERT(sizeof(T) == 0);
        }

        BOOST_STATIC_ASSERT(sizeof(T) == 0);
};

}

#endif

---