thread_local_object.hpp

Go to the documentation of this file.

#pragma once
#include "mutex.hpp"
#include "thread.hpp"
#include "../func.hpp"
#include "../object.hpp"
#include "../time_span.hpp"
#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;
      auto operator =(const thread_local_object& other) -> thread_local_object& = default;
      
      
      [[nodiscard]] auto is_value_created() const noexcept -> bool {
        lock_guard_mutex lock {data_->mutex};
        return data_->values.find(thread::current_thread().thread_id()) != data_->values.end();
      }
      
      [[nodiscard]] auto value() const noexcept -> value_t {
        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;
      }

      auto value(value_t value) noexcept -> void {
        lock_guard_mutex lock {data_->mutex};
        data_->values[thread::current_thread().thread_id()] = value;
      }
      
      [[nodiscard]] auto values() const -> xtd::array<value_t> {
        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.length() + 1, entry.second);
        return values;
      }

      
      
      [[nodiscard]] auto to_string() const noexcept -> string override {
        return string::format("{}", value());
      }

      
    private:
      mutable xtd::sptr<data> data_ = xtd::new_sptr<data>();
    };
  }
}