vtkSMPThreadLocal.h

Go to the documentation of this file.

 /*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkSMPThreadLocal.h

  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.

=========================================================================*/
#ifndef vtkSMPThreadLocal_h
#define vtkSMPThreadLocal_h

#include "vtkSystemIncludes.h"

#include <vector>

template <typename T>
class vtkSMPThreadLocal
{
  typedef std::vector<T> TLS;
  typedef typename TLS::iterator TLSIter;
public:

  vtkSMPThreadLocal() : NumInitialized(0)
    {
      this->Initialize();
    }


  vtkSMPThreadLocal(const T& exemplar) : NumInitialized(0), Exemplar(exemplar)
    {
      this->Initialize();
    }


  T& Local()
    {
      int tid = this->GetThreadID();
      if (!this->Initialized[tid])
        {
        this->Internal[tid] = this->Exemplar;
        this->Initialized[tid] = true;
        ++this->NumInitialized;
        }
      return this->Internal[tid];
    }


  size_t size() const
    {
      return this->NumInitialized;
    }


  class iterator
  {
  public:
    iterator& operator++()
      {
        this->InitIter++;
        this->Iter++;

        // Make sure to skip uninitialized
        // entries.
        while(this->InitIter != this->EndIter)
          {
          if (*this->InitIter)
            {
            break;
            }
          this->InitIter++;
          this->Iter++;
          }
        return *this;
      }

    iterator operator++(int)
      {
      iterator copy = *this;
      ++(*this);
      return copy;
      }

    bool operator==(const iterator& other)
      {
        return this->Iter == other.Iter;
      }

    bool operator!=(const iterator& other)
      {
        return this->Iter != other.Iter;
      }

    T& operator*()
      {
        return *this->Iter;
      }

    T* operator->()
      {
        return &*this->Iter;
      }

  private:
    friend class vtkSMPThreadLocal<T>;
    std::vector<bool>::iterator InitIter;
    std::vector<bool>::iterator EndIter;
    TLSIter Iter;
  };


  iterator begin()
    {
      TLSIter iter = this->Internal.begin();
      std::vector<bool>::iterator iter2 =
        this->Initialized.begin();
      std::vector<bool>::iterator enditer =
        this->Initialized.end();
      // fast forward to first initialized
      // value
      while(iter2 != enditer)
        {
        if (*iter2)
          {
          break;
          }
        iter2++;
        iter++;
        }
      iterator retVal;
      retVal.InitIter = iter2;
      retVal.EndIter = enditer;
      retVal.Iter = iter;
      return retVal;
    };


  iterator end()
    {
      iterator retVal;
      retVal.InitIter = this->Initialized.end();
      retVal.EndIter = this->Initialized.end();
      retVal.Iter = this->Internal.end();
      return retVal;
    }

private:
  TLS Internal;
  std::vector<bool> Initialized;
  size_t NumInitialized;
  T Exemplar;

  void Initialize()
    {
      this->Internal.resize(this->GetNumberOfThreads());
      this->Initialized.resize(this->GetNumberOfThreads());
      std::fill(this->Initialized.begin(),
                this->Initialized.end(),
                false);
    }

  inline int GetNumberOfThreads()
    {
      return 1;
    }

  inline int GetThreadID()
    {
      return 0;
    }
};
#endif
// VTK-HeaderTest-Exclude: vtkSMPThreadLocal.h