ApiKeyRestrictions.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/location/LocationService_EXPORTS.h>
#include <aws/location/model/AndroidApp.h>
#include <aws/location/model/AppleApp.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace LocationService {
namespace Model {
 
class ApiKeyRestrictions {
 public:
  AWS_LOCATIONSERVICE_API ApiKeyRestrictions() = default;
  AWS_LOCATIONSERVICE_API ApiKeyRestrictions(Aws::Utils::Json::JsonView jsonValue);
  AWS_LOCATIONSERVICE_API ApiKeyRestrictions& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_LOCATIONSERVICE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::Vector<Aws::String>& GetAllowActions() const { return m_allowActions; }
  inline bool AllowActionsHasBeenSet() const { return m_allowActionsHasBeenSet; }
  template <typename AllowActionsT = Aws::Vector<Aws::String>>
  void SetAllowActions(AllowActionsT&& value) {
    m_allowActionsHasBeenSet = true;
    m_allowActions = std::forward<AllowActionsT>(value);
  }
  template <typename AllowActionsT = Aws::Vector<Aws::String>>
  ApiKeyRestrictions& WithAllowActions(AllowActionsT&& value) {
    SetAllowActions(std::forward<AllowActionsT>(value));
    return *this;
  }
  template <typename AllowActionsT = Aws::String>
  ApiKeyRestrictions& AddAllowActions(AllowActionsT&& value) {
    m_allowActionsHasBeenSet = true;
    m_allowActions.emplace_back(std::forward<AllowActionsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetAllowResources() const { return m_allowResources; }
  inline bool AllowResourcesHasBeenSet() const { return m_allowResourcesHasBeenSet; }
  template <typename AllowResourcesT = Aws::Vector<Aws::String>>
  void SetAllowResources(AllowResourcesT&& value) {
    m_allowResourcesHasBeenSet = true;
    m_allowResources = std::forward<AllowResourcesT>(value);
  }
  template <typename AllowResourcesT = Aws::Vector<Aws::String>>
  ApiKeyRestrictions& WithAllowResources(AllowResourcesT&& value) {
    SetAllowResources(std::forward<AllowResourcesT>(value));
    return *this;
  }
  template <typename AllowResourcesT = Aws::String>
  ApiKeyRestrictions& AddAllowResources(AllowResourcesT&& value) {
    m_allowResourcesHasBeenSet = true;
    m_allowResources.emplace_back(std::forward<AllowResourcesT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetAllowReferers() const { return m_allowReferers; }
  inline bool AllowReferersHasBeenSet() const { return m_allowReferersHasBeenSet; }
  template <typename AllowReferersT = Aws::Vector<Aws::String>>
  void SetAllowReferers(AllowReferersT&& value) {
    m_allowReferersHasBeenSet = true;
    m_allowReferers = std::forward<AllowReferersT>(value);
  }
  template <typename AllowReferersT = Aws::Vector<Aws::String>>
  ApiKeyRestrictions& WithAllowReferers(AllowReferersT&& value) {
    SetAllowReferers(std::forward<AllowReferersT>(value));
    return *this;
  }
  template <typename AllowReferersT = Aws::String>
  ApiKeyRestrictions& AddAllowReferers(AllowReferersT&& value) {
    m_allowReferersHasBeenSet = true;
    m_allowReferers.emplace_back(std::forward<AllowReferersT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<AndroidApp>& GetAllowAndroidApps() const { return m_allowAndroidApps; }
  inline bool AllowAndroidAppsHasBeenSet() const { return m_allowAndroidAppsHasBeenSet; }
  template <typename AllowAndroidAppsT = Aws::Vector<AndroidApp>>
  void SetAllowAndroidApps(AllowAndroidAppsT&& value) {
    m_allowAndroidAppsHasBeenSet = true;
    m_allowAndroidApps = std::forward<AllowAndroidAppsT>(value);
  }
  template <typename AllowAndroidAppsT = Aws::Vector<AndroidApp>>
  ApiKeyRestrictions& WithAllowAndroidApps(AllowAndroidAppsT&& value) {
    SetAllowAndroidApps(std::forward<AllowAndroidAppsT>(value));
    return *this;
  }
  template <typename AllowAndroidAppsT = AndroidApp>
  ApiKeyRestrictions& AddAllowAndroidApps(AllowAndroidAppsT&& value) {
    m_allowAndroidAppsHasBeenSet = true;
    m_allowAndroidApps.emplace_back(std::forward<AllowAndroidAppsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<AppleApp>& GetAllowAppleApps() const { return m_allowAppleApps; }
  inline bool AllowAppleAppsHasBeenSet() const { return m_allowAppleAppsHasBeenSet; }
  template <typename AllowAppleAppsT = Aws::Vector<AppleApp>>
  void SetAllowAppleApps(AllowAppleAppsT&& value) {
    m_allowAppleAppsHasBeenSet = true;
    m_allowAppleApps = std::forward<AllowAppleAppsT>(value);
  }
  template <typename AllowAppleAppsT = Aws::Vector<AppleApp>>
  ApiKeyRestrictions& WithAllowAppleApps(AllowAppleAppsT&& value) {
    SetAllowAppleApps(std::forward<AllowAppleAppsT>(value));
    return *this;
  }
  template <typename AllowAppleAppsT = AppleApp>
  ApiKeyRestrictions& AddAllowAppleApps(AllowAppleAppsT&& value) {
    m_allowAppleAppsHasBeenSet = true;
    m_allowAppleApps.emplace_back(std::forward<AllowAppleAppsT>(value));
    return *this;
  }
 private:
  Aws::Vector<Aws::String> m_allowActions;
 
  Aws::Vector<Aws::String> m_allowResources;
 
  Aws::Vector<Aws::String> m_allowReferers;
 
  Aws::Vector<AndroidApp> m_allowAndroidApps;
 
  Aws::Vector<AppleApp> m_allowAppleApps;
  bool m_allowActionsHasBeenSet = false;
  bool m_allowResourcesHasBeenSet = false;
  bool m_allowReferersHasBeenSet = false;
  bool m_allowAndroidAppsHasBeenSet = false;
  bool m_allowAppleAppsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace LocationService
}  // namespace Aws