thread_local_object.h

Go to the documentation of this file.

 
#pragma once
#include "mutex.h"
#include "thread.h"
#include "../func.h"
#include "../invalid_operation_exception.h"
#include "../object.h"
#include "../time_span.h"
#include <map>
 
namespace xtd {
  namespace threading {
    template<typename value_t>
    class thread_local_object : public object {
      struct data : public object {
        threading::mutex mutex;
        bool track_all_values = false;
        func<value_t> value_factory;
        std::map<intptr, value_t> values;
      };
 
      struct lock_guard_mutex {
        lock_guard_mutex(mutex& mutex) : mutex_(mutex) {mutex_.lock();}
        ~lock_guard_mutex() {mutex_.unlock();}
      private:
        mutex& mutex_;
      };
 
    public:
      
      thread_local_object() = default;
      explicit thread_local_object(bool track_all_values) {data_->track_all_values = track_all_values;}
      explicit thread_local_object(const func<value_t>& value_factory) {data_->value_factory = value_factory;}
      thread_local_object(const func<value_t>& value_factory, bool track_all_values) {
        data_->value_factory = value_factory;
        data_->track_all_values = track_all_values;
      }
 
      template<typename func_t>
      explicit thread_local_object(func_t value_factory) : thread_local_object(func<value_t> {value_factory}) {}
      template<typename func_t>
      explicit thread_local_object(func_t value_factory, bool track_all_values) : thread_local_object(func<value_t> {value_factory}, track_all_values) {}
      thread_local_object(thread_local_object&&) = default;
      thread_local_object(const thread_local_object&) = default;
      thread_local_object& operator =(const thread_local_object& other) = default;
 
      
      bool is_value_created() const noexcept {
        lock_guard_mutex lock {data_->mutex};
        return data_->values.find(thread::current_thread().thread_id()) != data_->values.end();
      }
 
      value_t value() const noexcept {
        lock_guard_mutex lock {data_->mutex};
        if (!is_value_created()) data_->values[thread::current_thread().thread_id()] = data_->value_factory.is_empty() ? value_t {} : data_->values[thread::current_thread().thread_id()] = data_->value_factory();
        return data_->values.find(thread::current_thread().thread_id())->second;
      }
      
      void value(value_t value) noexcept {
        lock_guard_mutex lock {data_->mutex};
        data_->values[thread::current_thread().thread_id()] = value;
      }
      
      std::vector<value_t> values() const {
        if (!data_->track_all_values) throw invalid_operation_exception(csf_);
        lock_guard_mutex lock {data_->mutex};
        auto values = std::vector<value_t> {};
        for (const auto& entry : data_->values)
          values.push_back(entry.second);
        return values;
      }
 
      
      ustring to_string() const noexcept override {
        return ustring::format("{}", value());
      }
 
    private:
      mutable std::shared_ptr<data> data_ = std::make_shared<data>();
    };
  }
}