EventDetails.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/crt/cbor/Cbor.h>
#include <aws/health/Health_EXPORTS.h>
#include <aws/health/model/Event.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Cbor {
class CborValue;
}  // namespace Cbor
}  // namespace Utils
namespace Health {
namespace Model {
 
class EventDetails {
 public:
  AWS_HEALTH_API EventDetails() = default;
  AWS_HEALTH_API EventDetails(const std::shared_ptr<Aws::Crt::Cbor::CborDecoder>& decoder);
  AWS_HEALTH_API EventDetails& operator=(const std::shared_ptr<Aws::Crt::Cbor::CborDecoder>& decoder);
  AWS_HEALTH_API void CborEncode(Aws::Crt::Cbor::CborEncoder& encoder) const;
 
 
  inline const Event& GetEvent() const { return m_event; }
  inline bool EventHasBeenSet() const { return m_eventHasBeenSet; }
  template <typename EventT = Event>
  void SetEvent(EventT&& value) {
    m_eventHasBeenSet = true;
    m_event = std::forward<EventT>(value);
  }
  template <typename EventT = Event>
  EventDetails& WithEvent(EventT&& value) {
    SetEvent(std::forward<EventT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetEventDescription() const { return m_eventDescription; }
  inline bool EventDescriptionHasBeenSet() const { return m_eventDescriptionHasBeenSet; }
  template <typename EventDescriptionT = Aws::String>
  void SetEventDescription(EventDescriptionT&& value) {
    m_eventDescriptionHasBeenSet = true;
    m_eventDescription = std::forward<EventDescriptionT>(value);
  }
  template <typename EventDescriptionT = Aws::String>
  EventDetails& WithEventDescription(EventDescriptionT&& value) {
    SetEventDescription(std::forward<EventDescriptionT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::String>& GetEventMetadata() const { return m_eventMetadata; }
  inline bool EventMetadataHasBeenSet() const { return m_eventMetadataHasBeenSet; }
  template <typename EventMetadataT = Aws::Map<Aws::String, Aws::String>>
  void SetEventMetadata(EventMetadataT&& value) {
    m_eventMetadataHasBeenSet = true;
    m_eventMetadata = std::forward<EventMetadataT>(value);
  }
  template <typename EventMetadataT = Aws::Map<Aws::String, Aws::String>>
  EventDetails& WithEventMetadata(EventMetadataT&& value) {
    SetEventMetadata(std::forward<EventMetadataT>(value));
    return *this;
  }
  template <typename EventMetadataKeyT = Aws::String, typename EventMetadataValueT = Aws::String>
  EventDetails& AddEventMetadata(EventMetadataKeyT&& key, EventMetadataValueT&& value) {
    m_eventMetadataHasBeenSet = true;
    m_eventMetadata.emplace(std::forward<EventMetadataKeyT>(key), std::forward<EventMetadataValueT>(value));
    return *this;
  }
 private:
  Event m_event;
 
  Aws::String m_eventDescription;
 
  Aws::Map<Aws::String, Aws::String> m_eventMetadata;
  bool m_eventHasBeenSet = false;
  bool m_eventDescriptionHasBeenSet = false;
  bool m_eventMetadataHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Health
}  // namespace Aws