GrpcRetryPolicy.h

 
#pragma once
#include <aws/appmesh/AppMesh_EXPORTS.h>
#include <aws/appmesh/model/Duration.h>
#include <aws/appmesh/model/GrpcRetryPolicyEvent.h>
#include <aws/appmesh/model/TcpRetryPolicyEvent.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace AppMesh {
namespace Model {
 
class GrpcRetryPolicy {
 public:
  AWS_APPMESH_API GrpcRetryPolicy() = default;
  AWS_APPMESH_API GrpcRetryPolicy(Aws::Utils::Json::JsonView jsonValue);
  AWS_APPMESH_API GrpcRetryPolicy& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_APPMESH_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::Vector<GrpcRetryPolicyEvent>& GetGrpcRetryEvents() const { return m_grpcRetryEvents; }
  inline bool GrpcRetryEventsHasBeenSet() const { return m_grpcRetryEventsHasBeenSet; }
  template <typename GrpcRetryEventsT = Aws::Vector<GrpcRetryPolicyEvent>>
  void SetGrpcRetryEvents(GrpcRetryEventsT&& value) {
    m_grpcRetryEventsHasBeenSet = true;
    m_grpcRetryEvents = std::forward<GrpcRetryEventsT>(value);
  }
  template <typename GrpcRetryEventsT = Aws::Vector<GrpcRetryPolicyEvent>>
  GrpcRetryPolicy& WithGrpcRetryEvents(GrpcRetryEventsT&& value) {
    SetGrpcRetryEvents(std::forward<GrpcRetryEventsT>(value));
    return *this;
  }
  inline GrpcRetryPolicy& AddGrpcRetryEvents(GrpcRetryPolicyEvent value) {
    m_grpcRetryEventsHasBeenSet = true;
    m_grpcRetryEvents.push_back(value);
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetHttpRetryEvents() const { return m_httpRetryEvents; }
  inline bool HttpRetryEventsHasBeenSet() const { return m_httpRetryEventsHasBeenSet; }
  template <typename HttpRetryEventsT = Aws::Vector<Aws::String>>
  void SetHttpRetryEvents(HttpRetryEventsT&& value) {
    m_httpRetryEventsHasBeenSet = true;
    m_httpRetryEvents = std::forward<HttpRetryEventsT>(value);
  }
  template <typename HttpRetryEventsT = Aws::Vector<Aws::String>>
  GrpcRetryPolicy& WithHttpRetryEvents(HttpRetryEventsT&& value) {
    SetHttpRetryEvents(std::forward<HttpRetryEventsT>(value));
    return *this;
  }
  template <typename HttpRetryEventsT = Aws::String>
  GrpcRetryPolicy& AddHttpRetryEvents(HttpRetryEventsT&& value) {
    m_httpRetryEventsHasBeenSet = true;
    m_httpRetryEvents.emplace_back(std::forward<HttpRetryEventsT>(value));
    return *this;
  }
 
 
  inline long long GetMaxRetries() const { return m_maxRetries; }
  inline bool MaxRetriesHasBeenSet() const { return m_maxRetriesHasBeenSet; }
  inline void SetMaxRetries(long long value) {
    m_maxRetriesHasBeenSet = true;
    m_maxRetries = value;
  }
  inline GrpcRetryPolicy& WithMaxRetries(long long value) {
    SetMaxRetries(value);
    return *this;
  }
 
 
  inline const Duration& GetPerRetryTimeout() const { return m_perRetryTimeout; }
  inline bool PerRetryTimeoutHasBeenSet() const { return m_perRetryTimeoutHasBeenSet; }
  template <typename PerRetryTimeoutT = Duration>
  void SetPerRetryTimeout(PerRetryTimeoutT&& value) {
    m_perRetryTimeoutHasBeenSet = true;
    m_perRetryTimeout = std::forward<PerRetryTimeoutT>(value);
  }
  template <typename PerRetryTimeoutT = Duration>
  GrpcRetryPolicy& WithPerRetryTimeout(PerRetryTimeoutT&& value) {
    SetPerRetryTimeout(std::forward<PerRetryTimeoutT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<TcpRetryPolicyEvent>& GetTcpRetryEvents() const { return m_tcpRetryEvents; }
  inline bool TcpRetryEventsHasBeenSet() const { return m_tcpRetryEventsHasBeenSet; }
  template <typename TcpRetryEventsT = Aws::Vector<TcpRetryPolicyEvent>>
  void SetTcpRetryEvents(TcpRetryEventsT&& value) {
    m_tcpRetryEventsHasBeenSet = true;
    m_tcpRetryEvents = std::forward<TcpRetryEventsT>(value);
  }
  template <typename TcpRetryEventsT = Aws::Vector<TcpRetryPolicyEvent>>
  GrpcRetryPolicy& WithTcpRetryEvents(TcpRetryEventsT&& value) {
    SetTcpRetryEvents(std::forward<TcpRetryEventsT>(value));
    return *this;
  }
  inline GrpcRetryPolicy& AddTcpRetryEvents(TcpRetryPolicyEvent value) {
    m_tcpRetryEventsHasBeenSet = true;
    m_tcpRetryEvents.push_back(value);
    return *this;
  }
 private:
  Aws::Vector<GrpcRetryPolicyEvent> m_grpcRetryEvents;
 
  Aws::Vector<Aws::String> m_httpRetryEvents;
 
  long long m_maxRetries{0};
 
  Duration m_perRetryTimeout;
 
  Aws::Vector<TcpRetryPolicyEvent> m_tcpRetryEvents;
  bool m_grpcRetryEventsHasBeenSet = false;
  bool m_httpRetryEventsHasBeenSet = false;
  bool m_maxRetriesHasBeenSet = false;
  bool m_perRetryTimeoutHasBeenSet = false;
  bool m_tcpRetryEventsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace AppMesh
}  // namespace Aws