LockBox.hpp

Go to the documentation of this file.

#pragma once
 
#include <functional>
#include <memory>
 
namespace Utility {
template <typename T> class LockBox;
template <typename T> void swap(LockBox<T>& first, LockBox<T>& second);
 
template <typename T> class LockBox {
  public:
    class Key {};
 
    friend void swap<T>(LockBox<T>& first, LockBox<T>& second);
 
    LockBox() = default;
 
 
    LockBox(std::shared_ptr<Key> key, T* data);
 
 
    LockBox(const LockBox<T>& other);
 
 
    LockBox(LockBox<T>&& other);
 
 
    LockBox<T>& operator=(LockBox<T> rhs);
 
    ~LockBox();
 
 
    bool Open(std::shared_ptr<Key> key, const std::function<void(T&)>& forValidKey);
 
 
    uint32_t RefCount() const;
 
  private:
    struct Shared {
        uint32_t refs = 0;
        std::shared_ptr<Key> key = std::shared_ptr<Key>(nullptr);
        T* data = nullptr;
    };
 
    Shared* shared = nullptr;
};
 
 
template <typename T> void swap(LockBox<T>& first, LockBox<T>& second) {
    using std::swap;
    swap(first.shared, second.shared);
}
 
template <typename T> LockBox<T>::LockBox(std::shared_ptr<Key> key, T* data) {
    shared = new Shared;
    shared->refs = 1;
    shared->key = key;
    shared->data = data;
}
 
template <typename T> LockBox<T>::LockBox(const LockBox<T>& other) {
    shared = other.shared;
    shared->refs++;
}
 
template <typename T> LockBox<T>::LockBox(LockBox<T>&& other) : LockBox() {
    swap(*this, other);
}
 
// Why not placement new: https://stackoverflow.com/a/7178022
// Copy-and-swap idiom: https://stackoverflow.com/a/3279550
template <typename T> LockBox<T>& LockBox<T>::operator=(LockBox<T> rhs) {
    swap(*this, rhs);
    return *this;
}
 
template <typename T> LockBox<T>::~LockBox() {
    if (shared && --shared->refs == 0) {
        delete shared;
    }
}
 
template <typename T> bool LockBox<T>::Open(std::shared_ptr<Key> key, const std::function<void(T&)>& forValidKey) {
    if (shared && key.get() == shared->key.get()) {
        forValidKey(*shared->data);
        return true;
    }
    return false;
}
 
template <typename T> uint32_t LockBox<T>::RefCount() const {
    return shared ? shared->refs : 0;
}
} // namespace Utility