AWS SDK for C++

AWS SDK for C++ Version 1.11.930

Loading...
Searching...
No Matches
CreateSpaceRequest.h
1
6#pragma once
7#include <aws/core/utils/UUID.h>
8#include <aws/core/utils/memory/stl/AWSString.h>
9#include <aws/core/utils/memory/stl/AWSVector.h>
10#include <aws/opensearchmemory/OpenSearchMemoryRequest.h>
11#include <aws/opensearchmemory/OpenSearchMemory_EXPORTS.h>
12#include <aws/opensearchmemory/model/EncryptionConfiguration.h>
13#include <aws/opensearchmemory/model/MemoryStrategy.h>
14#include <aws/opensearchmemory/model/Tag.h>
15
16#include <utility>
17
18namespace Aws {
19namespace OpenSearchMemory {
20namespace Model {
21
25 public:
26 AWS_OPENSEARCHMEMORY_API CreateSpaceRequest() = default;
27
28 // Service request name is the Operation name which will send this request out,
29 // each operation should has unique request name, so that we can get operation's name from this request.
30 // Note: this is not true for response, multiple operations may have the same response name,
31 // so we can not get operation's name from response.
32 inline virtual const char* GetServiceRequestName() const override { return "CreateSpace"; }
33
34 AWS_OPENSEARCHMEMORY_API Aws::String SerializePayload() const override;
35
36 AWS_OPENSEARCHMEMORY_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
37
39
44 inline const Aws::String& GetName() const { return m_name; }
45 inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
46 template <typename NameT = Aws::String>
47 void SetName(NameT&& value) {
48 m_nameHasBeenSet = true;
49 m_name = std::forward<NameT>(value);
50 }
51 template <typename NameT = Aws::String>
52 CreateSpaceRequest& WithName(NameT&& value) {
53 SetName(std::forward<NameT>(value));
54 return *this;
55 }
57
59
68 inline const Aws::Vector<MemoryStrategy>& GetMemoryStrategies() const { return m_memoryStrategies; }
69 inline bool MemoryStrategiesHasBeenSet() const { return m_memoryStrategiesHasBeenSet; }
70 template <typename MemoryStrategiesT = Aws::Vector<MemoryStrategy>>
71 void SetMemoryStrategies(MemoryStrategiesT&& value) {
72 m_memoryStrategiesHasBeenSet = true;
73 m_memoryStrategies = std::forward<MemoryStrategiesT>(value);
74 }
75 template <typename MemoryStrategiesT = Aws::Vector<MemoryStrategy>>
76 CreateSpaceRequest& WithMemoryStrategies(MemoryStrategiesT&& value) {
77 SetMemoryStrategies(std::forward<MemoryStrategiesT>(value));
78 return *this;
79 }
80 template <typename MemoryStrategiesT = MemoryStrategy>
81 CreateSpaceRequest& AddMemoryStrategies(MemoryStrategiesT&& value) {
82 m_memoryStrategiesHasBeenSet = true;
83 m_memoryStrategies.emplace_back(std::forward<MemoryStrategiesT>(value));
84 return *this;
85 }
87
89
93 inline int GetEventExpiryDays() const { return m_eventExpiryDays; }
94 inline bool EventExpiryDaysHasBeenSet() const { return m_eventExpiryDaysHasBeenSet; }
95 inline void SetEventExpiryDays(int value) {
96 m_eventExpiryDaysHasBeenSet = true;
97 m_eventExpiryDays = value;
98 }
100 SetEventExpiryDays(value);
101 return *this;
102 }
104
106
114 inline int GetMemoryExpiryDays() const { return m_memoryExpiryDays; }
115 inline bool MemoryExpiryDaysHasBeenSet() const { return m_memoryExpiryDaysHasBeenSet; }
116 inline void SetMemoryExpiryDays(int value) {
117 m_memoryExpiryDaysHasBeenSet = true;
118 m_memoryExpiryDays = value;
119 }
121 SetMemoryExpiryDays(value);
122 return *this;
123 }
125
127
136 inline const Aws::String& GetExtractionModelId() const { return m_extractionModelId; }
137 inline bool ExtractionModelIdHasBeenSet() const { return m_extractionModelIdHasBeenSet; }
138 template <typename ExtractionModelIdT = Aws::String>
139 void SetExtractionModelId(ExtractionModelIdT&& value) {
140 m_extractionModelIdHasBeenSet = true;
141 m_extractionModelId = std::forward<ExtractionModelIdT>(value);
142 }
143 template <typename ExtractionModelIdT = Aws::String>
144 CreateSpaceRequest& WithExtractionModelId(ExtractionModelIdT&& value) {
145 SetExtractionModelId(std::forward<ExtractionModelIdT>(value));
146 return *this;
147 }
149
151
156 inline const EncryptionConfiguration& GetEncryptionConfiguration() const { return m_encryptionConfiguration; }
157 inline bool EncryptionConfigurationHasBeenSet() const { return m_encryptionConfigurationHasBeenSet; }
158 template <typename EncryptionConfigurationT = EncryptionConfiguration>
159 void SetEncryptionConfiguration(EncryptionConfigurationT&& value) {
160 m_encryptionConfigurationHasBeenSet = true;
161 m_encryptionConfiguration = std::forward<EncryptionConfigurationT>(value);
162 }
163 template <typename EncryptionConfigurationT = EncryptionConfiguration>
164 CreateSpaceRequest& WithEncryptionConfiguration(EncryptionConfigurationT&& value) {
165 SetEncryptionConfiguration(std::forward<EncryptionConfigurationT>(value));
166 return *this;
167 }
169
171
174 inline const Aws::Vector<Tag>& GetTags() const { return m_tags; }
175 inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
176 template <typename TagsT = Aws::Vector<Tag>>
177 void SetTags(TagsT&& value) {
178 m_tagsHasBeenSet = true;
179 m_tags = std::forward<TagsT>(value);
180 }
181 template <typename TagsT = Aws::Vector<Tag>>
182 CreateSpaceRequest& WithTags(TagsT&& value) {
183 SetTags(std::forward<TagsT>(value));
184 return *this;
185 }
186 template <typename TagsT = Tag>
187 CreateSpaceRequest& AddTags(TagsT&& value) {
188 m_tagsHasBeenSet = true;
189 m_tags.emplace_back(std::forward<TagsT>(value));
190 return *this;
191 }
193
195
202 inline const Aws::String& GetClientToken() const { return m_clientToken; }
203 inline bool ClientTokenHasBeenSet() const { return m_clientTokenHasBeenSet; }
204 template <typename ClientTokenT = Aws::String>
205 void SetClientToken(ClientTokenT&& value) {
206 m_clientTokenHasBeenSet = true;
207 m_clientToken = std::forward<ClientTokenT>(value);
208 }
209 template <typename ClientTokenT = Aws::String>
210 CreateSpaceRequest& WithClientToken(ClientTokenT&& value) {
211 SetClientToken(std::forward<ClientTokenT>(value));
212 return *this;
213 }
215 private:
216 Aws::String m_name;
217
218 Aws::Vector<MemoryStrategy> m_memoryStrategies;
219
220 int m_eventExpiryDays{0};
221
222 int m_memoryExpiryDays{0};
223
224 Aws::String m_extractionModelId;
225
226 EncryptionConfiguration m_encryptionConfiguration;
227
228 Aws::Vector<Tag> m_tags;
229
231 bool m_nameHasBeenSet = false;
232 bool m_memoryStrategiesHasBeenSet = false;
233 bool m_eventExpiryDaysHasBeenSet = false;
234 bool m_memoryExpiryDaysHasBeenSet = false;
235 bool m_extractionModelIdHasBeenSet = false;
236 bool m_encryptionConfigurationHasBeenSet = false;
237 bool m_tagsHasBeenSet = false;
238 bool m_clientTokenHasBeenSet = true;
239};
240
241} // namespace Model
242} // namespace OpenSearchMemory
243} // namespace Aws
virtual const char * GetServiceRequestName() const override
CreateSpaceRequest & WithClientToken(ClientTokenT &&value)
CreateSpaceRequest & WithTags(TagsT &&value)
CreateSpaceRequest & AddTags(TagsT &&value)
CreateSpaceRequest & WithMemoryStrategies(MemoryStrategiesT &&value)
void SetEncryptionConfiguration(EncryptionConfigurationT &&value)
CreateSpaceRequest & WithEncryptionConfiguration(EncryptionConfigurationT &&value)
CreateSpaceRequest & WithMemoryExpiryDays(int value)
const EncryptionConfiguration & GetEncryptionConfiguration() const
CreateSpaceRequest & WithEventExpiryDays(int value)
void SetExtractionModelId(ExtractionModelIdT &&value)
CreateSpaceRequest & WithName(NameT &&value)
AWS_OPENSEARCHMEMORY_API Aws::String SerializePayload() const override
void SetMemoryStrategies(MemoryStrategiesT &&value)
AWS_OPENSEARCHMEMORY_API CreateSpaceRequest()=default
AWS_OPENSEARCHMEMORY_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override
const Aws::Vector< MemoryStrategy > & GetMemoryStrategies() const
CreateSpaceRequest & AddMemoryStrategies(MemoryStrategiesT &&value)
CreateSpaceRequest & WithExtractionModelId(ExtractionModelIdT &&value)
static Aws::Utils::UUID PseudoRandomUUID()
Aws::Map< Aws::String, Aws::String > HeaderValueCollection
std::basic_string< char, std::char_traits< char >, Aws::Allocator< char > > String
std::vector< T, Aws::Allocator< T > > Vector