Classifier.h

 
#pragma once
#include <aws/glue/Glue_EXPORTS.h>
#include <aws/glue/model/CsvClassifier.h>
#include <aws/glue/model/GrokClassifier.h>
#include <aws/glue/model/JsonClassifier.h>
#include <aws/glue/model/XMLClassifier.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace Glue {
namespace Model {
 
class Classifier {
 public:
  AWS_GLUE_API Classifier() = default;
  AWS_GLUE_API Classifier(Aws::Utils::Json::JsonView jsonValue);
  AWS_GLUE_API Classifier& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_GLUE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const GrokClassifier& GetGrokClassifier() const { return m_grokClassifier; }
  inline bool GrokClassifierHasBeenSet() const { return m_grokClassifierHasBeenSet; }
  template <typename GrokClassifierT = GrokClassifier>
  void SetGrokClassifier(GrokClassifierT&& value) {
    m_grokClassifierHasBeenSet = true;
    m_grokClassifier = std::forward<GrokClassifierT>(value);
  }
  template <typename GrokClassifierT = GrokClassifier>
  Classifier& WithGrokClassifier(GrokClassifierT&& value) {
    SetGrokClassifier(std::forward<GrokClassifierT>(value));
    return *this;
  }
 
 
  inline const XMLClassifier& GetXMLClassifier() const { return m_xMLClassifier; }
  inline bool XMLClassifierHasBeenSet() const { return m_xMLClassifierHasBeenSet; }
  template <typename XMLClassifierT = XMLClassifier>
  void SetXMLClassifier(XMLClassifierT&& value) {
    m_xMLClassifierHasBeenSet = true;
    m_xMLClassifier = std::forward<XMLClassifierT>(value);
  }
  template <typename XMLClassifierT = XMLClassifier>
  Classifier& WithXMLClassifier(XMLClassifierT&& value) {
    SetXMLClassifier(std::forward<XMLClassifierT>(value));
    return *this;
  }
 
 
  inline const JsonClassifier& GetJsonClassifier() const { return m_jsonClassifier; }
  inline bool JsonClassifierHasBeenSet() const { return m_jsonClassifierHasBeenSet; }
  template <typename JsonClassifierT = JsonClassifier>
  void SetJsonClassifier(JsonClassifierT&& value) {
    m_jsonClassifierHasBeenSet = true;
    m_jsonClassifier = std::forward<JsonClassifierT>(value);
  }
  template <typename JsonClassifierT = JsonClassifier>
  Classifier& WithJsonClassifier(JsonClassifierT&& value) {
    SetJsonClassifier(std::forward<JsonClassifierT>(value));
    return *this;
  }
 
 
  inline const CsvClassifier& GetCsvClassifier() const { return m_csvClassifier; }
  inline bool CsvClassifierHasBeenSet() const { return m_csvClassifierHasBeenSet; }
  template <typename CsvClassifierT = CsvClassifier>
  void SetCsvClassifier(CsvClassifierT&& value) {
    m_csvClassifierHasBeenSet = true;
    m_csvClassifier = std::forward<CsvClassifierT>(value);
  }
  template <typename CsvClassifierT = CsvClassifier>
  Classifier& WithCsvClassifier(CsvClassifierT&& value) {
    SetCsvClassifier(std::forward<CsvClassifierT>(value));
    return *this;
  }
 private:
  GrokClassifier m_grokClassifier;
 
  XMLClassifier m_xMLClassifier;
 
  JsonClassifier m_jsonClassifier;
 
  CsvClassifier m_csvClassifier;
  bool m_grokClassifierHasBeenSet = false;
  bool m_xMLClassifierHasBeenSet = false;
  bool m_jsonClassifierHasBeenSet = false;
  bool m_csvClassifierHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Glue
}  // namespace Aws