operation.hpp

Go to the documentation of this file.

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
 
#pragma once
 
#include "azure/core/context.hpp"
#include "azure/core/operation_status.hpp"
#include "azure/core/response.hpp"
 
#include <chrono>
#include <memory>
#include <stdexcept>
#include <string>
 
namespace Azure { namespace Core {
 
  template <class T> class Operation {
  private:
    // These are pure virtual b/c the derived class must provide an implementation
    virtual std::unique_ptr<Http::RawResponse> PollInternal(Context const& context) = 0;
    virtual Response<T> PollUntilDoneInternal(std::chrono::milliseconds period, Context& context)
        = 0;
 
    [[deprecated("Do not override and do not use.")]] virtual Azure::Core::Http::RawResponse const&
    GetRawResponseInternal() const
    {
      return *m_rawResponse;
    }
 
  protected:
    std::unique_ptr<Azure::Core::Http::RawResponse> m_rawResponse = nullptr;
 
    OperationStatus m_status = OperationStatus::NotStarted;
 
    Operation() = default;
 
    // Define how an Operation<T> can be move-constructed from rvalue other. Parameter `other`
    // gave up ownership for the rawResponse.
    Operation(Operation&& other)
        : m_rawResponse(std::move(other.m_rawResponse)), m_status(other.m_status)
    {
    }
 
    // Define how an Operation<T> can be copy-constructed from some other Operation reference.
    // Operation will create a clone of the rawResponse from `other`.
    Operation(Operation const& other)
        : m_rawResponse(std::make_unique<Http::RawResponse>(other.GetRawResponse())),
          m_status(other.m_status)
    {
    }
 
    // Define how an Operation<T> can be move-assigned from rvalue other. Parameter `other`
    // gave up ownership for the rawResponse.
    Operation& operator=(Operation&& other)
    {
      this->m_rawResponse = std::move(other.m_rawResponse);
      this->m_status = other.m_status;
      return *this;
    }
 
    // Define how an Operation<T> can be copy-assigned from some other Operation reference.
    // Operation will create a clone of the rawResponse from `other`.
    Operation& operator=(Operation const& other)
    {
      this->m_rawResponse = std::make_unique<Http::RawResponse>(other.GetRawResponse());
      this->m_status = other.m_status;
      return *this;
    }
 
  public:
    virtual ~Operation() {}
 
    virtual T Value() const = 0;
 
    virtual std::string GetResumeToken() const = 0;
 
    Azure::Core::Http::RawResponse const& GetRawResponse() const
    {
      if (!m_rawResponse)
      {
        throw std::runtime_error("The raw response was not yet set for the Operation.");
      }
      return *m_rawResponse;
    }
 
    OperationStatus const& Status() const noexcept { return m_status; }
 
    bool IsDone() const noexcept
    {
      return (
          m_status == OperationStatus::Succeeded || m_status == OperationStatus::Cancelled
          || m_status == OperationStatus::Failed);
    }
 
    bool HasValue() const noexcept { return (m_status == OperationStatus::Succeeded); }
 
    Http::RawResponse const& Poll()
    {
      // In the cases where the customer doesn't want to use a context we new one up and pass it
      // through
      return Poll(Context{});
    }
 
    Http::RawResponse const& Poll(Context const& context)
    {
      context.ThrowIfCancelled();
      m_rawResponse = PollInternal(context);
      return *m_rawResponse;
    }
 
    Response<T> PollUntilDone(std::chrono::milliseconds period)
    {
      // In the cases where the customer doesn't want to use a context we new one up and pass it
      // through
      Context context;
      return PollUntilDone(period, context);
    }
 
    Response<T> PollUntilDone(std::chrono::milliseconds period, Context& context)
    {
      context.ThrowIfCancelled();
      return PollUntilDoneInternal(period, context);
    }
  };
}} // namespace Azure::Core