Token.h

Go to the documentation of this file.

//============================================================================
//  The contents of this file are covered by the Viskores license. See
//  LICENSE.txt for details.
//
//  By contributing to this file, all contributors agree to the Developer
//  Certificate of Origin Version 1.1 (DCO 1.1) as stated in DCO.txt.
//============================================================================
 
//============================================================================
//  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 viskores_cont_Token_h
#define viskores_cont_Token_h
 
#include <viskores/cont/viskores_cont_export.h>
 
#include <viskores/Types.h>
 
#include <condition_variable>
#include <memory>
#include <mutex>
#include <type_traits>
 
namespace viskores
{
namespace cont
{
 
class VISKORES_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:
  VISKORES_CONT Token();
  VISKORES_CONT Token(Token&& rhs);
  VISKORES_CONT ~Token();
 
  using ReferenceCount = viskores::IdComponent;
 
  VISKORES_CONT void DetachFromAll();
 
  template <typename T>
  VISKORES_CONT void Attach(T&& object,
                            viskores::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>
  VISKORES_CONT void Attach(T&& object,
                            viskores::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);
  }
 
  VISKORES_CONT bool IsAttached(viskores::cont::Token::ReferenceCount* referenceCountPointer) const;
 
  class Reference
  {
    friend Token;
    const void* InternalsPointer;
    VISKORES_CONT Reference(const void* internalsPointer)
      : InternalsPointer(internalsPointer)
    {
    }
 
  public:
    VISKORES_CONT bool operator==(Reference rhs) const
    {
      return this->InternalsPointer == rhs.InternalsPointer;
    }
    VISKORES_CONT bool operator!=(Reference rhs) const
    {
      return this->InternalsPointer != rhs.InternalsPointer;
    }
  };
 
  VISKORES_CONT Reference GetReference() const;
 
private:
  VISKORES_CONT void Attach(
    std::unique_ptr<viskores::cont::Token::ObjectReference>&& objectReference,
    viskores::cont::Token::ReferenceCount* referenceCountPointer,
    std::unique_lock<std::mutex>& lock,
    std::condition_variable* conditionVariablePointer);
 
  VISKORES_CONT bool IsAttached(std::unique_lock<std::mutex>& lock,
                                viskores::cont::Token::ReferenceCount* referenceCountPointer) const;
};
 
VISKORES_CONT inline bool operator==(const viskores::cont::Token& token,
                                     viskores::cont::Token::Reference ref)
{
  return token.GetReference() == ref;
}
VISKORES_CONT inline bool operator!=(const viskores::cont::Token& token,
                                     viskores::cont::Token::Reference ref)
{
  return token.GetReference() != ref;
}
 
VISKORES_CONT inline bool operator==(viskores::cont::Token::Reference ref,
                                     const viskores::cont::Token& token)
{
  return ref == token.GetReference();
}
VISKORES_CONT inline bool operator!=(viskores::cont::Token::Reference ref,
                                     const viskores::cont::Token& token)
{
  return ref != token.GetReference();
}
}
} // namespace viskores::cont
 
#endif //viskores_cont_Token_h