AWS SDK for C++

AWS SDK for C++ Version 1.11.607

Loading...
Searching...
No Matches
EksAnywhereSubscription.h
1
6#pragma once
7#include <aws/eks/EKS_EXPORTS.h>
8#include <aws/core/utils/memory/stl/AWSString.h>
9#include <aws/core/utils/DateTime.h>
10#include <aws/eks/model/EksAnywhereSubscriptionLicenseType.h>
11#include <aws/eks/model/EksAnywhereSubscriptionTerm.h>
12#include <aws/core/utils/memory/stl/AWSVector.h>
13#include <aws/core/utils/memory/stl/AWSMap.h>
14#include <aws/eks/model/License.h>
15#include <utility>
16
17namespace Aws
18{
19namespace Utils
20{
21namespace Json
22{
23 class JsonValue;
24 class JsonView;
25} // namespace Json
26} // namespace Utils
27namespace EKS
28{
29namespace Model
30{
31
40 {
41 public:
42 AWS_EKS_API EksAnywhereSubscription() = default;
46
47
49
52 inline const Aws::String& GetId() const { return m_id; }
53 inline bool IdHasBeenSet() const { return m_idHasBeenSet; }
54 template<typename IdT = Aws::String>
55 void SetId(IdT&& value) { m_idHasBeenSet = true; m_id = std::forward<IdT>(value); }
56 template<typename IdT = Aws::String>
57 EksAnywhereSubscription& WithId(IdT&& value) { SetId(std::forward<IdT>(value)); return *this;}
59
61
64 inline const Aws::String& GetArn() const { return m_arn; }
65 inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
66 template<typename ArnT = Aws::String>
67 void SetArn(ArnT&& value) { m_arnHasBeenSet = true; m_arn = std::forward<ArnT>(value); }
68 template<typename ArnT = Aws::String>
69 EksAnywhereSubscription& WithArn(ArnT&& value) { SetArn(std::forward<ArnT>(value)); return *this;}
71
73
76 inline const Aws::Utils::DateTime& GetCreatedAt() const { return m_createdAt; }
77 inline bool CreatedAtHasBeenSet() const { return m_createdAtHasBeenSet; }
78 template<typename CreatedAtT = Aws::Utils::DateTime>
79 void SetCreatedAt(CreatedAtT&& value) { m_createdAtHasBeenSet = true; m_createdAt = std::forward<CreatedAtT>(value); }
80 template<typename CreatedAtT = Aws::Utils::DateTime>
81 EksAnywhereSubscription& WithCreatedAt(CreatedAtT&& value) { SetCreatedAt(std::forward<CreatedAtT>(value)); return *this;}
83
85
88 inline const Aws::Utils::DateTime& GetEffectiveDate() const { return m_effectiveDate; }
89 inline bool EffectiveDateHasBeenSet() const { return m_effectiveDateHasBeenSet; }
90 template<typename EffectiveDateT = Aws::Utils::DateTime>
91 void SetEffectiveDate(EffectiveDateT&& value) { m_effectiveDateHasBeenSet = true; m_effectiveDate = std::forward<EffectiveDateT>(value); }
92 template<typename EffectiveDateT = Aws::Utils::DateTime>
93 EksAnywhereSubscription& WithEffectiveDate(EffectiveDateT&& value) { SetEffectiveDate(std::forward<EffectiveDateT>(value)); return *this;}
95
97
101 inline const Aws::Utils::DateTime& GetExpirationDate() const { return m_expirationDate; }
102 inline bool ExpirationDateHasBeenSet() const { return m_expirationDateHasBeenSet; }
103 template<typename ExpirationDateT = Aws::Utils::DateTime>
104 void SetExpirationDate(ExpirationDateT&& value) { m_expirationDateHasBeenSet = true; m_expirationDate = std::forward<ExpirationDateT>(value); }
105 template<typename ExpirationDateT = Aws::Utils::DateTime>
106 EksAnywhereSubscription& WithExpirationDate(ExpirationDateT&& value) { SetExpirationDate(std::forward<ExpirationDateT>(value)); return *this;}
108
110
114 inline int GetLicenseQuantity() const { return m_licenseQuantity; }
115 inline bool LicenseQuantityHasBeenSet() const { return m_licenseQuantityHasBeenSet; }
116 inline void SetLicenseQuantity(int value) { m_licenseQuantityHasBeenSet = true; m_licenseQuantity = value; }
117 inline EksAnywhereSubscription& WithLicenseQuantity(int value) { SetLicenseQuantity(value); return *this;}
119
121
126 inline EksAnywhereSubscriptionLicenseType GetLicenseType() const { return m_licenseType; }
127 inline bool LicenseTypeHasBeenSet() const { return m_licenseTypeHasBeenSet; }
128 inline void SetLicenseType(EksAnywhereSubscriptionLicenseType value) { m_licenseTypeHasBeenSet = true; m_licenseType = value; }
131
133
136 inline const EksAnywhereSubscriptionTerm& GetTerm() const { return m_term; }
137 inline bool TermHasBeenSet() const { return m_termHasBeenSet; }
138 template<typename TermT = EksAnywhereSubscriptionTerm>
139 void SetTerm(TermT&& value) { m_termHasBeenSet = true; m_term = std::forward<TermT>(value); }
140 template<typename TermT = EksAnywhereSubscriptionTerm>
141 EksAnywhereSubscription& WithTerm(TermT&& value) { SetTerm(std::forward<TermT>(value)); return *this;}
143
145
148 inline const Aws::String& GetStatus() const { return m_status; }
149 inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
150 template<typename StatusT = Aws::String>
151 void SetStatus(StatusT&& value) { m_statusHasBeenSet = true; m_status = std::forward<StatusT>(value); }
152 template<typename StatusT = Aws::String>
153 EksAnywhereSubscription& WithStatus(StatusT&& value) { SetStatus(std::forward<StatusT>(value)); return *this;}
155
157
161 inline bool GetAutoRenew() const { return m_autoRenew; }
162 inline bool AutoRenewHasBeenSet() const { return m_autoRenewHasBeenSet; }
163 inline void SetAutoRenew(bool value) { m_autoRenewHasBeenSet = true; m_autoRenew = value; }
164 inline EksAnywhereSubscription& WithAutoRenew(bool value) { SetAutoRenew(value); return *this;}
166
168
171 inline const Aws::Vector<Aws::String>& GetLicenseArns() const { return m_licenseArns; }
172 inline bool LicenseArnsHasBeenSet() const { return m_licenseArnsHasBeenSet; }
173 template<typename LicenseArnsT = Aws::Vector<Aws::String>>
174 void SetLicenseArns(LicenseArnsT&& value) { m_licenseArnsHasBeenSet = true; m_licenseArns = std::forward<LicenseArnsT>(value); }
175 template<typename LicenseArnsT = Aws::Vector<Aws::String>>
176 EksAnywhereSubscription& WithLicenseArns(LicenseArnsT&& value) { SetLicenseArns(std::forward<LicenseArnsT>(value)); return *this;}
177 template<typename LicenseArnsT = Aws::String>
178 EksAnywhereSubscription& AddLicenseArns(LicenseArnsT&& value) { m_licenseArnsHasBeenSet = true; m_licenseArns.emplace_back(std::forward<LicenseArnsT>(value)); return *this; }
180
182
186 inline const Aws::Vector<License>& GetLicenses() const { return m_licenses; }
187 inline bool LicensesHasBeenSet() const { return m_licensesHasBeenSet; }
188 template<typename LicensesT = Aws::Vector<License>>
189 void SetLicenses(LicensesT&& value) { m_licensesHasBeenSet = true; m_licenses = std::forward<LicensesT>(value); }
190 template<typename LicensesT = Aws::Vector<License>>
191 EksAnywhereSubscription& WithLicenses(LicensesT&& value) { SetLicenses(std::forward<LicensesT>(value)); return *this;}
192 template<typename LicensesT = License>
193 EksAnywhereSubscription& AddLicenses(LicensesT&& value) { m_licensesHasBeenSet = true; m_licenses.emplace_back(std::forward<LicensesT>(value)); return *this; }
195
197
203 inline const Aws::Map<Aws::String, Aws::String>& GetTags() const { return m_tags; }
204 inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
205 template<typename TagsT = Aws::Map<Aws::String, Aws::String>>
206 void SetTags(TagsT&& value) { m_tagsHasBeenSet = true; m_tags = std::forward<TagsT>(value); }
207 template<typename TagsT = Aws::Map<Aws::String, Aws::String>>
208 EksAnywhereSubscription& WithTags(TagsT&& value) { SetTags(std::forward<TagsT>(value)); return *this;}
209 template<typename TagsKeyT = Aws::String, typename TagsValueT = Aws::String>
210 EksAnywhereSubscription& AddTags(TagsKeyT&& key, TagsValueT&& value) {
211 m_tagsHasBeenSet = true; m_tags.emplace(std::forward<TagsKeyT>(key), std::forward<TagsValueT>(value)); return *this;
212 }
214 private:
215
216 Aws::String m_id;
217 bool m_idHasBeenSet = false;
218
219 Aws::String m_arn;
220 bool m_arnHasBeenSet = false;
221
222 Aws::Utils::DateTime m_createdAt{};
223 bool m_createdAtHasBeenSet = false;
224
225 Aws::Utils::DateTime m_effectiveDate{};
226 bool m_effectiveDateHasBeenSet = false;
227
228 Aws::Utils::DateTime m_expirationDate{};
229 bool m_expirationDateHasBeenSet = false;
230
231 int m_licenseQuantity{0};
232 bool m_licenseQuantityHasBeenSet = false;
233
235 bool m_licenseTypeHasBeenSet = false;
236
237 EksAnywhereSubscriptionTerm m_term;
238 bool m_termHasBeenSet = false;
239
240 Aws::String m_status;
241 bool m_statusHasBeenSet = false;
242
243 bool m_autoRenew{false};
244 bool m_autoRenewHasBeenSet = false;
245
246 Aws::Vector<Aws::String> m_licenseArns;
247 bool m_licenseArnsHasBeenSet = false;
248
249 Aws::Vector<License> m_licenses;
250 bool m_licensesHasBeenSet = false;
251
253 bool m_tagsHasBeenSet = false;
254 };
255
256} // namespace Model
257} // namespace EKS
258} // namespace Aws
EksAnywhereSubscription & WithId(IdT &&value)
EksAnywhereSubscription & WithTags(TagsT &&value)
EksAnywhereSubscription & WithArn(ArnT &&value)
const Aws::Utils::DateTime & GetCreatedAt() const
const Aws::Map< Aws::String, Aws::String > & GetTags() const
void SetLicenseType(EksAnywhereSubscriptionLicenseType value)
EksAnywhereSubscription & AddLicenseArns(LicenseArnsT &&value)
EksAnywhereSubscriptionLicenseType GetLicenseType() const
EksAnywhereSubscription & WithLicenseQuantity(int value)
EksAnywhereSubscription & AddLicenses(LicensesT &&value)
EksAnywhereSubscription & WithStatus(StatusT &&value)
EksAnywhereSubscription & WithEffectiveDate(EffectiveDateT &&value)
const Aws::Vector< License > & GetLicenses() const
EksAnywhereSubscription & WithTerm(TermT &&value)
AWS_EKS_API Aws::Utils::Json::JsonValue Jsonize() const
EksAnywhereSubscription & WithLicenseArns(LicenseArnsT &&value)
const Aws::Utils::DateTime & GetExpirationDate() const
const Aws::Utils::DateTime & GetEffectiveDate() const
AWS_EKS_API EksAnywhereSubscription()=default
EksAnywhereSubscription & WithExpirationDate(ExpirationDateT &&value)
EksAnywhereSubscription & WithLicenseType(EksAnywhereSubscriptionLicenseType value)
EksAnywhereSubscription & WithCreatedAt(CreatedAtT &&value)
AWS_EKS_API EksAnywhereSubscription & operator=(Aws::Utils::Json::JsonView jsonValue)
EksAnywhereSubscription & AddTags(TagsKeyT &&key, TagsValueT &&value)
const EksAnywhereSubscriptionTerm & GetTerm() const
const Aws::Vector< Aws::String > & GetLicenseArns() const
AWS_EKS_API EksAnywhereSubscription(Aws::Utils::Json::JsonView jsonValue)
EksAnywhereSubscription & WithAutoRenew(bool value)
EksAnywhereSubscription & WithLicenses(LicensesT &&value)
std::map< K, V, std::less< K >, Aws::Allocator< std::pair< const K, V > > > Map
std::basic_string< char, std::char_traits< char >, Aws::Allocator< char > > String
std::vector< T, Aws::Allocator< T > > Vector
Aws::Utils::Json::JsonValue JsonValue