ConfigurationTemplate.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/logs/CloudWatchLogs_EXPORTS.h>
#include <aws/logs/model/ConfigurationTemplateDeliveryConfigValues.h>
#include <aws/logs/model/DeliveryDestinationType.h>
#include <aws/logs/model/DeliverySourceConfigurationSchema.h>
#include <aws/logs/model/OutputFormat.h>
#include <aws/logs/model/RecordField.h>
#include <aws/logs/model/S3TablesIntegration.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace CloudWatchLogs {
namespace Model {
 
class ConfigurationTemplate {
 public:
  AWS_CLOUDWATCHLOGS_API ConfigurationTemplate() = default;
  AWS_CLOUDWATCHLOGS_API ConfigurationTemplate(Aws::Utils::Json::JsonView jsonValue);
  AWS_CLOUDWATCHLOGS_API ConfigurationTemplate& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_CLOUDWATCHLOGS_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetService() const { return m_service; }
  inline bool ServiceHasBeenSet() const { return m_serviceHasBeenSet; }
  template <typename ServiceT = Aws::String>
  void SetService(ServiceT&& value) {
    m_serviceHasBeenSet = true;
    m_service = std::forward<ServiceT>(value);
  }
  template <typename ServiceT = Aws::String>
  ConfigurationTemplate& WithService(ServiceT&& value) {
    SetService(std::forward<ServiceT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetLogType() const { return m_logType; }
  inline bool LogTypeHasBeenSet() const { return m_logTypeHasBeenSet; }
  template <typename LogTypeT = Aws::String>
  void SetLogType(LogTypeT&& value) {
    m_logTypeHasBeenSet = true;
    m_logType = std::forward<LogTypeT>(value);
  }
  template <typename LogTypeT = Aws::String>
  ConfigurationTemplate& WithLogType(LogTypeT&& value) {
    SetLogType(std::forward<LogTypeT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetResourceType() const { return m_resourceType; }
  inline bool ResourceTypeHasBeenSet() const { return m_resourceTypeHasBeenSet; }
  template <typename ResourceTypeT = Aws::String>
  void SetResourceType(ResourceTypeT&& value) {
    m_resourceTypeHasBeenSet = true;
    m_resourceType = std::forward<ResourceTypeT>(value);
  }
  template <typename ResourceTypeT = Aws::String>
  ConfigurationTemplate& WithResourceType(ResourceTypeT&& value) {
    SetResourceType(std::forward<ResourceTypeT>(value));
    return *this;
  }
 
 
  inline DeliveryDestinationType GetDeliveryDestinationType() const { return m_deliveryDestinationType; }
  inline bool DeliveryDestinationTypeHasBeenSet() const { return m_deliveryDestinationTypeHasBeenSet; }
  inline void SetDeliveryDestinationType(DeliveryDestinationType value) {
    m_deliveryDestinationTypeHasBeenSet = true;
    m_deliveryDestinationType = value;
  }
  inline ConfigurationTemplate& WithDeliveryDestinationType(DeliveryDestinationType value) {
    SetDeliveryDestinationType(value);
    return *this;
  }
 
 
  inline const ConfigurationTemplateDeliveryConfigValues& GetDefaultDeliveryConfigValues() const { return m_defaultDeliveryConfigValues; }
  inline bool DefaultDeliveryConfigValuesHasBeenSet() const { return m_defaultDeliveryConfigValuesHasBeenSet; }
  template <typename DefaultDeliveryConfigValuesT = ConfigurationTemplateDeliveryConfigValues>
  void SetDefaultDeliveryConfigValues(DefaultDeliveryConfigValuesT&& value) {
    m_defaultDeliveryConfigValuesHasBeenSet = true;
    m_defaultDeliveryConfigValues = std::forward<DefaultDeliveryConfigValuesT>(value);
  }
  template <typename DefaultDeliveryConfigValuesT = ConfigurationTemplateDeliveryConfigValues>
  ConfigurationTemplate& WithDefaultDeliveryConfigValues(DefaultDeliveryConfigValuesT&& value) {
    SetDefaultDeliveryConfigValues(std::forward<DefaultDeliveryConfigValuesT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<RecordField>& GetAllowedFields() const { return m_allowedFields; }
  inline bool AllowedFieldsHasBeenSet() const { return m_allowedFieldsHasBeenSet; }
  template <typename AllowedFieldsT = Aws::Vector<RecordField>>
  void SetAllowedFields(AllowedFieldsT&& value) {
    m_allowedFieldsHasBeenSet = true;
    m_allowedFields = std::forward<AllowedFieldsT>(value);
  }
  template <typename AllowedFieldsT = Aws::Vector<RecordField>>
  ConfigurationTemplate& WithAllowedFields(AllowedFieldsT&& value) {
    SetAllowedFields(std::forward<AllowedFieldsT>(value));
    return *this;
  }
  template <typename AllowedFieldsT = RecordField>
  ConfigurationTemplate& AddAllowedFields(AllowedFieldsT&& value) {
    m_allowedFieldsHasBeenSet = true;
    m_allowedFields.emplace_back(std::forward<AllowedFieldsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<OutputFormat>& GetAllowedOutputFormats() const { return m_allowedOutputFormats; }
  inline bool AllowedOutputFormatsHasBeenSet() const { return m_allowedOutputFormatsHasBeenSet; }
  template <typename AllowedOutputFormatsT = Aws::Vector<OutputFormat>>
  void SetAllowedOutputFormats(AllowedOutputFormatsT&& value) {
    m_allowedOutputFormatsHasBeenSet = true;
    m_allowedOutputFormats = std::forward<AllowedOutputFormatsT>(value);
  }
  template <typename AllowedOutputFormatsT = Aws::Vector<OutputFormat>>
  ConfigurationTemplate& WithAllowedOutputFormats(AllowedOutputFormatsT&& value) {
    SetAllowedOutputFormats(std::forward<AllowedOutputFormatsT>(value));
    return *this;
  }
  inline ConfigurationTemplate& AddAllowedOutputFormats(OutputFormat value) {
    m_allowedOutputFormatsHasBeenSet = true;
    m_allowedOutputFormats.push_back(value);
    return *this;
  }
 
 
  inline const Aws::String& GetAllowedActionForAllowVendedLogsDeliveryForResource() const {
    return m_allowedActionForAllowVendedLogsDeliveryForResource;
  }
  inline bool AllowedActionForAllowVendedLogsDeliveryForResourceHasBeenSet() const {
    return m_allowedActionForAllowVendedLogsDeliveryForResourceHasBeenSet;
  }
  template <typename AllowedActionForAllowVendedLogsDeliveryForResourceT = Aws::String>
  void SetAllowedActionForAllowVendedLogsDeliveryForResource(AllowedActionForAllowVendedLogsDeliveryForResourceT&& value) {
    m_allowedActionForAllowVendedLogsDeliveryForResourceHasBeenSet = true;
    m_allowedActionForAllowVendedLogsDeliveryForResource = std::forward<AllowedActionForAllowVendedLogsDeliveryForResourceT>(value);
  }
  template <typename AllowedActionForAllowVendedLogsDeliveryForResourceT = Aws::String>
  ConfigurationTemplate& WithAllowedActionForAllowVendedLogsDeliveryForResource(
      AllowedActionForAllowVendedLogsDeliveryForResourceT&& value) {
    SetAllowedActionForAllowVendedLogsDeliveryForResource(std::forward<AllowedActionForAllowVendedLogsDeliveryForResourceT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetAllowedFieldDelimiters() const { return m_allowedFieldDelimiters; }
  inline bool AllowedFieldDelimitersHasBeenSet() const { return m_allowedFieldDelimitersHasBeenSet; }
  template <typename AllowedFieldDelimitersT = Aws::Vector<Aws::String>>
  void SetAllowedFieldDelimiters(AllowedFieldDelimitersT&& value) {
    m_allowedFieldDelimitersHasBeenSet = true;
    m_allowedFieldDelimiters = std::forward<AllowedFieldDelimitersT>(value);
  }
  template <typename AllowedFieldDelimitersT = Aws::Vector<Aws::String>>
  ConfigurationTemplate& WithAllowedFieldDelimiters(AllowedFieldDelimitersT&& value) {
    SetAllowedFieldDelimiters(std::forward<AllowedFieldDelimitersT>(value));
    return *this;
  }
  template <typename AllowedFieldDelimitersT = Aws::String>
  ConfigurationTemplate& AddAllowedFieldDelimiters(AllowedFieldDelimitersT&& value) {
    m_allowedFieldDelimitersHasBeenSet = true;
    m_allowedFieldDelimiters.emplace_back(std::forward<AllowedFieldDelimitersT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetAllowedSuffixPathFields() const { return m_allowedSuffixPathFields; }
  inline bool AllowedSuffixPathFieldsHasBeenSet() const { return m_allowedSuffixPathFieldsHasBeenSet; }
  template <typename AllowedSuffixPathFieldsT = Aws::Vector<Aws::String>>
  void SetAllowedSuffixPathFields(AllowedSuffixPathFieldsT&& value) {
    m_allowedSuffixPathFieldsHasBeenSet = true;
    m_allowedSuffixPathFields = std::forward<AllowedSuffixPathFieldsT>(value);
  }
  template <typename AllowedSuffixPathFieldsT = Aws::Vector<Aws::String>>
  ConfigurationTemplate& WithAllowedSuffixPathFields(AllowedSuffixPathFieldsT&& value) {
    SetAllowedSuffixPathFields(std::forward<AllowedSuffixPathFieldsT>(value));
    return *this;
  }
  template <typename AllowedSuffixPathFieldsT = Aws::String>
  ConfigurationTemplate& AddAllowedSuffixPathFields(AllowedSuffixPathFieldsT&& value) {
    m_allowedSuffixPathFieldsHasBeenSet = true;
    m_allowedSuffixPathFields.emplace_back(std::forward<AllowedSuffixPathFieldsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<DeliverySourceConfigurationSchema>& GetDeliverySourceConfiguration() const {
    return m_deliverySourceConfiguration;
  }
  inline bool DeliverySourceConfigurationHasBeenSet() const { return m_deliverySourceConfigurationHasBeenSet; }
  template <typename DeliverySourceConfigurationT = Aws::Vector<DeliverySourceConfigurationSchema>>
  void SetDeliverySourceConfiguration(DeliverySourceConfigurationT&& value) {
    m_deliverySourceConfigurationHasBeenSet = true;
    m_deliverySourceConfiguration = std::forward<DeliverySourceConfigurationT>(value);
  }
  template <typename DeliverySourceConfigurationT = Aws::Vector<DeliverySourceConfigurationSchema>>
  ConfigurationTemplate& WithDeliverySourceConfiguration(DeliverySourceConfigurationT&& value) {
    SetDeliverySourceConfiguration(std::forward<DeliverySourceConfigurationT>(value));
    return *this;
  }
  template <typename DeliverySourceConfigurationT = DeliverySourceConfigurationSchema>
  ConfigurationTemplate& AddDeliverySourceConfiguration(DeliverySourceConfigurationT&& value) {
    m_deliverySourceConfigurationHasBeenSet = true;
    m_deliverySourceConfiguration.emplace_back(std::forward<DeliverySourceConfigurationT>(value));
    return *this;
  }
 
 
  inline const S3TablesIntegration& GetS3TablesIntegration() const { return m_s3TablesIntegration; }
  inline bool S3TablesIntegrationHasBeenSet() const { return m_s3TablesIntegrationHasBeenSet; }
  template <typename S3TablesIntegrationT = S3TablesIntegration>
  void SetS3TablesIntegration(S3TablesIntegrationT&& value) {
    m_s3TablesIntegrationHasBeenSet = true;
    m_s3TablesIntegration = std::forward<S3TablesIntegrationT>(value);
  }
  template <typename S3TablesIntegrationT = S3TablesIntegration>
  ConfigurationTemplate& WithS3TablesIntegration(S3TablesIntegrationT&& value) {
    SetS3TablesIntegration(std::forward<S3TablesIntegrationT>(value));
    return *this;
  }
 private:
  Aws::String m_service;
 
  Aws::String m_logType;
 
  Aws::String m_resourceType;
 
  DeliveryDestinationType m_deliveryDestinationType{DeliveryDestinationType::NOT_SET};
 
  ConfigurationTemplateDeliveryConfigValues m_defaultDeliveryConfigValues;
 
  Aws::Vector<RecordField> m_allowedFields;
 
  Aws::Vector<OutputFormat> m_allowedOutputFormats;
 
  Aws::String m_allowedActionForAllowVendedLogsDeliveryForResource;
 
  Aws::Vector<Aws::String> m_allowedFieldDelimiters;
 
  Aws::Vector<Aws::String> m_allowedSuffixPathFields;
 
  Aws::Vector<DeliverySourceConfigurationSchema> m_deliverySourceConfiguration;
 
  S3TablesIntegration m_s3TablesIntegration;
  bool m_serviceHasBeenSet = false;
  bool m_logTypeHasBeenSet = false;
  bool m_resourceTypeHasBeenSet = false;
  bool m_deliveryDestinationTypeHasBeenSet = false;
  bool m_defaultDeliveryConfigValuesHasBeenSet = false;
  bool m_allowedFieldsHasBeenSet = false;
  bool m_allowedOutputFormatsHasBeenSet = false;
  bool m_allowedActionForAllowVendedLogsDeliveryForResourceHasBeenSet = false;
  bool m_allowedFieldDelimitersHasBeenSet = false;
  bool m_allowedSuffixPathFieldsHasBeenSet = false;
  bool m_deliverySourceConfigurationHasBeenSet = false;
  bool m_s3TablesIntegrationHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace CloudWatchLogs
}  // namespace Aws