NetworkEndpoint.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/guardduty/GuardDuty_EXPORTS.h>
#include <aws/guardduty/model/AutonomousSystem.h>
#include <aws/guardduty/model/NetworkConnection.h>
#include <aws/guardduty/model/NetworkGeoLocation.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace GuardDuty {
namespace Model {
 
class NetworkEndpoint {
 public:
  AWS_GUARDDUTY_API NetworkEndpoint() = default;
  AWS_GUARDDUTY_API NetworkEndpoint(Aws::Utils::Json::JsonView jsonValue);
  AWS_GUARDDUTY_API NetworkEndpoint& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_GUARDDUTY_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetId() const { return m_id; }
  inline bool IdHasBeenSet() const { return m_idHasBeenSet; }
  template <typename IdT = Aws::String>
  void SetId(IdT&& value) {
    m_idHasBeenSet = true;
    m_id = std::forward<IdT>(value);
  }
  template <typename IdT = Aws::String>
  NetworkEndpoint& WithId(IdT&& value) {
    SetId(std::forward<IdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetIp() const { return m_ip; }
  inline bool IpHasBeenSet() const { return m_ipHasBeenSet; }
  template <typename IpT = Aws::String>
  void SetIp(IpT&& value) {
    m_ipHasBeenSet = true;
    m_ip = std::forward<IpT>(value);
  }
  template <typename IpT = Aws::String>
  NetworkEndpoint& WithIp(IpT&& value) {
    SetIp(std::forward<IpT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDomain() const { return m_domain; }
  inline bool DomainHasBeenSet() const { return m_domainHasBeenSet; }
  template <typename DomainT = Aws::String>
  void SetDomain(DomainT&& value) {
    m_domainHasBeenSet = true;
    m_domain = std::forward<DomainT>(value);
  }
  template <typename DomainT = Aws::String>
  NetworkEndpoint& WithDomain(DomainT&& value) {
    SetDomain(std::forward<DomainT>(value));
    return *this;
  }
 
 
  inline int GetPort() const { return m_port; }
  inline bool PortHasBeenSet() const { return m_portHasBeenSet; }
  inline void SetPort(int value) {
    m_portHasBeenSet = true;
    m_port = value;
  }
  inline NetworkEndpoint& WithPort(int value) {
    SetPort(value);
    return *this;
  }
 
 
  inline const NetworkGeoLocation& GetLocation() const { return m_location; }
  inline bool LocationHasBeenSet() const { return m_locationHasBeenSet; }
  template <typename LocationT = NetworkGeoLocation>
  void SetLocation(LocationT&& value) {
    m_locationHasBeenSet = true;
    m_location = std::forward<LocationT>(value);
  }
  template <typename LocationT = NetworkGeoLocation>
  NetworkEndpoint& WithLocation(LocationT&& value) {
    SetLocation(std::forward<LocationT>(value));
    return *this;
  }
 
 
  inline const AutonomousSystem& GetAutonomousSystem() const { return m_autonomousSystem; }
  inline bool AutonomousSystemHasBeenSet() const { return m_autonomousSystemHasBeenSet; }
  template <typename AutonomousSystemT = AutonomousSystem>
  void SetAutonomousSystem(AutonomousSystemT&& value) {
    m_autonomousSystemHasBeenSet = true;
    m_autonomousSystem = std::forward<AutonomousSystemT>(value);
  }
  template <typename AutonomousSystemT = AutonomousSystem>
  NetworkEndpoint& WithAutonomousSystem(AutonomousSystemT&& value) {
    SetAutonomousSystem(std::forward<AutonomousSystemT>(value));
    return *this;
  }
 
 
  inline const NetworkConnection& GetConnection() const { return m_connection; }
  inline bool ConnectionHasBeenSet() const { return m_connectionHasBeenSet; }
  template <typename ConnectionT = NetworkConnection>
  void SetConnection(ConnectionT&& value) {
    m_connectionHasBeenSet = true;
    m_connection = std::forward<ConnectionT>(value);
  }
  template <typename ConnectionT = NetworkConnection>
  NetworkEndpoint& WithConnection(ConnectionT&& value) {
    SetConnection(std::forward<ConnectionT>(value));
    return *this;
  }
 private:
  Aws::String m_id;
 
  Aws::String m_ip;
 
  Aws::String m_domain;
 
  int m_port{0};
 
  NetworkGeoLocation m_location;
 
  AutonomousSystem m_autonomousSystem;
 
  NetworkConnection m_connection;
  bool m_idHasBeenSet = false;
  bool m_ipHasBeenSet = false;
  bool m_domainHasBeenSet = false;
  bool m_portHasBeenSet = false;
  bool m_locationHasBeenSet = false;
  bool m_autonomousSystemHasBeenSet = false;
  bool m_connectionHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace GuardDuty
}  // namespace Aws