thread_local_object.hpp

Go to the documentation of this file.

#pragma once
#include "mutex.hpp"
#include "thread.hpp"
#include "../func.hpp"
#include "../invalid_operation_exception.hpp"
#include "../object.hpp"
#include "../time_span.hpp"
#include <map>

namespace xtd {
  namespace threading {
    template<class 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;
      }
      thread_local_object(const func<value_t>& value_factory, bool track_all_values) {…}


      template<class func_t>
      explicit thread_local_object(func_t value_factory) : thread_local_object(func<value_t> {value_factory}) {}
      template<class 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();
      }
      bool is_value_created() const noexcept {…}

      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;
      }
      value_t value() const noexcept {…}
      
      void value(value_t value) noexcept {
        lock_guard_mutex lock {data_->mutex};
        data_->values[thread::current_thread().thread_id()] = value;
      }
      void value(value_t value) noexcept {…}
      
      xtd::array<value_t> values() const {
        if (!data_->track_all_values) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation);
        lock_guard_mutex lock {data_->mutex};
        auto values = xtd::array<value_t> {};
        for (const auto& entry : data_->values)
          values.resize(values.size() + 1, entry.second);
        return values;
      }
      xtd::array<value_t> values() const  {…}


      
      string to_string() const noexcept override {
        return string::format("{}", value());
      }
      string to_string() const noexcept override  {…}

 
    private:
      mutable xtd::sptr<data> data_ = xtd::new_sptr<data>();
    };
    class thread_local_object : public object {…};
  }
}