Token.h

Go to the documentation of this file.

//============================================================================
//  Copyright (c) Kitware, Inc.
//  All rights reserved.
//  See LICENSE.txt 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 vtk_m_cont_Token_h
#define vtk_m_cont_Token_h
 
#include <vtkm/cont/vtkm_cont_export.h>
 
#include <vtkm/Types.h>
 
#include <condition_variable>
#include <memory>
#include <mutex>
#include <type_traits>
 
namespace vtkm
{
namespace cont
{
 
class VTKM_CONT_EXPORT Token final
{
  class InternalStruct;
  mutable std::unique_ptr<InternalStruct> Internals;
 
  struct HeldReference;
 
  struct ObjectReference
  {
    virtual ~ObjectReference() = default;
  };
 
  template <typename ObjectType>
  struct ObjectReferenceImpl : ObjectReference
  {
    ObjectType Object;
 
    ObjectReferenceImpl(const ObjectType& object)
      : Object(object)
    {
    }
 
    ObjectReferenceImpl(ObjectType&& object)
      : Object(std::move(object))
    {
    }
 
    ObjectReferenceImpl() = delete;
    ObjectReferenceImpl(const ObjectReferenceImpl&) = delete;
 
    ~ObjectReferenceImpl() override = default;
  };
 
public:
  VTKM_CONT Token();
  VTKM_CONT Token(Token&& rhs);
  VTKM_CONT ~Token();
 
  using ReferenceCount = vtkm::IdComponent;
 
  VTKM_CONT void DetachFromAll();
 
  template <typename T>
  VTKM_CONT void Attach(T&& object,
                        vtkm::cont::Token::ReferenceCount* referenceCountPointer,
                        std::unique_lock<std::mutex>& lock,
                        std::condition_variable* conditionVariablePointer)
  {
    this->Attach(std::unique_ptr<ObjectReference>(
                   new ObjectReferenceImpl<typename std::decay<T>::type>(std::forward<T>(object))),
                 referenceCountPointer,
                 lock,
                 conditionVariablePointer);
  }
 
  template <typename T>
  VTKM_CONT void Attach(T&& object,
                        vtkm::cont::Token::ReferenceCount* referenceCountPoiner,
                        std::mutex* mutexPointer,
                        std::condition_variable* conditionVariablePointer)
  {
    std::unique_lock<std::mutex> lock(*mutexPointer, std::defer_lock);
    this->Attach(std::forward<T>(object), referenceCountPoiner, lock, conditionVariablePointer);
  }
 
  VTKM_CONT bool IsAttached(vtkm::cont::Token::ReferenceCount* referenceCountPointer) const;
 
  class Reference
  {
    friend Token;
    const void* InternalsPointer;
    VTKM_CONT Reference(const void* internalsPointer)
      : InternalsPointer(internalsPointer)
    {
    }
 
  public:
    VTKM_CONT bool operator==(Reference rhs) const
    {
      return this->InternalsPointer == rhs.InternalsPointer;
    }
    VTKM_CONT bool operator!=(Reference rhs) const
    {
      return this->InternalsPointer != rhs.InternalsPointer;
    }
  };
 
  VTKM_CONT Reference GetReference() const;
 
private:
  VTKM_CONT void Attach(std::unique_ptr<vtkm::cont::Token::ObjectReference>&& objectReference,
                        vtkm::cont::Token::ReferenceCount* referenceCountPointer,
                        std::unique_lock<std::mutex>& lock,
                        std::condition_variable* conditionVariablePointer);
 
  VTKM_CONT bool IsAttached(std::unique_lock<std::mutex>& lock,
                            vtkm::cont::Token::ReferenceCount* referenceCountPointer) const;
};
 
VTKM_CONT inline bool operator==(const vtkm::cont::Token& token, vtkm::cont::Token::Reference ref)
{
  return token.GetReference() == ref;
}
VTKM_CONT inline bool operator!=(const vtkm::cont::Token& token, vtkm::cont::Token::Reference ref)
{
  return token.GetReference() != ref;
}
 
VTKM_CONT inline bool operator==(vtkm::cont::Token::Reference ref, const vtkm::cont::Token& token)
{
  return ref == token.GetReference();
}
VTKM_CONT inline bool operator!=(vtkm::cont::Token::Reference ref, const vtkm::cont::Token& token)
{
  return ref != token.GetReference();
}
}
} // namespace vtkm::cont
 
#endif //vtk_m_cont_Token_h