PairElementToken.h

Go to the documentation of this file.

 
#pragma once
 
#include <assert.h>
#include <memory>
#include <stdexcept>
 
namespace tvm::internal
{
class PairElementToken;
 
class PairElementTokenHandle
{
public:
  PairElementTokenHandle() = delete;
  PairElementTokenHandle(const PairElementTokenHandle &) = delete;
  PairElementTokenHandle(PairElementTokenHandle &&) = delete;
  PairElementTokenHandle & operator=(const PairElementTokenHandle &) = delete;
  PairElementTokenHandle & operator=(PairElementTokenHandle &&) = delete;
 
  explicit PairElementTokenHandle(PairElementToken & t) noexcept;
 
  bool isValid() const { return token_ != nullptr; }
 
private:
  void invalidate() { token_ = nullptr; }
 
  PairElementToken * token_;
 
  friend PairElementToken;
};
 
class PairElementToken
{
public:
  PairElementToken() noexcept {}
  PairElementToken(const PairElementToken &) = delete;             // To keep a pair valid we cannot duplicate tokens
  PairElementToken & operator=(const PairElementToken &) = delete; // idem
 
  PairElementToken(PairElementToken && other) noexcept : otherPairElement_(other.otherPairElement_)
  {
    other.otherPairElement_ = nullptr; // we need to leave the previous token in an unpaired state.
    if(isPaired())
      otherPairElement_->notifyMove(this); // if paired, we need to notify to otherPairElement_ that this changed place.
  }
 
  PairElementToken(PairElementTokenHandle && h) noexcept : otherPairElement_(h.token_)
  {
    assert(h.isValid());
    h.token_->otherPairElement_ = this;
    h.invalidate();
  }
 
  PairElementToken & operator=(PairElementToken && other) noexcept
  {
    if(isPaired()) // If we move into an already paired token, we basically erase it and its paired element must be
                   // notified
      otherPairElement_->notifyDeath();
    otherPairElement_ = other.otherPairElement_;
    other.otherPairElement_ = nullptr; // we need to leave the previous token in an unpaired state.
    if(isPaired())
      otherPairElement_->notifyMove(this); // if paired, we need to notify to otherPairElement_ that this changed place.
    return *this;
  }
 
  PairElementToken & operator=(PairElementTokenHandle && h) noexcept
  {
    assert(h.isValid());
    if(isPaired()) // If we move into an already paired token, we basically erase it and its  paired element must be
                   // notified
      otherPairElement_->notifyDeath();
    otherPairElement_ = h.token_;
    h.token_->otherPairElement_ = this;
    h.invalidate(); // we need to leave the handle in an invalid state.
    return *this;
  }
 
  ~PairElementToken()
  {
    if(isPaired())
      otherPairElement_->notifyDeath();
  }
 
  void pairWith(PairElementToken & other)
  {
    if(isPaired() || other.isPaired())
      throw std::runtime_error("Can only pair if both tokens are unpaired.");
    otherPairElement_ = &other;
    other.otherPairElement_ = this;
  }
 
  bool isPaired() const { return otherPairElement_ != nullptr; }
 
  bool isPairedWith(const PairElementToken & other) const { return otherPairElement_ == &other; }
 
  const PairElementToken & otherPairElement() const
  {
    if(!isPaired())
      throw std::runtime_error("This token is not paired.");
    return *otherPairElement_;
  }
 
private:
  PairElementToken(PairElementToken * other) : otherPairElement_(other)
  {
    assert(!other->isPaired());
    other->otherPairElement_ = this;
  }
 
  void notifyMove(PairElementToken * newAddress) { otherPairElement_ = newAddress; }
 
  void notifyDeath() { otherPairElement_ = nullptr; }
 
  PairElementToken * otherPairElement_ = nullptr;
};
 
inline PairElementTokenHandle::PairElementTokenHandle(PairElementToken & t) noexcept : token_(&t)
{ assert(!t.isPaired() && "Input token is already paired."); }
} // namespace tvm::internal