Input.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/kinesisanalytics/KinesisAnalytics_EXPORTS.h>
#include <aws/kinesisanalytics/model/InputParallelism.h>
#include <aws/kinesisanalytics/model/InputProcessingConfiguration.h>
#include <aws/kinesisanalytics/model/KinesisFirehoseInput.h>
#include <aws/kinesisanalytics/model/KinesisStreamsInput.h>
#include <aws/kinesisanalytics/model/SourceSchema.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace KinesisAnalytics {
namespace Model {
 
class Input {
 public:
  AWS_KINESISANALYTICS_API Input() = default;
  AWS_KINESISANALYTICS_API Input(Aws::Utils::Json::JsonView jsonValue);
  AWS_KINESISANALYTICS_API Input& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_KINESISANALYTICS_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetNamePrefix() const { return m_namePrefix; }
  inline bool NamePrefixHasBeenSet() const { return m_namePrefixHasBeenSet; }
  template <typename NamePrefixT = Aws::String>
  void SetNamePrefix(NamePrefixT&& value) {
    m_namePrefixHasBeenSet = true;
    m_namePrefix = std::forward<NamePrefixT>(value);
  }
  template <typename NamePrefixT = Aws::String>
  Input& WithNamePrefix(NamePrefixT&& value) {
    SetNamePrefix(std::forward<NamePrefixT>(value));
    return *this;
  }
 
 
  inline const InputProcessingConfiguration& GetInputProcessingConfiguration() const { return m_inputProcessingConfiguration; }
  inline bool InputProcessingConfigurationHasBeenSet() const { return m_inputProcessingConfigurationHasBeenSet; }
  template <typename InputProcessingConfigurationT = InputProcessingConfiguration>
  void SetInputProcessingConfiguration(InputProcessingConfigurationT&& value) {
    m_inputProcessingConfigurationHasBeenSet = true;
    m_inputProcessingConfiguration = std::forward<InputProcessingConfigurationT>(value);
  }
  template <typename InputProcessingConfigurationT = InputProcessingConfiguration>
  Input& WithInputProcessingConfiguration(InputProcessingConfigurationT&& value) {
    SetInputProcessingConfiguration(std::forward<InputProcessingConfigurationT>(value));
    return *this;
  }
 
 
  inline const KinesisStreamsInput& GetKinesisStreamsInput() const { return m_kinesisStreamsInput; }
  inline bool KinesisStreamsInputHasBeenSet() const { return m_kinesisStreamsInputHasBeenSet; }
  template <typename KinesisStreamsInputT = KinesisStreamsInput>
  void SetKinesisStreamsInput(KinesisStreamsInputT&& value) {
    m_kinesisStreamsInputHasBeenSet = true;
    m_kinesisStreamsInput = std::forward<KinesisStreamsInputT>(value);
  }
  template <typename KinesisStreamsInputT = KinesisStreamsInput>
  Input& WithKinesisStreamsInput(KinesisStreamsInputT&& value) {
    SetKinesisStreamsInput(std::forward<KinesisStreamsInputT>(value));
    return *this;
  }
 
 
  inline const KinesisFirehoseInput& GetKinesisFirehoseInput() const { return m_kinesisFirehoseInput; }
  inline bool KinesisFirehoseInputHasBeenSet() const { return m_kinesisFirehoseInputHasBeenSet; }
  template <typename KinesisFirehoseInputT = KinesisFirehoseInput>
  void SetKinesisFirehoseInput(KinesisFirehoseInputT&& value) {
    m_kinesisFirehoseInputHasBeenSet = true;
    m_kinesisFirehoseInput = std::forward<KinesisFirehoseInputT>(value);
  }
  template <typename KinesisFirehoseInputT = KinesisFirehoseInput>
  Input& WithKinesisFirehoseInput(KinesisFirehoseInputT&& value) {
    SetKinesisFirehoseInput(std::forward<KinesisFirehoseInputT>(value));
    return *this;
  }
 
 
  inline const InputParallelism& GetInputParallelism() const { return m_inputParallelism; }
  inline bool InputParallelismHasBeenSet() const { return m_inputParallelismHasBeenSet; }
  template <typename InputParallelismT = InputParallelism>
  void SetInputParallelism(InputParallelismT&& value) {
    m_inputParallelismHasBeenSet = true;
    m_inputParallelism = std::forward<InputParallelismT>(value);
  }
  template <typename InputParallelismT = InputParallelism>
  Input& WithInputParallelism(InputParallelismT&& value) {
    SetInputParallelism(std::forward<InputParallelismT>(value));
    return *this;
  }
 
 
  inline const SourceSchema& GetInputSchema() const { return m_inputSchema; }
  inline bool InputSchemaHasBeenSet() const { return m_inputSchemaHasBeenSet; }
  template <typename InputSchemaT = SourceSchema>
  void SetInputSchema(InputSchemaT&& value) {
    m_inputSchemaHasBeenSet = true;
    m_inputSchema = std::forward<InputSchemaT>(value);
  }
  template <typename InputSchemaT = SourceSchema>
  Input& WithInputSchema(InputSchemaT&& value) {
    SetInputSchema(std::forward<InputSchemaT>(value));
    return *this;
  }
 private:
  Aws::String m_namePrefix;
 
  InputProcessingConfiguration m_inputProcessingConfiguration;
 
  KinesisStreamsInput m_kinesisStreamsInput;
 
  KinesisFirehoseInput m_kinesisFirehoseInput;
 
  InputParallelism m_inputParallelism;
 
  SourceSchema m_inputSchema;
  bool m_namePrefixHasBeenSet = false;
  bool m_inputProcessingConfigurationHasBeenSet = false;
  bool m_kinesisStreamsInputHasBeenSet = false;
  bool m_kinesisFirehoseInputHasBeenSet = false;
  bool m_inputParallelismHasBeenSet = false;
  bool m_inputSchemaHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace KinesisAnalytics
}  // namespace Aws