AWS SDK for C++

AWS SDK for C++ Version 1.11.935

Loading...
Searching...
No Matches
DBCapacityReservation.h
1
6#pragma once
7#include <aws/core/utils/DateTime.h>
8#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
9#include <aws/core/utils/memory/stl/AWSString.h>
10#include <aws/core/utils/memory/stl/AWSVector.h>
11#include <aws/rds/RDS_EXPORTS.h>
12#include <aws/rds/model/AvailableCapacityPerAvailabilityZone.h>
13#include <aws/rds/model/DBCapacityReservationCommitmentInfo.h>
14#include <aws/rds/model/DBCapacityReservationState.h>
15#include <aws/rds/model/Tag.h>
16
17#include <utility>
18
19namespace Aws {
20namespace Utils {
21namespace Xml {
22class XmlNode;
23} // namespace Xml
24} // namespace Utils
25namespace RDS {
26namespace Model {
27
40 public:
41 AWS_RDS_API DBCapacityReservation() = default;
44
45 AWS_RDS_API void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
46 AWS_RDS_API void OutputToStream(Aws::OStream& oStream, const char* location) const;
47
49
52 inline const Aws::String& GetDBCapacityReservationName() const { return m_dBCapacityReservationName; }
53 inline bool DBCapacityReservationNameHasBeenSet() const { return m_dBCapacityReservationNameHasBeenSet; }
54 template <typename DBCapacityReservationNameT = Aws::String>
55 void SetDBCapacityReservationName(DBCapacityReservationNameT&& value) {
56 m_dBCapacityReservationNameHasBeenSet = true;
57 m_dBCapacityReservationName = std::forward<DBCapacityReservationNameT>(value);
58 }
59 template <typename DBCapacityReservationNameT = Aws::String>
60 DBCapacityReservation& WithDBCapacityReservationName(DBCapacityReservationNameT&& value) {
61 SetDBCapacityReservationName(std::forward<DBCapacityReservationNameT>(value));
62 return *this;
63 }
65
67
71 inline const Aws::String& GetDBInstanceClass() const { return m_dBInstanceClass; }
72 inline bool DBInstanceClassHasBeenSet() const { return m_dBInstanceClassHasBeenSet; }
73 template <typename DBInstanceClassT = Aws::String>
74 void SetDBInstanceClass(DBInstanceClassT&& value) {
75 m_dBInstanceClassHasBeenSet = true;
76 m_dBInstanceClass = std::forward<DBInstanceClassT>(value);
77 }
78 template <typename DBInstanceClassT = Aws::String>
79 DBCapacityReservation& WithDBInstanceClass(DBInstanceClassT&& value) {
80 SetDBInstanceClass(std::forward<DBInstanceClassT>(value));
81 return *this;
82 }
84
86
90 inline const Aws::String& GetEngine() const { return m_engine; }
91 inline bool EngineHasBeenSet() const { return m_engineHasBeenSet; }
92 template <typename EngineT = Aws::String>
93 void SetEngine(EngineT&& value) {
94 m_engineHasBeenSet = true;
95 m_engine = std::forward<EngineT>(value);
96 }
97 template <typename EngineT = Aws::String>
99 SetEngine(std::forward<EngineT>(value));
100 return *this;
101 }
103
105
122 inline const Aws::String& GetLicenseModel() const { return m_licenseModel; }
123 inline bool LicenseModelHasBeenSet() const { return m_licenseModelHasBeenSet; }
124 template <typename LicenseModelT = Aws::String>
125 void SetLicenseModel(LicenseModelT&& value) {
126 m_licenseModelHasBeenSet = true;
127 m_licenseModel = std::forward<LicenseModelT>(value);
128 }
129 template <typename LicenseModelT = Aws::String>
130 DBCapacityReservation& WithLicenseModel(LicenseModelT&& value) {
131 SetLicenseModel(std::forward<LicenseModelT>(value));
132 return *this;
133 }
135
137
144 inline int GetReservedCapacityPerAvailabilityZone() const { return m_reservedCapacityPerAvailabilityZone; }
145 inline bool ReservedCapacityPerAvailabilityZoneHasBeenSet() const { return m_reservedCapacityPerAvailabilityZoneHasBeenSet; }
147 m_reservedCapacityPerAvailabilityZoneHasBeenSet = true;
148 m_reservedCapacityPerAvailabilityZone = value;
149 }
155
157
171 return m_availableCapacityPerAvailabilityZoneList;
172 }
173 inline bool AvailableCapacityPerAvailabilityZoneListHasBeenSet() const { return m_availableCapacityPerAvailabilityZoneListHasBeenSet; }
174 template <typename AvailableCapacityPerAvailabilityZoneListT = Aws::Vector<AvailableCapacityPerAvailabilityZone>>
175 void SetAvailableCapacityPerAvailabilityZoneList(AvailableCapacityPerAvailabilityZoneListT&& value) {
176 m_availableCapacityPerAvailabilityZoneListHasBeenSet = true;
177 m_availableCapacityPerAvailabilityZoneList = std::forward<AvailableCapacityPerAvailabilityZoneListT>(value);
178 }
179 template <typename AvailableCapacityPerAvailabilityZoneListT = Aws::Vector<AvailableCapacityPerAvailabilityZone>>
180 DBCapacityReservation& WithAvailableCapacityPerAvailabilityZoneList(AvailableCapacityPerAvailabilityZoneListT&& value) {
181 SetAvailableCapacityPerAvailabilityZoneList(std::forward<AvailableCapacityPerAvailabilityZoneListT>(value));
182 return *this;
183 }
184 template <typename AvailableCapacityPerAvailabilityZoneListT = AvailableCapacityPerAvailabilityZone>
185 DBCapacityReservation& AddAvailableCapacityPerAvailabilityZoneList(AvailableCapacityPerAvailabilityZoneListT&& value) {
186 m_availableCapacityPerAvailabilityZoneListHasBeenSet = true;
187 m_availableCapacityPerAvailabilityZoneList.emplace_back(std::forward<AvailableCapacityPerAvailabilityZoneListT>(value));
188 return *this;
189 }
191
193
204 inline const Aws::Utils::DateTime& GetEndDate() const { return m_endDate; }
205 inline bool EndDateHasBeenSet() const { return m_endDateHasBeenSet; }
206 template <typename EndDateT = Aws::Utils::DateTime>
207 void SetEndDate(EndDateT&& value) {
208 m_endDateHasBeenSet = true;
209 m_endDate = std::forward<EndDateT>(value);
210 }
211 template <typename EndDateT = Aws::Utils::DateTime>
213 SetEndDate(std::forward<EndDateT>(value));
214 return *this;
215 }
217
219
223 inline const Aws::Utils::DateTime& GetCreateDate() const { return m_createDate; }
224 inline bool CreateDateHasBeenSet() const { return m_createDateHasBeenSet; }
225 template <typename CreateDateT = Aws::Utils::DateTime>
226 void SetCreateDate(CreateDateT&& value) {
227 m_createDateHasBeenSet = true;
228 m_createDate = std::forward<CreateDateT>(value);
229 }
230 template <typename CreateDateT = Aws::Utils::DateTime>
231 DBCapacityReservation& WithCreateDate(CreateDateT&& value) {
232 SetCreateDate(std::forward<CreateDateT>(value));
233 return *this;
234 }
236
238
243 inline const Aws::Utils::DateTime& GetStartDate() const { return m_startDate; }
244 inline bool StartDateHasBeenSet() const { return m_startDateHasBeenSet; }
245 template <typename StartDateT = Aws::Utils::DateTime>
246 void SetStartDate(StartDateT&& value) {
247 m_startDateHasBeenSet = true;
248 m_startDate = std::forward<StartDateT>(value);
249 }
250 template <typename StartDateT = Aws::Utils::DateTime>
252 SetStartDate(std::forward<StartDateT>(value));
253 return *this;
254 }
256
258
262 inline const DBCapacityReservationCommitmentInfo& GetCommitmentInfo() const { return m_commitmentInfo; }
263 inline bool CommitmentInfoHasBeenSet() const { return m_commitmentInfoHasBeenSet; }
264 template <typename CommitmentInfoT = DBCapacityReservationCommitmentInfo>
265 void SetCommitmentInfo(CommitmentInfoT&& value) {
266 m_commitmentInfoHasBeenSet = true;
267 m_commitmentInfo = std::forward<CommitmentInfoT>(value);
268 }
269 template <typename CommitmentInfoT = DBCapacityReservationCommitmentInfo>
270 DBCapacityReservation& WithCommitmentInfo(CommitmentInfoT&& value) {
271 SetCommitmentInfo(std::forward<CommitmentInfoT>(value));
272 return *this;
273 }
275
277
298 inline DBCapacityReservationState GetState() const { return m_state; }
299 inline bool StateHasBeenSet() const { return m_stateHasBeenSet; }
301 m_stateHasBeenSet = true;
302 m_state = value;
303 }
305 SetState(value);
306 return *this;
307 }
309
311
314 inline const Aws::String& GetDBCapacityReservationArn() const { return m_dBCapacityReservationArn; }
315 inline bool DBCapacityReservationArnHasBeenSet() const { return m_dBCapacityReservationArnHasBeenSet; }
316 template <typename DBCapacityReservationArnT = Aws::String>
317 void SetDBCapacityReservationArn(DBCapacityReservationArnT&& value) {
318 m_dBCapacityReservationArnHasBeenSet = true;
319 m_dBCapacityReservationArn = std::forward<DBCapacityReservationArnT>(value);
320 }
321 template <typename DBCapacityReservationArnT = Aws::String>
322 DBCapacityReservation& WithDBCapacityReservationArn(DBCapacityReservationArnT&& value) {
323 SetDBCapacityReservationArn(std::forward<DBCapacityReservationArnT>(value));
324 return *this;
325 }
327
329
334 inline const Aws::String& GetDBCapacityReservationIdentifier() const { return m_dBCapacityReservationIdentifier; }
335 inline bool DBCapacityReservationIdentifierHasBeenSet() const { return m_dBCapacityReservationIdentifierHasBeenSet; }
336 template <typename DBCapacityReservationIdentifierT = Aws::String>
337 void SetDBCapacityReservationIdentifier(DBCapacityReservationIdentifierT&& value) {
338 m_dBCapacityReservationIdentifierHasBeenSet = true;
339 m_dBCapacityReservationIdentifier = std::forward<DBCapacityReservationIdentifierT>(value);
340 }
341 template <typename DBCapacityReservationIdentifierT = Aws::String>
342 DBCapacityReservation& WithDBCapacityReservationIdentifier(DBCapacityReservationIdentifierT&& value) {
343 SetDBCapacityReservationIdentifier(std::forward<DBCapacityReservationIdentifierT>(value));
344 return *this;
345 }
347
349
352 inline const Aws::Vector<Tag>& GetTagList() const { return m_tagList; }
353 inline bool TagListHasBeenSet() const { return m_tagListHasBeenSet; }
354 template <typename TagListT = Aws::Vector<Tag>>
355 void SetTagList(TagListT&& value) {
356 m_tagListHasBeenSet = true;
357 m_tagList = std::forward<TagListT>(value);
358 }
359 template <typename TagListT = Aws::Vector<Tag>>
361 SetTagList(std::forward<TagListT>(value));
362 return *this;
363 }
364 template <typename TagListT = Tag>
366 m_tagListHasBeenSet = true;
367 m_tagList.emplace_back(std::forward<TagListT>(value));
368 return *this;
369 }
371 private:
372 Aws::String m_dBCapacityReservationName;
373
374 Aws::String m_dBInstanceClass;
375
376 Aws::String m_engine;
377
378 Aws::String m_licenseModel;
379
380 int m_reservedCapacityPerAvailabilityZone{0};
381
382 Aws::Vector<AvailableCapacityPerAvailabilityZone> m_availableCapacityPerAvailabilityZoneList;
383
384 Aws::Utils::DateTime m_endDate{};
385
386 Aws::Utils::DateTime m_createDate{};
387
388 Aws::Utils::DateTime m_startDate{};
389
390 DBCapacityReservationCommitmentInfo m_commitmentInfo;
391
393
394 Aws::String m_dBCapacityReservationArn;
395
396 Aws::String m_dBCapacityReservationIdentifier;
397
398 Aws::Vector<Tag> m_tagList;
399 bool m_dBCapacityReservationNameHasBeenSet = false;
400 bool m_dBInstanceClassHasBeenSet = false;
401 bool m_engineHasBeenSet = false;
402 bool m_licenseModelHasBeenSet = false;
403 bool m_reservedCapacityPerAvailabilityZoneHasBeenSet = false;
404 bool m_availableCapacityPerAvailabilityZoneListHasBeenSet = false;
405 bool m_endDateHasBeenSet = false;
406 bool m_createDateHasBeenSet = false;
407 bool m_startDateHasBeenSet = false;
408 bool m_commitmentInfoHasBeenSet = false;
409 bool m_stateHasBeenSet = false;
410 bool m_dBCapacityReservationArnHasBeenSet = false;
411 bool m_dBCapacityReservationIdentifierHasBeenSet = false;
412 bool m_tagListHasBeenSet = false;
413};
414
415} // namespace Model
416} // namespace RDS
417} // namespace Aws
const Aws::Vector< Tag > & GetTagList() const
void SetDBCapacityReservationArn(DBCapacityReservationArnT &&value)
const Aws::Utils::DateTime & GetEndDate() const
void SetDBCapacityReservationIdentifier(DBCapacityReservationIdentifierT &&value)
const Aws::String & GetDBCapacityReservationName() const
DBCapacityReservation & WithCreateDate(CreateDateT &&value)
DBCapacityReservation & WithDBCapacityReservationIdentifier(DBCapacityReservationIdentifierT &&value)
void SetDBInstanceClass(DBInstanceClassT &&value)
DBCapacityReservation & WithLicenseModel(LicenseModelT &&value)
void SetDBCapacityReservationName(DBCapacityReservationNameT &&value)
const Aws::String & GetDBInstanceClass() const
const Aws::Utils::DateTime & GetCreateDate() const
AWS_RDS_API void OutputToStream(Aws::OStream &ostream, const char *location, unsigned index, const char *locationValue) const
DBCapacityReservation & WithStartDate(StartDateT &&value)
DBCapacityReservation & WithState(DBCapacityReservationState value)
DBCapacityReservation & WithEndDate(EndDateT &&value)
const Aws::Utils::DateTime & GetStartDate() const
void SetState(DBCapacityReservationState value)
DBCapacityReservation & AddAvailableCapacityPerAvailabilityZoneList(AvailableCapacityPerAvailabilityZoneListT &&value)
const Aws::Vector< AvailableCapacityPerAvailabilityZone > & GetAvailableCapacityPerAvailabilityZoneList() const
const Aws::String & GetDBCapacityReservationArn() const
void SetCommitmentInfo(CommitmentInfoT &&value)
DBCapacityReservationState GetState() const
const DBCapacityReservationCommitmentInfo & GetCommitmentInfo() const
DBCapacityReservation & AddTagList(TagListT &&value)
const Aws::String & GetDBCapacityReservationIdentifier() const
void SetAvailableCapacityPerAvailabilityZoneList(AvailableCapacityPerAvailabilityZoneListT &&value)
AWS_RDS_API DBCapacityReservation & operator=(const Aws::Utils::Xml::XmlNode &xmlNode)
DBCapacityReservation & WithDBInstanceClass(DBInstanceClassT &&value)
DBCapacityReservation & WithAvailableCapacityPerAvailabilityZoneList(AvailableCapacityPerAvailabilityZoneListT &&value)
AWS_RDS_API DBCapacityReservation(const Aws::Utils::Xml::XmlNode &xmlNode)
DBCapacityReservation & WithReservedCapacityPerAvailabilityZone(int value)
DBCapacityReservation & WithDBCapacityReservationArn(DBCapacityReservationArnT &&value)
DBCapacityReservation & WithEngine(EngineT &&value)
DBCapacityReservation & WithTagList(TagListT &&value)
AWS_RDS_API DBCapacityReservation()=default
DBCapacityReservation & WithDBCapacityReservationName(DBCapacityReservationNameT &&value)
DBCapacityReservation & WithCommitmentInfo(CommitmentInfoT &&value)
AWS_RDS_API void OutputToStream(Aws::OStream &oStream, const char *location) const
std::basic_string< char, std::char_traits< char >, Aws::Allocator< char > > String
std::basic_ostream< char, std::char_traits< char > > OStream
std::vector< T, Aws::Allocator< T > > Vector