chaiscript_threading.hpp

Go to the documentation of this file.

// This file is distributed under the BSD License.
// See "license.txt" for details.
// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
// Copyright 2009-2017, Jason Turner (jason@emptycrate.com)
// http://www.chaiscript.com
 
// This is an open source non-commercial project. Dear PVS-Studio, please check it.
// PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
 
 
#ifndef CHAISCRIPT_THREADING_HPP_
#define CHAISCRIPT_THREADING_HPP_
 
 
#include <unordered_map>
 
#ifndef CHAISCRIPT_NO_THREADS
#include <thread>
#include <mutex>
#else
#ifndef CHAISCRIPT_NO_THREADS_WARNING
#pragma message ("ChaiScript is compiling without thread safety.")
#endif
#endif
 
#include "chaiscript_defines.hpp"

 
namespace chaiscript
{
  namespace detail
  {
    namespace threading
    {
 
#ifndef CHAISCRIPT_NO_THREADS
 
      template<typename T>
        using unique_lock = std::unique_lock<T>;
 
      template<typename T>
        using shared_lock = std::unique_lock<T>;
 
      template<typename T>
        using lock_guard = std::lock_guard<T>;
 
 
      using shared_mutex = std::mutex;
 
      using std::mutex;
 
      using std::recursive_mutex;

      template<typename T>
        class Thread_Storage
        {
          public:
            Thread_Storage() = default;
            Thread_Storage(const Thread_Storage &) = delete;
            Thread_Storage(Thread_Storage &&) = delete;
            Thread_Storage &operator=(const Thread_Storage &) = delete;
            Thread_Storage &operator=(Thread_Storage &&) = delete;
 
            ~Thread_Storage()
            {
              t().erase(this);
            }
 
            inline const T *operator->() const
            {
              return &(t()[this]);
            }
 
            inline const T &operator*() const
            {
              return t()[this];
            }
 
            inline T *operator->()
            {
              return &(t()[this]);
            }
 
            inline T &operator*()
            {
              return t()[this];
            }
 
 
            void *m_key;
 
          private:
            static std::unordered_map<const void*, T> &t()
            {
              thread_local std::unordered_map<const void *, T> my_t;
              return my_t;
            }
        };
 
#else // threading disabled
      template<typename T>
      class unique_lock 
      {
        public:
          explicit unique_lock(T &) {}
          void lock() {}
          void unlock() {}
      };
 
      template<typename T>
      class shared_lock 
      {
        public:
          explicit shared_lock(T &) {}
          void lock() {}
          void unlock() {}
      };
 
      template<typename T>
      class lock_guard 
      {
        public:
          explicit lock_guard(T &) {}
      };
 
      class shared_mutex { };
 
      class recursive_mutex {};
 
 
      template<typename T>
        class Thread_Storage
        {
          public:
            explicit Thread_Storage()
            {
            }
 
            inline T *operator->() const
            {
              return &obj;
            }
 
            inline T &operator*() const
            {
              return obj;
            }
 
          private:
            mutable T obj;
        };
 
#endif
    }
  }
}
 
 
 
#endif