Public API Reference

csutil/threading/tls.h

Go to the documentation of this file.

/*
  Copyright (C) 2008 by Michael Gist

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Library General Public License for more details.

  You should have received a copy of the GNU Library General Public
  License along with this library; if not, write to the Free
  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#ifndef __CS_CSUTIL_THREADING_TLS_H__
#define __CS_CSUTIL_THREADING_TLS_H__

#include "../noncopyable.h"

#if defined(CS_PLATFORM_WIN32)
# include "csutil/threading/win32_tls.h"
#elif defined(CS_PLATFORM_UNIX) || \
  defined(CS_PLATFORM_MACOSX)
# include "csutil/threading/pthread_tls.h"
#else
  #ifndef DOXYGEN_RUN
    #error "No TLS implementation for your platform"
  #endif
#endif

namespace CS
{
  namespace Threading
  {
    using namespace Implementation;
    
#ifdef DOXYGEN_RUN

      class ThreadLocalBase
      {
      public:
        typedef void (* DestructorFn)(void*);
        
        ThreadLocalBase (DestructorFn dtor = 0);
        ~ThreadLocalBase();
        void SetValue (void* data) const;
        void* GetValue () const;
      };
#endif

    template<typename T>
    class ThreadLocal : protected ThreadLocalBase,
                        public CS::NonCopyable
    {
      static void Destructor (void* p)
      {
        delete reinterpret_cast<T*> (p);
      }
      
      T& GetObject() const
      {
        T* p = reinterpret_cast<T*> (ThreadLocalBase::GetValue ());
        if (p == 0)
        {
          p = new T;
          ThreadLocalBase::SetValue (p);
        }
        return *p;
      }
    public:
      ThreadLocal() : ThreadLocalBase (Destructor)
      {
      }
      ~ThreadLocal()
      {
        // Destructor function does _not_ kick in when deleting the TLS slot!
        T* p = reinterpret_cast<T*> (ThreadLocalBase::GetValue ());
        delete p;
      }
      
      bool HasValue() const
      {
        return ThreadLocalBase::GetValue () != 0;
      }

      operator T& () const
      {
        return GetObject();
      }
      
      T* operator->() const
      {
        return &(GetObject());
      }
      
      T& operator *() const
      {
        return GetObject();
      }

      ThreadLocal& operator = (const T& other)
      {
        T* p = reinterpret_cast<T*> (ThreadLocalBase::GetValue ());
        if (p == 0)
        {
          p = new T (other);
          ThreadLocalBase::SetValue (p);
        }
        else
          *p = other;
        return *this;
      } 
    };
  } // Threading
} // CS

#endif // __CS_CSUTIL_THREADING_TLS_H__

---