asyncable_data.h

[詳解]

 
 
// Copyright(c) 2023-2025 Design Engineering Laboratory, Saitama University
// Released under the MIT license
// https://opensource.org/licenses/mit-license.php
 
#ifndef DESIGNLAB_ASYNCABLE_DATA_H_
#define DESIGNLAB_ASYNCABLE_DATA_H_
 
#include <boost/thread.hpp>
#include <vector>
 
namespace designlab {
 
template <typename T>
concept CopyAssignable = std::is_copy_assignable<T>::value;
 
template <CopyAssignable T>
class AsyncableData final {
 public:
  AsyncableData() : update_count_(0) {}
  explicit AsyncableData(const T& data) : data_(data), update_count_(0) {}
 
  AsyncableData(const AsyncableData&) = delete;  
  AsyncableData& operator=(const AsyncableData&) =
      delete;                               
  AsyncableData(AsyncableData&&) = delete;  
 
  T GetData() const {
    // 読み取り用のロックをかける.
    // このスコープ { } を抜けるまでロックがかかる.(つまりこの関数が終わるまで)
    boost::shared_lock<boost::shared_mutex> read_lock(mtx_);
    return data_;
  };
 
  void SetData(const T& data) {
    // 書き込み用のロックをかける.
    // まずは,upgrade_lock を用意して,それを unique_lock に変更する.
    boost::upgrade_lock<boost::shared_mutex> upgrade_lock(mtx_);
 
    {
      boost::upgrade_to_unique_lock<boost::shared_mutex> write_lock(
          upgrade_lock);
 
      data_ = data;
      ++update_count_;
    }
  };
 
  int GetUpdateCount() const {
    // 読み取り用のロックをかける.
    // このスコープ { } を抜けるまでロックがかかる.(つまりこの関数が終わるまで)
    boost::shared_lock<boost::shared_mutex> read_lock(mtx_);
    return update_count_;
  };
 
 private:
  mutable boost::shared_mutex mtx_;  
 
  T data_;
 
  int update_count_;
};
 
template <typename T>
class AsyncableData<std::vector<T> > final {
 public:
  AsyncableData() : data_({}), update_count_(0) {}
  explicit AsyncableData(const std::vector<T>& data)
      : data_(data), update_count_(0) {}
 
  AsyncableData(const AsyncableData&) = delete;
 
  AsyncableData& operator=(const AsyncableData&) = delete;
 
  AsyncableData(AsyncableData&&) = delete;
 
  std::vector<T> GetData() const {
    // 読み取り用のロックをかける.
    // このスコープ { } を抜けるまでロックがかかる.(つまりこの関数が終わるまで)
    boost::shared_lock<boost::shared_mutex> read_lock(mtx_);
    return data_;
  };
 
  void SetData(const std::vector<T>& data) {
    // 書き込み用のロックをかける.まずは,upgrade_lockを用意して,
    // それを unique_lock に変更する.
    boost::upgrade_lock<boost::shared_mutex> upgrade_lock(mtx_);
 
    {
      boost::upgrade_to_unique_lock<boost::shared_mutex> write_lock(
          upgrade_lock);
 
      data_ = data;
      ++update_count_;
    }
  };
 
  void PushBack(const T& data) {
    // 書き込み用のロックをかける.
    // まずは,upgrade_lock を用意して,それを unique_lock に変更する.
    boost::upgrade_lock<boost::shared_mutex> upgrade_lock(mtx_);
 
    {
      boost::upgrade_to_unique_lock<boost::shared_mutex> write_lock(
          upgrade_lock);
 
      data_.push_back(data);
      ++update_count_;
    }
  };
 
  void Clean() {
    // 書き込み用のロックをかける.
    // まずは,upgrade_lock を用意して,それを unique_lock に変更する.
    boost::upgrade_lock<boost::shared_mutex> upgrade_lock(mtx_);
 
    {
      boost::upgrade_to_unique_lock<boost::shared_mutex> write_lock(
          upgrade_lock);
 
      data_.clear();
      ++update_count_;
    }
  };
 
  size_t GetSize() const {
    // 読み取り用のロックをかける.
    // このスコープ { } を抜けるまでロックがかかる.(つまりこの関数が終わるまで)
    boost::shared_lock<boost::shared_mutex> read_lock(mtx_);
    return data_.size();
  };
 
  int GetUpdateCount() const {
    // 読み取り用のロックをかける.
    // このスコープ { } を抜けるまでロックがかかる.(つまりこの関数が終わるまで)
    boost::shared_lock<boost::shared_mutex> read_lock(mtx_);
    return update_count_;
  };
 
 private:
  mutable boost::shared_mutex mtx_;  
 
  std::vector<T> data_;
 
  int update_count_;
};
 
}  // namespace designlab
 
#endif  // DESIGNLAB_ASYNCABLE_DATA_H_