staticsafedeclare.h

Go to the documentation of this file.

#ifndef ION_BASE_STATICSAFEDECLARE_H_
#define ION_BASE_STATICSAFEDECLARE_H_

#include <stdint.h>

#include <type_traits>
#include <vector>

#include "ion/base/lockguards.h"
#include "ion/base/shareable.h"
#include "ion/base/sharedptr.h"
#include "ion/base/static_assert.h"
#include "ion/port/atomic.h"
#include "ion/port/mutex.h"


#define ION_SAFE_ASSIGN_STATIC_POINTER(                          \
    type, variable, new_variable, add_func, destroyer) \
  type null = NULL;                                              \
  if (variable.compare_exchange_strong(null, new_variable)) {    \
    add_func(#type, new_variable);                               \
  } else {                                                       \
    destroyer new_variable;                                      \
  }

#define ION_DECLARE_SAFE_STATIC(                                         \
    type, variable, constructor, add_func, destroyer)                    \
  static std::atomic<type> atomic_##variable; /* Zero-initialized */     \
  ION_STATIC_ASSERT(std::is_pointer<type>::value,                        \
                    "static variables must be of pointer type");         \
  type variable = atomic_##variable.load(std::memory_order_acquire);     \
  if (variable == 0) {                                                   \
    type new_##variable = constructor;                                   \
    ION_SAFE_ASSIGN_STATIC_POINTER(                                      \
        type, atomic_##variable, new_##variable, add_func, destroyer);   \
    variable = atomic_##variable.load(std::memory_order_acquire);        \
  }




#define ION_DECLARE_SAFE_STATIC_ARRAY(type, variable, count)            \
  ION_DECLARE_SAFE_STATIC(                                              \
      type*,                                                            \
      variable,                                                         \
      new type[count],                                                  \
      ion::base::StaticDeleterDeleter::GetInstance()->AddArrayToDelete, \
      delete[])

#define ION_DECLARE_SAFE_STATIC_POINTER(type, variable)                   \
  ION_DECLARE_SAFE_STATIC(                                                \
      type*,                                                              \
      variable,                                                           \
      new type,                                                           \
      ion::base::StaticDeleterDeleter::GetInstance()->AddPointerToDelete, \
      delete)

#define ION_DECLARE_SAFE_STATIC_POINTER_WITH_CONSTRUCTOR(                 \
    type, variable, constructor)                                          \
  ION_DECLARE_SAFE_STATIC(                                                \
      type*,                                                              \
      variable,                                                           \
      constructor,                                                        \
      ion::base::StaticDeleterDeleter::GetInstance()->AddPointerToDelete, \
      delete)

namespace ion {
namespace base {

class StaticDeleterBase {
 public:
  explicit StaticDeleterBase(const std::string& name) : type_name_(name) {}
  virtual ~StaticDeleterBase() {}

  const std::string& GetTypeName() const { return type_name_; }

 protected:
  std::string type_name_;
};

template <typename T> class StaticDeleter : public StaticDeleterBase {
 public:
  StaticDeleter(const std::string& name, T* pointer_to_delete)
      : StaticDeleterBase(name),
        pointer_to_delete_(pointer_to_delete) {}

 private:
  ~StaticDeleter() override {
    delete pointer_to_delete_;
  }

  T* pointer_to_delete_;
};

template <typename T> class StaticDeleter<T[]> : public StaticDeleterBase {
 public:
  StaticDeleter(const std::string& name, T* pointer_to_delete)
      : StaticDeleterBase(name),
        pointer_to_delete_(pointer_to_delete) {}

 private:
  ~StaticDeleter() override {
    delete [] pointer_to_delete_;
  }

  T* pointer_to_delete_;
};

class ION_API StaticDeleterDeleter : public Shareable {
 public:
  StaticDeleterDeleter();
  ~StaticDeleterDeleter() override;

  template <typename T>
  void AddPointerToDelete(const std::string& name, T* ptr) {
    LockGuard locker(&mutex_);
    deleters_.push_back(new StaticDeleter<T>(name, ptr));
  }
  template <typename T>
  void AddArrayToDelete(const std::string& name, T* ptr) {
    LockGuard locker(&mutex_);
    deleters_.push_back(new StaticDeleter<T[]>(name, ptr));
  }
  template <typename T>
  void IgnoreInstance(const std::string& name, const T& ptr) {}

  static StaticDeleterDeleter* GetInstance();

  const StaticDeleterBase* GetDeleterAt(size_t index) const {
    return index < deleters_.size() ? deleters_[index] : NULL;
  }

  size_t GetDeleterCount() const { return deleters_.size(); }

  static void DestroyInstance();

 private:
  static void SetInstancePtr(const std::string&,
                             StaticDeleterDeleter* instance);

  std::vector<StaticDeleterBase*> deleters_;

  port::Mutex mutex_;
};

}  // namespace base
}  // namespace ion

#endif  // ION_BASE_STATICSAFEDECLARE_H_