threadlocalobject.h

Go to the documentation of this file.

#ifndef ION_BASE_THREADLOCALOBJECT_H_
#define ION_BASE_THREADLOCALOBJECT_H_

#include <vector>

#include "ion/base/allocatable.h"
#include "ion/base/allocator.h"
#include "ion/base/lockguards.h"
#include "ion/base/type_structs.h"
#include "ion/port/mutex.h"
#include "ion/port/threadutils.h"

namespace ion {
namespace base {

template <typename T> class ThreadLocalObject {
 public:
  ThreadLocalObject()
      : key_(port::CreateThreadLocalStorageKey()) {}

  explicit ThreadLocalObject(const AllocatorPtr& allocator)
      : key_(port::CreateThreadLocalStorageKey()),
        allocator_(allocator) {}

  ~ThreadLocalObject() {
    DestroyAllInstances();
    port::DeleteThreadLocalStorageKey(key_);
  }

  const port::ThreadLocalStorageKey& GetKey() const { return key_; }

  T* Get() {
    if (void* ptr = port::GetThreadLocalStorage(key_))
      return static_cast<T*>(ptr);
    else
      return CreateAndStoreInstance();
  }

 private:
  template <typename InstanceType, bool IsAllocatable = false>
  struct AllocationHelper {
    static InstanceType* Allocate(const AllocatorPtr& allocator) {
      return new InstanceType();
    }
  };
  template <typename InstanceType> struct AllocationHelper<InstanceType, true> {
    static InstanceType* Allocate(const AllocatorPtr& allocator) {
      return new(allocator) InstanceType();
    }
  };

  T* CreateAndStoreInstance() {
    T* instance = NULL;
    if (key_ != port::kInvalidThreadLocalStorageKey) {
      instance = AllocateInstance(allocator_);
      port::SetThreadLocalStorage(key_, instance);
      LockGuard guard(&mutex_);
      instances_.push_back(instance);
    }
    return instance;
  }

  static T* AllocateInstance(const AllocatorPtr& allocator) {
    typedef AllocationHelper<T, IsBaseOf<Allocatable, T>::value> HelperType;
    return HelperType::Allocate(allocator);
  }

  void DestroyAllInstances() {
    LockGuard guard(&mutex_);
    const size_t num_instances = instances_.size();
    for (size_t i = 0; i < num_instances; ++i)
      delete instances_[i];
    instances_.clear();
  }

  port::ThreadLocalStorageKey key_;
  AllocatorPtr allocator_;
  std::vector<T*> instances_;
  port::Mutex mutex_;
};

}  // namespace base
}  // namespace ion

#endif  // ION_BASE_THREADLOCALOBJECT_H_