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&);
  void operator=(const vtkSMPThreadLocalObject&);

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