RecordingGroup.h

 
#pragma once
#include <aws/config/ConfigService_EXPORTS.h>
#include <aws/config/model/ExclusionByResourceTypes.h>
#include <aws/config/model/RecordingStrategy.h>
#include <aws/config/model/ResourceType.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 ConfigService {
namespace Model {
 
class RecordingGroup {
 public:
  AWS_CONFIGSERVICE_API RecordingGroup() = default;
  AWS_CONFIGSERVICE_API RecordingGroup(Aws::Utils::Json::JsonView jsonValue);
  AWS_CONFIGSERVICE_API RecordingGroup& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_CONFIGSERVICE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline bool GetAllSupported() const { return m_allSupported; }
  inline bool AllSupportedHasBeenSet() const { return m_allSupportedHasBeenSet; }
  inline void SetAllSupported(bool value) {
    m_allSupportedHasBeenSet = true;
    m_allSupported = value;
  }
  inline RecordingGroup& WithAllSupported(bool value) {
    SetAllSupported(value);
    return *this;
  }
 
 
  inline bool GetIncludeGlobalResourceTypes() const { return m_includeGlobalResourceTypes; }
  inline bool IncludeGlobalResourceTypesHasBeenSet() const { return m_includeGlobalResourceTypesHasBeenSet; }
  inline void SetIncludeGlobalResourceTypes(bool value) {
    m_includeGlobalResourceTypesHasBeenSet = true;
    m_includeGlobalResourceTypes = value;
  }
  inline RecordingGroup& WithIncludeGlobalResourceTypes(bool value) {
    SetIncludeGlobalResourceTypes(value);
    return *this;
  }
 
 
  inline const Aws::Vector<ResourceType>& GetResourceTypes() const { return m_resourceTypes; }
  inline bool ResourceTypesHasBeenSet() const { return m_resourceTypesHasBeenSet; }
  template <typename ResourceTypesT = Aws::Vector<ResourceType>>
  void SetResourceTypes(ResourceTypesT&& value) {
    m_resourceTypesHasBeenSet = true;
    m_resourceTypes = std::forward<ResourceTypesT>(value);
  }
  template <typename ResourceTypesT = Aws::Vector<ResourceType>>
  RecordingGroup& WithResourceTypes(ResourceTypesT&& value) {
    SetResourceTypes(std::forward<ResourceTypesT>(value));
    return *this;
  }
  inline RecordingGroup& AddResourceTypes(ResourceType value) {
    m_resourceTypesHasBeenSet = true;
    m_resourceTypes.push_back(value);
    return *this;
  }
 
 
  inline const ExclusionByResourceTypes& GetExclusionByResourceTypes() const { return m_exclusionByResourceTypes; }
  inline bool ExclusionByResourceTypesHasBeenSet() const { return m_exclusionByResourceTypesHasBeenSet; }
  template <typename ExclusionByResourceTypesT = ExclusionByResourceTypes>
  void SetExclusionByResourceTypes(ExclusionByResourceTypesT&& value) {
    m_exclusionByResourceTypesHasBeenSet = true;
    m_exclusionByResourceTypes = std::forward<ExclusionByResourceTypesT>(value);
  }
  template <typename ExclusionByResourceTypesT = ExclusionByResourceTypes>
  RecordingGroup& WithExclusionByResourceTypes(ExclusionByResourceTypesT&& value) {
    SetExclusionByResourceTypes(std::forward<ExclusionByResourceTypesT>(value));
    return *this;
  }
 
 
  inline const RecordingStrategy& GetRecordingStrategy() const { return m_recordingStrategy; }
  inline bool RecordingStrategyHasBeenSet() const { return m_recordingStrategyHasBeenSet; }
  template <typename RecordingStrategyT = RecordingStrategy>
  void SetRecordingStrategy(RecordingStrategyT&& value) {
    m_recordingStrategyHasBeenSet = true;
    m_recordingStrategy = std::forward<RecordingStrategyT>(value);
  }
  template <typename RecordingStrategyT = RecordingStrategy>
  RecordingGroup& WithRecordingStrategy(RecordingStrategyT&& value) {
    SetRecordingStrategy(std::forward<RecordingStrategyT>(value));
    return *this;
  }
 private:
  bool m_allSupported{false};
 
  bool m_includeGlobalResourceTypes{false};
 
  Aws::Vector<ResourceType> m_resourceTypes;
 
  ExclusionByResourceTypes m_exclusionByResourceTypes;
 
  RecordingStrategy m_recordingStrategy;
  bool m_allSupportedHasBeenSet = false;
  bool m_includeGlobalResourceTypesHasBeenSet = false;
  bool m_resourceTypesHasBeenSet = false;
  bool m_exclusionByResourceTypesHasBeenSet = false;
  bool m_recordingStrategyHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace ConfigService
}  // namespace Aws