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 <vector>
 
#include <boost/thread.hpp>
 
 
// テンプレートの実装はヘッダーに書く．
// https://qiita.com/i153/items/38f9688a9c80b2cb7da7 (アクセス日 2023/12/25)
 
 
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_