vtkSMPThreadLocalObject.h

Go to the documentation of this file.

/*=========================================================================
 
 Program:   Visualization Toolkit
 Module:    vtkSMPThreadLocalObject.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 vtkSMPThreadLocalObject_h
#define vtkSMPThreadLocalObject_h
 
#include "vtkSMPThreadLocal.h"
 
template <typename T>
class vtkSMPThreadLocalObject
{
  typedef vtkSMPThreadLocal<T*> TLS;
  typedef typename vtkSMPThreadLocal<T*>::iterator TLSIter;
 
  // Hide the copy constructor for now and assignment
  // operator for now.
  vtkSMPThreadLocalObject(const vtkSMPThreadLocalObject&) = delete;
  void operator=(const vtkSMPThreadLocalObject&) = delete;
 
public:
  vtkSMPThreadLocalObject()
    : Internal(nullptr)
    , Exemplar(nullptr)
  {
  }
 
  vtkSMPThreadLocalObject(T* const& exemplar)
    : Internal(0)
    , Exemplar(exemplar)
  {
  }
 
  virtual ~vtkSMPThreadLocalObject()
  {
    iterator iter = this->begin();
    while (iter != this->end())
    {
      if (*iter)
      {
        (*iter)->Delete();
      }
      ++iter;
    }
  }
 
 
  T*& Local()
  {
    T*& vtkobject = this->Internal.Local();
    if (!vtkobject)
    {
      if (this->Exemplar)
      {
        vtkobject = this->Exemplar->NewInstance();
      }
      else
      {
        vtkobject = T::SafeDownCast(T::New());
      }
    }
    return vtkobject;
  }
 
  size_t size() const { return this->Internal.size(); }
 
 
  class iterator
  {
  public:
    iterator& operator++()
    {
      ++this->Iter;
      return *this;
    }
 
    iterator operator++(int)
    {
      iterator copy = *this;
      ++this->Iter;
      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:
    TLSIter Iter;
 
    friend class vtkSMPThreadLocalObject<T>;
  };
 
  iterator begin()
  {
    iterator iter;
    iter.Iter = this->Internal.begin();
    return iter;
  };
 
  iterator end()
  {
    iterator iter;
    iter.Iter = this->Internal.end();
    return iter;
  }
 
private:
  TLS Internal;
  T* Exemplar;
};
 
#endif
// VTK-HeaderTest-Exclude: vtkSMPThreadLocalObject.h