HttpRetryPolicy.h

 
#pragma once
#include <aws/appmesh/AppMesh_EXPORTS.h>
#include <aws/appmesh/model/Duration.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 HttpRetryPolicy {
 public:
  AWS_APPMESH_API HttpRetryPolicy() = default;
  AWS_APPMESH_API HttpRetryPolicy(Aws::Utils::Json::JsonView jsonValue);
  AWS_APPMESH_API HttpRetryPolicy& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_APPMESH_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  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>>
  HttpRetryPolicy& WithHttpRetryEvents(HttpRetryEventsT&& value) {
    SetHttpRetryEvents(std::forward<HttpRetryEventsT>(value));
    return *this;
  }
  template <typename HttpRetryEventsT = Aws::String>
  HttpRetryPolicy& 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 HttpRetryPolicy& 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>
  HttpRetryPolicy& 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>>
  HttpRetryPolicy& WithTcpRetryEvents(TcpRetryEventsT&& value) {
    SetTcpRetryEvents(std::forward<TcpRetryEventsT>(value));
    return *this;
  }
  inline HttpRetryPolicy& AddTcpRetryEvents(TcpRetryPolicyEvent value) {
    m_tcpRetryEventsHasBeenSet = true;
    m_tcpRetryEvents.push_back(value);
    return *this;
  }
 private:
  Aws::Vector<Aws::String> m_httpRetryEvents;
 
  long long m_maxRetries{0};
 
  Duration m_perRetryTimeout;
 
  Aws::Vector<TcpRetryPolicyEvent> m_tcpRetryEvents;
  bool m_httpRetryEventsHasBeenSet = false;
  bool m_maxRetriesHasBeenSet = false;
  bool m_perRetryTimeoutHasBeenSet = false;
  bool m_tcpRetryEventsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace AppMesh
}  // namespace Aws