1585346868/aliyun-openapi-cpp-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update HDENI and LENI API.

Browse Source
This commit is contained in:
sdk-team
2024-05-06 08:43:09 +00:00
parent ac7c0da065
commit cbe97f842a
52 changed files with 1667 additions and 13 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
eflo/CMakeLists.txt
View File

@@ -21,6 +21,8 @@ set(eflo_public_header
include/alibabacloud/eflo/EfloExport.h )
set(eflo_public_header_model
include/alibabacloud/eflo/model/AssignLeniPrivateIpAddressRequest.h
include/alibabacloud/eflo/model/AssignLeniPrivateIpAddressResult.h
include/alibabacloud/eflo/model/AssignPrivateIpAddressRequest.h
include/alibabacloud/eflo/model/AssignPrivateIpAddressResult.h
include/alibabacloud/eflo/model/AssociateVpdCidrBlockRequest.h
@@ -77,6 +79,8 @@ set(eflo_public_header_model
include/alibabacloud/eflo/model/GetErRouteMapResult.h
include/alibabacloud/eflo/model/GetFabricTopologyRequest.h
include/alibabacloud/eflo/model/GetFabricTopologyResult.h
include/alibabacloud/eflo/model/GetLeniPrivateIpAddressRequest.h
include/alibabacloud/eflo/model/GetLeniPrivateIpAddressResult.h
include/alibabacloud/eflo/model/GetLniPrivateIpAddressRequest.h
include/alibabacloud/eflo/model/GetLniPrivateIpAddressResult.h
include/alibabacloud/eflo/model/GetNetworkInterfaceRequest.h
@@ -111,6 +115,8 @@ set(eflo_public_header_model
include/alibabacloud/eflo/model/ListErsResult.h
include/alibabacloud/eflo/model/ListInstancesByNcdRequest.h
include/alibabacloud/eflo/model/ListInstancesByNcdResult.h
include/alibabacloud/eflo/model/ListLeniPrivateIpAddressesRequest.h
include/alibabacloud/eflo/model/ListLeniPrivateIpAddressesResult.h
include/alibabacloud/eflo/model/ListLniPrivateIpAddressRequest.h
include/alibabacloud/eflo/model/ListLniPrivateIpAddressResult.h
include/alibabacloud/eflo/model/ListNetworkInterfacesRequest.h
@@ -137,6 +143,8 @@ set(eflo_public_header_model
include/alibabacloud/eflo/model/UnAssignPrivateIpAddressResult.h
include/alibabacloud/eflo/model/UnAssociateVpdCidrBlockRequest.h
include/alibabacloud/eflo/model/UnAssociateVpdCidrBlockResult.h
include/alibabacloud/eflo/model/UnassignLeniPrivateIpAddressRequest.h
include/alibabacloud/eflo/model/UnassignLeniPrivateIpAddressResult.h
include/alibabacloud/eflo/model/UpdateElasticNetworkInterfaceRequest.h
include/alibabacloud/eflo/model/UpdateElasticNetworkInterfaceResult.h
include/alibabacloud/eflo/model/UpdateErRequest.h
@@ -145,6 +153,8 @@ set(eflo_public_header_model
include/alibabacloud/eflo/model/UpdateErAttachmentResult.h
include/alibabacloud/eflo/model/UpdateErRouteMapRequest.h
include/alibabacloud/eflo/model/UpdateErRouteMapResult.h
include/alibabacloud/eflo/model/UpdateLeniPrivateIpAddressRequest.h
include/alibabacloud/eflo/model/UpdateLeniPrivateIpAddressResult.h
include/alibabacloud/eflo/model/UpdateSubnetRequest.h
include/alibabacloud/eflo/model/UpdateSubnetResult.h
include/alibabacloud/eflo/model/UpdateVccRequest.h
@@ -154,6 +164,8 @@ set(eflo_public_header_model
set(eflo_src
src/EfloClient.cc
src/model/AssignLeniPrivateIpAddressRequest.cc
src/model/AssignLeniPrivateIpAddressResult.cc
src/model/AssignPrivateIpAddressRequest.cc
src/model/AssignPrivateIpAddressResult.cc
src/model/AssociateVpdCidrBlockRequest.cc
@@ -210,6 +222,8 @@ set(eflo_src
src/model/GetErRouteMapResult.cc
src/model/GetFabricTopologyRequest.cc
src/model/GetFabricTopologyResult.cc
src/model/GetLeniPrivateIpAddressRequest.cc
src/model/GetLeniPrivateIpAddressResult.cc
src/model/GetLniPrivateIpAddressRequest.cc
src/model/GetLniPrivateIpAddressResult.cc
src/model/GetNetworkInterfaceRequest.cc
@@ -244,6 +258,8 @@ set(eflo_src
src/model/ListErsResult.cc
src/model/ListInstancesByNcdRequest.cc
src/model/ListInstancesByNcdResult.cc
src/model/ListLeniPrivateIpAddressesRequest.cc
src/model/ListLeniPrivateIpAddressesResult.cc
src/model/ListLniPrivateIpAddressRequest.cc
src/model/ListLniPrivateIpAddressResult.cc
src/model/ListNetworkInterfacesRequest.cc
@@ -270,6 +286,8 @@ set(eflo_src
src/model/UnAssignPrivateIpAddressResult.cc
src/model/UnAssociateVpdCidrBlockRequest.cc
src/model/UnAssociateVpdCidrBlockResult.cc
src/model/UnassignLeniPrivateIpAddressRequest.cc
src/model/UnassignLeniPrivateIpAddressResult.cc
src/model/UpdateElasticNetworkInterfaceRequest.cc
src/model/UpdateElasticNetworkInterfaceResult.cc
src/model/UpdateErRequest.cc
@@ -278,6 +296,8 @@ set(eflo_src
src/model/UpdateErAttachmentResult.cc
src/model/UpdateErRouteMapRequest.cc
src/model/UpdateErRouteMapResult.cc
src/model/UpdateLeniPrivateIpAddressRequest.cc
src/model/UpdateLeniPrivateIpAddressResult.cc
src/model/UpdateSubnetRequest.cc
src/model/UpdateSubnetResult.cc
src/model/UpdateVccRequest.cc

40
eflo/include/alibabacloud/eflo/EfloClient.h
View File

@@ -22,6 +22,8 @@
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "EfloExport.h"
#include "model/AssignLeniPrivateIpAddressRequest.h"
#include "model/AssignLeniPrivateIpAddressResult.h"
#include "model/AssignPrivateIpAddressRequest.h"
#include "model/AssignPrivateIpAddressResult.h"
#include "model/AssociateVpdCidrBlockRequest.h"
@@ -78,6 +80,8 @@
#include "model/GetErRouteMapResult.h"
#include "model/GetFabricTopologyRequest.h"
#include "model/GetFabricTopologyResult.h"
#include "model/GetLeniPrivateIpAddressRequest.h"
#include "model/GetLeniPrivateIpAddressResult.h"
#include "model/GetLniPrivateIpAddressRequest.h"
#include "model/GetLniPrivateIpAddressResult.h"
#include "model/GetNetworkInterfaceRequest.h"
@@ -112,6 +116,8 @@
#include "model/ListErsResult.h"
#include "model/ListInstancesByNcdRequest.h"
#include "model/ListInstancesByNcdResult.h"
#include "model/ListLeniPrivateIpAddressesRequest.h"
#include "model/ListLeniPrivateIpAddressesResult.h"
#include "model/ListLniPrivateIpAddressRequest.h"
#include "model/ListLniPrivateIpAddressResult.h"
#include "model/ListNetworkInterfacesRequest.h"
@@ -138,6 +144,8 @@
#include "model/UnAssignPrivateIpAddressResult.h"
#include "model/UnAssociateVpdCidrBlockRequest.h"
#include "model/UnAssociateVpdCidrBlockResult.h"
#include "model/UnassignLeniPrivateIpAddressRequest.h"
#include "model/UnassignLeniPrivateIpAddressResult.h"
#include "model/UpdateElasticNetworkInterfaceRequest.h"
#include "model/UpdateElasticNetworkInterfaceResult.h"
#include "model/UpdateErRequest.h"
@@ -146,6 +154,8 @@
#include "model/UpdateErAttachmentResult.h"
#include "model/UpdateErRouteMapRequest.h"
#include "model/UpdateErRouteMapResult.h"
#include "model/UpdateLeniPrivateIpAddressRequest.h"
#include "model/UpdateLeniPrivateIpAddressResult.h"
#include "model/UpdateSubnetRequest.h"
#include "model/UpdateSubnetResult.h"
#include "model/UpdateVccRequest.h"
@@ -161,6 +171,9 @@ namespace AlibabaCloud
class ALIBABACLOUD_EFLO_EXPORT EfloClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::AssignLeniPrivateIpAddressResult> AssignLeniPrivateIpAddressOutcome;
typedef std::future<AssignLeniPrivateIpAddressOutcome> AssignLeniPrivateIpAddressOutcomeCallable;
typedef std::function<void(const EfloClient*, const Model::AssignLeniPrivateIpAddressRequest&, const AssignLeniPrivateIpAddressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AssignLeniPrivateIpAddressAsyncHandler;
typedef Outcome<Error, Model::AssignPrivateIpAddressResult> AssignPrivateIpAddressOutcome;
typedef std::future<AssignPrivateIpAddressOutcome> AssignPrivateIpAddressOutcomeCallable;
typedef std::function<void(const EfloClient*, const Model::AssignPrivateIpAddressRequest&, const AssignPrivateIpAddressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AssignPrivateIpAddressAsyncHandler;
@@ -245,6 +258,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::GetFabricTopologyResult> GetFabricTopologyOutcome;
typedef std::future<GetFabricTopologyOutcome> GetFabricTopologyOutcomeCallable;
typedef std::function<void(const EfloClient*, const Model::GetFabricTopologyRequest&, const GetFabricTopologyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetFabricTopologyAsyncHandler;
typedef Outcome<Error, Model::GetLeniPrivateIpAddressResult> GetLeniPrivateIpAddressOutcome;
typedef std::future<GetLeniPrivateIpAddressOutcome> GetLeniPrivateIpAddressOutcomeCallable;
typedef std::function<void(const EfloClient*, const Model::GetLeniPrivateIpAddressRequest&, const GetLeniPrivateIpAddressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetLeniPrivateIpAddressAsyncHandler;
typedef Outcome<Error, Model::GetLniPrivateIpAddressResult> GetLniPrivateIpAddressOutcome;
typedef std::future<GetLniPrivateIpAddressOutcome> GetLniPrivateIpAddressOutcomeCallable;
typedef std::function<void(const EfloClient*, const Model::GetLniPrivateIpAddressRequest&, const GetLniPrivateIpAddressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetLniPrivateIpAddressAsyncHandler;
@@ -296,6 +312,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::ListInstancesByNcdResult> ListInstancesByNcdOutcome;
typedef std::future<ListInstancesByNcdOutcome> ListInstancesByNcdOutcomeCallable;
typedef std::function<void(const EfloClient*, const Model::ListInstancesByNcdRequest&, const ListInstancesByNcdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListInstancesByNcdAsyncHandler;
typedef Outcome<Error, Model::ListLeniPrivateIpAddressesResult> ListLeniPrivateIpAddressesOutcome;
typedef std::future<ListLeniPrivateIpAddressesOutcome> ListLeniPrivateIpAddressesOutcomeCallable;
typedef std::function<void(const EfloClient*, const Model::ListLeniPrivateIpAddressesRequest&, const ListLeniPrivateIpAddressesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListLeniPrivateIpAddressesAsyncHandler;
typedef Outcome<Error, Model::ListLniPrivateIpAddressResult> ListLniPrivateIpAddressOutcome;
typedef std::future<ListLniPrivateIpAddressOutcome> ListLniPrivateIpAddressOutcomeCallable;
typedef std::function<void(const EfloClient*, const Model::ListLniPrivateIpAddressRequest&, const ListLniPrivateIpAddressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListLniPrivateIpAddressAsyncHandler;
@@ -335,6 +354,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::UnAssociateVpdCidrBlockResult> UnAssociateVpdCidrBlockOutcome;
typedef std::future<UnAssociateVpdCidrBlockOutcome> UnAssociateVpdCidrBlockOutcomeCallable;
typedef std::function<void(const EfloClient*, const Model::UnAssociateVpdCidrBlockRequest&, const UnAssociateVpdCidrBlockOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UnAssociateVpdCidrBlockAsyncHandler;
typedef Outcome<Error, Model::UnassignLeniPrivateIpAddressResult> UnassignLeniPrivateIpAddressOutcome;
typedef std::future<UnassignLeniPrivateIpAddressOutcome> UnassignLeniPrivateIpAddressOutcomeCallable;
typedef std::function<void(const EfloClient*, const Model::UnassignLeniPrivateIpAddressRequest&, const UnassignLeniPrivateIpAddressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UnassignLeniPrivateIpAddressAsyncHandler;
typedef Outcome<Error, Model::UpdateElasticNetworkInterfaceResult> UpdateElasticNetworkInterfaceOutcome;
typedef std::future<UpdateElasticNetworkInterfaceOutcome> UpdateElasticNetworkInterfaceOutcomeCallable;
typedef std::function<void(const EfloClient*, const Model::UpdateElasticNetworkInterfaceRequest&, const UpdateElasticNetworkInterfaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateElasticNetworkInterfaceAsyncHandler;
@@ -347,6 +369,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::UpdateErRouteMapResult> UpdateErRouteMapOutcome;
typedef std::future<UpdateErRouteMapOutcome> UpdateErRouteMapOutcomeCallable;
typedef std::function<void(const EfloClient*, const Model::UpdateErRouteMapRequest&, const UpdateErRouteMapOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateErRouteMapAsyncHandler;
typedef Outcome<Error, Model::UpdateLeniPrivateIpAddressResult> UpdateLeniPrivateIpAddressOutcome;
typedef std::future<UpdateLeniPrivateIpAddressOutcome> UpdateLeniPrivateIpAddressOutcomeCallable;
typedef std::function<void(const EfloClient*, const Model::UpdateLeniPrivateIpAddressRequest&, const UpdateLeniPrivateIpAddressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateLeniPrivateIpAddressAsyncHandler;
typedef Outcome<Error, Model::UpdateSubnetResult> UpdateSubnetOutcome;
typedef std::future<UpdateSubnetOutcome> UpdateSubnetOutcomeCallable;
typedef std::function<void(const EfloClient*, const Model::UpdateSubnetRequest&, const UpdateSubnetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateSubnetAsyncHandler;
@@ -361,6 +386,9 @@ namespace AlibabaCloud
EfloClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
EfloClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~EfloClient();
AssignLeniPrivateIpAddressOutcome assignLeniPrivateIpAddress(const Model::AssignLeniPrivateIpAddressRequest &request)const;
void assignLeniPrivateIpAddressAsync(const Model::AssignLeniPrivateIpAddressRequest& request, const AssignLeniPrivateIpAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AssignLeniPrivateIpAddressOutcomeCallable assignLeniPrivateIpAddressCallable(const Model::AssignLeniPrivateIpAddressRequest& request) const;
AssignPrivateIpAddressOutcome assignPrivateIpAddress(const Model::AssignPrivateIpAddressRequest &request)const;
void assignPrivateIpAddressAsync(const Model::AssignPrivateIpAddressRequest& request, const AssignPrivateIpAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AssignPrivateIpAddressOutcomeCallable assignPrivateIpAddressCallable(const Model::AssignPrivateIpAddressRequest& request) const;
@@ -445,6 +473,9 @@ namespace AlibabaCloud
GetFabricTopologyOutcome getFabricTopology(const Model::GetFabricTopologyRequest &request)const;
void getFabricTopologyAsync(const Model::GetFabricTopologyRequest& request, const GetFabricTopologyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetFabricTopologyOutcomeCallable getFabricTopologyCallable(const Model::GetFabricTopologyRequest& request) const;
GetLeniPrivateIpAddressOutcome getLeniPrivateIpAddress(const Model::GetLeniPrivateIpAddressRequest &request)const;
void getLeniPrivateIpAddressAsync(const Model::GetLeniPrivateIpAddressRequest& request, const GetLeniPrivateIpAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetLeniPrivateIpAddressOutcomeCallable getLeniPrivateIpAddressCallable(const Model::GetLeniPrivateIpAddressRequest& request) const;
GetLniPrivateIpAddressOutcome getLniPrivateIpAddress(const Model::GetLniPrivateIpAddressRequest &request)const;
void getLniPrivateIpAddressAsync(const Model::GetLniPrivateIpAddressRequest& request, const GetLniPrivateIpAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetLniPrivateIpAddressOutcomeCallable getLniPrivateIpAddressCallable(const Model::GetLniPrivateIpAddressRequest& request) const;
@@ -496,6 +527,9 @@ namespace AlibabaCloud
ListInstancesByNcdOutcome listInstancesByNcd(const Model::ListInstancesByNcdRequest &request)const;
void listInstancesByNcdAsync(const Model::ListInstancesByNcdRequest& request, const ListInstancesByNcdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListInstancesByNcdOutcomeCallable listInstancesByNcdCallable(const Model::ListInstancesByNcdRequest& request) const;
ListLeniPrivateIpAddressesOutcome listLeniPrivateIpAddresses(const Model::ListLeniPrivateIpAddressesRequest &request)const;
void listLeniPrivateIpAddressesAsync(const Model::ListLeniPrivateIpAddressesRequest& request, const ListLeniPrivateIpAddressesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListLeniPrivateIpAddressesOutcomeCallable listLeniPrivateIpAddressesCallable(const Model::ListLeniPrivateIpAddressesRequest& request) const;
ListLniPrivateIpAddressOutcome listLniPrivateIpAddress(const Model::ListLniPrivateIpAddressRequest &request)const;
void listLniPrivateIpAddressAsync(const Model::ListLniPrivateIpAddressRequest& request, const ListLniPrivateIpAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListLniPrivateIpAddressOutcomeCallable listLniPrivateIpAddressCallable(const Model::ListLniPrivateIpAddressRequest& request) const;
@@ -535,6 +569,9 @@ namespace AlibabaCloud
UnAssociateVpdCidrBlockOutcome unAssociateVpdCidrBlock(const Model::UnAssociateVpdCidrBlockRequest &request)const;
void unAssociateVpdCidrBlockAsync(const Model::UnAssociateVpdCidrBlockRequest& request, const UnAssociateVpdCidrBlockAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UnAssociateVpdCidrBlockOutcomeCallable unAssociateVpdCidrBlockCallable(const Model::UnAssociateVpdCidrBlockRequest& request) const;
UnassignLeniPrivateIpAddressOutcome unassignLeniPrivateIpAddress(const Model::UnassignLeniPrivateIpAddressRequest &request)const;
void unassignLeniPrivateIpAddressAsync(const Model::UnassignLeniPrivateIpAddressRequest& request, const UnassignLeniPrivateIpAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UnassignLeniPrivateIpAddressOutcomeCallable unassignLeniPrivateIpAddressCallable(const Model::UnassignLeniPrivateIpAddressRequest& request) const;
UpdateElasticNetworkInterfaceOutcome updateElasticNetworkInterface(const Model::UpdateElasticNetworkInterfaceRequest &request)const;
void updateElasticNetworkInterfaceAsync(const Model::UpdateElasticNetworkInterfaceRequest& request, const UpdateElasticNetworkInterfaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateElasticNetworkInterfaceOutcomeCallable updateElasticNetworkInterfaceCallable(const Model::UpdateElasticNetworkInterfaceRequest& request) const;
@@ -547,6 +584,9 @@ namespace AlibabaCloud
UpdateErRouteMapOutcome updateErRouteMap(const Model::UpdateErRouteMapRequest &request)const;
void updateErRouteMapAsync(const Model::UpdateErRouteMapRequest& request, const UpdateErRouteMapAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateErRouteMapOutcomeCallable updateErRouteMapCallable(const Model::UpdateErRouteMapRequest& request) const;
UpdateLeniPrivateIpAddressOutcome updateLeniPrivateIpAddress(const Model::UpdateLeniPrivateIpAddressRequest &request)const;
void updateLeniPrivateIpAddressAsync(const Model::UpdateLeniPrivateIpAddressRequest& request, const UpdateLeniPrivateIpAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateLeniPrivateIpAddressOutcomeCallable updateLeniPrivateIpAddressCallable(const Model::UpdateLeniPrivateIpAddressRequest& request) const;
UpdateSubnetOutcome updateSubnet(const Model::UpdateSubnetRequest &request)const;
void updateSubnetAsync(const Model::UpdateSubnetRequest& request, const UpdateSubnetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateSubnetOutcomeCallable updateSubnetCallable(const Model::UpdateSubnetRequest& request) const;

54
eflo/include/alibabacloud/eflo/model/AssignLeniPrivateIpAddressRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_EFLO_MODEL_ASSIGNLENIPRIVATEIPADDRESSREQUEST_H_
#define ALIBABACLOUD_EFLO_MODEL_ASSIGNLENIPRIVATEIPADDRESSREQUEST_H_
#include <alibabacloud/eflo/EfloExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Eflo {
namespace Model {
class ALIBABACLOUD_EFLO_EXPORT AssignLeniPrivateIpAddressRequest : public RpcServiceRequest {
public:
AssignLeniPrivateIpAddressRequest();
~AssignLeniPrivateIpAddressRequest();
std::string getClientToken() const;
void setClientToken(const std::string &clientToken);
std::string getDescription() const;
void setDescription(const std::string &description);
std::string getPrivateIpAddress() const;
void setPrivateIpAddress(const std::string &privateIpAddress);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getElasticNetworkInterfaceId() const;
void setElasticNetworkInterfaceId(const std::string &elasticNetworkInterfaceId);
private:
std::string clientToken_;
std::string description_;
std::string privateIpAddress_;
std::string regionId_;
std::string elasticNetworkInterfaceId_;
};
} // namespace Model
} // namespace Eflo
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_MODEL_ASSIGNLENIPRIVATEIPADDRESSREQUEST_H_

60
eflo/include/alibabacloud/eflo/model/AssignLeniPrivateIpAddressResult.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_EFLO_MODEL_ASSIGNLENIPRIVATEIPADDRESSRESULT_H_
#define ALIBABACLOUD_EFLO_MODEL_ASSIGNLENIPRIVATEIPADDRESSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/eflo/EfloExport.h>
namespace AlibabaCloud
{
namespace Eflo
{
namespace Model
{
class ALIBABACLOUD_EFLO_EXPORT AssignLeniPrivateIpAddressResult : public ServiceResult
{
public:
struct Content
{
std::string ipName;
std::string elasticNetworkInterfaceId;
};
AssignLeniPrivateIpAddressResult();
explicit AssignLeniPrivateIpAddressResult(const std::string &payload);
~AssignLeniPrivateIpAddressResult();
std::string getMessage()const;
Content getContent()const;
int getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
Content content_;
int code_;
};
}
}
}
#endif // !ALIBABACLOUD_EFLO_MODEL_ASSIGNLENIPRIVATEIPADDRESSRESULT_H_

6
eflo/include/alibabacloud/eflo/model/DeleteVpdGrantRuleRequest.h
View File

@@ -36,17 +36,17 @@ public:
void setGrantTenantId(const std::string &grantTenantId);
std::string getInstanceId() const;
void setInstanceId(const std::string &instanceId);
std::string getGrantRuleId() const;
void setGrantRuleId(const std::string &grantRuleId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getGrantRuleId() const;
void setGrantRuleId(const std::string &grantRuleId);
private:
std::string erId_;
std::string grantTenantId_;
std::string instanceId_;
std::string grantRuleId_;
std::string regionId_;
std::string grantRuleId_;
};
} // namespace Model
} // namespace Eflo

1
eflo/include/alibabacloud/eflo/model/GetElasticNetworkInterfaceResult.h
View File

@@ -54,6 +54,7 @@ namespace AlibabaCloud
std::string ip;
std::string vSwitchId;
std::string createTime;
std::string securityGroupId;
std::string mask;
std::string gmtModified;
std::string mac;

48
eflo/include/alibabacloud/eflo/model/GetLeniPrivateIpAddressRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_EFLO_MODEL_GETLENIPRIVATEIPADDRESSREQUEST_H_
#define ALIBABACLOUD_EFLO_MODEL_GETLENIPRIVATEIPADDRESSREQUEST_H_
#include <alibabacloud/eflo/EfloExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Eflo {
namespace Model {
class ALIBABACLOUD_EFLO_EXPORT GetLeniPrivateIpAddressRequest : public RpcServiceRequest {
public:
GetLeniPrivateIpAddressRequest();
~GetLeniPrivateIpAddressRequest();
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getIpName() const;
void setIpName(const std::string &ipName);
std::string getElasticNetworkInterfaceId() const;
void setElasticNetworkInterfaceId(const std::string &elasticNetworkInterfaceId);
private:
std::string regionId_;
std::string ipName_;
std::string elasticNetworkInterfaceId_;
};
} // namespace Model
} // namespace Eflo
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_MODEL_GETLENIPRIVATEIPADDRESSREQUEST_H_

67
eflo/include/alibabacloud/eflo/model/GetLeniPrivateIpAddressResult.h Normal file
View File

@@ -0,0 +1,67 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_EFLO_MODEL_GETLENIPRIVATEIPADDRESSRESULT_H_
#define ALIBABACLOUD_EFLO_MODEL_GETLENIPRIVATEIPADDRESSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/eflo/EfloExport.h>
namespace AlibabaCloud
{
namespace Eflo
{
namespace Model
{
class ALIBABACLOUD_EFLO_EXPORT GetLeniPrivateIpAddressResult : public ServiceResult
{
public:
struct Content
{
std::string status;
std::string elasticNetworkInterfaceId;
std::string gmtCreate;
std::string ipName;
std::string privateIpAddress;
std::string description;
std::string message;
std::string gmtModified;
std::string regionId;
};
GetLeniPrivateIpAddressResult();
explicit GetLeniPrivateIpAddressResult(const std::string &payload);
~GetLeniPrivateIpAddressResult();
std::string getMessage()const;
Content getContent()const;
int getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
Content content_;
int code_;
};
}
}
}
#endif // !ALIBABACLOUD_EFLO_MODEL_GETLENIPRIVATEIPADDRESSRESULT_H_

1
eflo/include/alibabacloud/eflo/model/GetNodeInfoForPodResult.h
View File

@@ -36,6 +36,7 @@ namespace AlibabaCloud
{
std::string zoneId;
std::string vpcId;
int hdeniQuota;
std::string clusterId;
int lniSipQuota;
std::string nodeId;

1
eflo/include/alibabacloud/eflo/model/GetVccGrantRuleResult.h
View File

@@ -37,6 +37,7 @@ namespace AlibabaCloud
std::string instanceName;
std::string tenantId;
std::string grantTenantId;
std::string resourceGroupId;
std::string instanceId;
bool used;
std::string createTime;

3
eflo/include/alibabacloud/eflo/model/GetVccRequest.h
View File

@@ -30,6 +30,8 @@ class ALIBABACLOUD_EFLO_EXPORT GetVccRequest : public RpcServiceRequest {
public:
GetVccRequest();
~GetVccRequest();
std::string getClientToken() const;
void setClientToken(const std::string &clientToken);
int getPageNumber() const;
void setPageNumber(int pageNumber);
std::string getRegionId() const;
@@ -42,6 +44,7 @@ public:
void setVccId(const std::string &vccId);
private:
std::string clientToken_;
int pageNumber_;
std::string regionId_;
bool enablePage_;

18
eflo/include/alibabacloud/eflo/model/GetVccResult.h
View File

@@ -84,6 +84,23 @@ namespace AlibabaCloud
std::string tagKey;
std::string tagValue;
};
struct VbrInfo
{
struct VbrBgpPeer
{
std::string status;
std::string bgpPeerId;
std::string peerIpAddress;
std::string peerAsn;
std::string bgpGroupId;
};
std::string status;
std::string gmtCreate;
std::vector<VbrInfo::VbrBgpPeer> vbrBgpPeers;
std::string cenId;
std::string gmtModified;
std::string vbrId;
};
std::string message;
std::string resourceGroupId;
std::string lineOperator;
@@ -112,6 +129,7 @@ namespace AlibabaCloud
std::string vpdId;
std::vector<ErInfo> erInfos;
std::string cenOwnerId;
std::vector<VbrInfo> vbrInfos;
bool attachErStatus;
std::string cenId;
std::string accessPointId;

1
eflo/include/alibabacloud/eflo/model/GetVccRouteEntryResult.h
View File

@@ -39,6 +39,7 @@ namespace AlibabaCloud
std::string nextHopType;
std::string tenantId;
std::string routeType;
std::string message;
std::string nextHopId;
std::string gmtModified;
std::string regionId;

1
eflo/include/alibabacloud/eflo/model/GetVpdGrantRuleResult.h
View File

@@ -37,6 +37,7 @@ namespace AlibabaCloud
std::string instanceName;
std::string tenantId;
std::string grantTenantId;
std::string resourceGroupId;
std::string instanceId;
bool used;
std::string createTime;

1
eflo/include/alibabacloud/eflo/model/ListElasticNetworkInterfacesResult.h
View File

@@ -43,6 +43,7 @@ namespace AlibabaCloud
std::string ip;
std::string vSwitchId;
std::string createTime;
std::string securityGroupId;
std::string mask;
std::string gmtModified;
std::string mac;

60
eflo/include/alibabacloud/eflo/model/ListLeniPrivateIpAddressesRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_EFLO_MODEL_LISTLENIPRIVATEIPADDRESSESREQUEST_H_
#define ALIBABACLOUD_EFLO_MODEL_LISTLENIPRIVATEIPADDRESSESREQUEST_H_
#include <alibabacloud/eflo/EfloExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Eflo {
namespace Model {
class ALIBABACLOUD_EFLO_EXPORT ListLeniPrivateIpAddressesRequest : public RpcServiceRequest {
public:
ListLeniPrivateIpAddressesRequest();
~ListLeniPrivateIpAddressesRequest();
int getPageNumber() const;
void setPageNumber(int pageNumber);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
int getPageSize() const;
void setPageSize(int pageSize);
std::string getPrivateIpAddress() const;
void setPrivateIpAddress(const std::string &privateIpAddress);
std::string getIpName() const;
void setIpName(const std::string &ipName);
std::string getElasticNetworkInterfaceId() const;
void setElasticNetworkInterfaceId(const std::string &elasticNetworkInterfaceId);
std::string getStatus() const;
void setStatus(const std::string &status);
private:
int pageNumber_;
std::string regionId_;
int pageSize_;
std::string privateIpAddress_;
std::string ipName_;
std::string elasticNetworkInterfaceId_;
std::string status_;
};
} // namespace Model
} // namespace Eflo
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_MODEL_LISTLENIPRIVATEIPADDRESSESREQUEST_H_

72
eflo/include/alibabacloud/eflo/model/ListLeniPrivateIpAddressesResult.h Normal file
View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_EFLO_MODEL_LISTLENIPRIVATEIPADDRESSESRESULT_H_
#define ALIBABACLOUD_EFLO_MODEL_LISTLENIPRIVATEIPADDRESSESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/eflo/EfloExport.h>
namespace AlibabaCloud
{
namespace Eflo
{
namespace Model
{
class ALIBABACLOUD_EFLO_EXPORT ListLeniPrivateIpAddressesResult : public ServiceResult
{
public:
struct Content
{
struct DataItem
{
std::string status;
std::string elasticNetworkInterfaceId;
std::string gmtCreate;
std::string ipName;
std::string privateIpAddress;
std::string description;
std::string message;
std::string gmtModified;
std::string regionId;
};
long total;
std::vector<DataItem> data;
};
ListLeniPrivateIpAddressesResult();
explicit ListLeniPrivateIpAddressesResult(const std::string &payload);
~ListLeniPrivateIpAddressesResult();
std::string getMessage()const;
Content getContent()const;
int getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
Content content_;
int code_;
};
}
}
}
#endif // !ALIBABACLOUD_EFLO_MODEL_LISTLENIPRIVATEIPADDRESSESRESULT_H_

3
eflo/include/alibabacloud/eflo/model/ListVccGrantRulesRequest.h
View File

@@ -34,6 +34,8 @@ public:
void setGrantTenantId(const std::string &grantTenantId);
int getPageNumber() const;
void setPageNumber(int pageNumber);
std::string getResourceGroupId() const;
void setResourceGroupId(const std::string &resourceGroupId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getGrantRuleId() const;
@@ -54,6 +56,7 @@ public:
private:
std::string grantTenantId_;
int pageNumber_;
std::string resourceGroupId_;
std::string regionId_;
std::string grantRuleId_;
int pageSize_;

1
eflo/include/alibabacloud/eflo/model/ListVccGrantRulesResult.h
View File

@@ -39,6 +39,7 @@ namespace AlibabaCloud
std::string instanceName;
std::string tenantId;
std::string grantTenantId;
std::string resourceGroupId;
std::string instanceId;
bool used;
std::string createTime;

1
eflo/include/alibabacloud/eflo/model/ListVccRouteEntriesResult.h
View File

@@ -42,6 +42,7 @@ namespace AlibabaCloud
std::string tenantId;
std::string resourceTenantId;
std::string routeType;
std::string message;
std::string nextHopId;
std::string gmtModified;
std::string vccId;

3
eflo/include/alibabacloud/eflo/model/ListVpdGrantRulesRequest.h
View File

@@ -34,6 +34,8 @@ public:
void setGrantTenantId(const std::string &grantTenantId);
int getPageNumber() const;
void setPageNumber(int pageNumber);
std::string getResourceGroupId() const;
void setResourceGroupId(const std::string &resourceGroupId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getGrantRuleId() const;
@@ -54,6 +56,7 @@ public:
private:
std::string grantTenantId_;
int pageNumber_;
std::string resourceGroupId_;
std::string regionId_;
std::string grantRuleId_;
int pageSize_;

1
eflo/include/alibabacloud/eflo/model/ListVpdGrantRulesResult.h
View File

@@ -39,6 +39,7 @@ namespace AlibabaCloud
std::string instanceName;
std::string tenantId;
std::string grantTenantId;
std::string resourceGroupId;
std::string instanceId;
bool used;
std::string createTime;

51
eflo/include/alibabacloud/eflo/model/UnassignLeniPrivateIpAddressRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_EFLO_MODEL_UNASSIGNLENIPRIVATEIPADDRESSREQUEST_H_
#define ALIBABACLOUD_EFLO_MODEL_UNASSIGNLENIPRIVATEIPADDRESSREQUEST_H_
#include <alibabacloud/eflo/EfloExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Eflo {
namespace Model {
class ALIBABACLOUD_EFLO_EXPORT UnassignLeniPrivateIpAddressRequest : public RpcServiceRequest {
public:
UnassignLeniPrivateIpAddressRequest();
~UnassignLeniPrivateIpAddressRequest();
std::string getClientToken() const;
void setClientToken(const std::string &clientToken);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getIpName() const;
void setIpName(const std::string &ipName);
std::string getElasticNetworkInterfaceId() const;
void setElasticNetworkInterfaceId(const std::string &elasticNetworkInterfaceId);
private:
std::string clientToken_;
std::string regionId_;
std::string ipName_;
std::string elasticNetworkInterfaceId_;
};
} // namespace Model
} // namespace Eflo
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_MODEL_UNASSIGNLENIPRIVATEIPADDRESSREQUEST_H_

60
eflo/include/alibabacloud/eflo/model/UnassignLeniPrivateIpAddressResult.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_EFLO_MODEL_UNASSIGNLENIPRIVATEIPADDRESSRESULT_H_
#define ALIBABACLOUD_EFLO_MODEL_UNASSIGNLENIPRIVATEIPADDRESSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/eflo/EfloExport.h>
namespace AlibabaCloud
{
namespace Eflo
{
namespace Model
{
class ALIBABACLOUD_EFLO_EXPORT UnassignLeniPrivateIpAddressResult : public ServiceResult
{
public:
struct Content
{
std::string ipName;
std::string elasticNetworkInterfaceId;
};
UnassignLeniPrivateIpAddressResult();
explicit UnassignLeniPrivateIpAddressResult(const std::string &payload);
~UnassignLeniPrivateIpAddressResult();
std::string getMessage()const;
Content getContent()const;
int getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
Content content_;
int code_;
};
}
}
}
#endif // !ALIBABACLOUD_EFLO_MODEL_UNASSIGNLENIPRIVATEIPADDRESSRESULT_H_

51
eflo/include/alibabacloud/eflo/model/UpdateLeniPrivateIpAddressRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_EFLO_MODEL_UPDATELENIPRIVATEIPADDRESSREQUEST_H_
#define ALIBABACLOUD_EFLO_MODEL_UPDATELENIPRIVATEIPADDRESSREQUEST_H_
#include <alibabacloud/eflo/EfloExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Eflo {
namespace Model {
class ALIBABACLOUD_EFLO_EXPORT UpdateLeniPrivateIpAddressRequest : public RpcServiceRequest {
public:
UpdateLeniPrivateIpAddressRequest();
~UpdateLeniPrivateIpAddressRequest();
std::string getDescription() const;
void setDescription(const std::string &description);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getIpName() const;
void setIpName(const std::string &ipName);
std::string getElasticNetworkInterfaceId() const;
void setElasticNetworkInterfaceId(const std::string &elasticNetworkInterfaceId);
private:
std::string description_;
std::string regionId_;
std::string ipName_;
std::string elasticNetworkInterfaceId_;
};
} // namespace Model
} // namespace Eflo
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_MODEL_UPDATELENIPRIVATEIPADDRESSREQUEST_H_

60
eflo/include/alibabacloud/eflo/model/UpdateLeniPrivateIpAddressResult.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_EFLO_MODEL_UPDATELENIPRIVATEIPADDRESSRESULT_H_
#define ALIBABACLOUD_EFLO_MODEL_UPDATELENIPRIVATEIPADDRESSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/eflo/EfloExport.h>
namespace AlibabaCloud
{
namespace Eflo
{
namespace Model
{
class ALIBABACLOUD_EFLO_EXPORT UpdateLeniPrivateIpAddressResult : public ServiceResult
{
public:
struct Content
{
std::string elasticNetworkInterfaceId;
std::string ipName;
};
UpdateLeniPrivateIpAddressResult();
explicit UpdateLeniPrivateIpAddressResult(const std::string &payload);
~UpdateLeniPrivateIpAddressResult();
std::string getMessage()const;
Content getContent()const;
int getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
Content content_;
int code_;
};
}
}
}
#endif // !ALIBABACLOUD_EFLO_MODEL_UPDATELENIPRIVATEIPADDRESSRESULT_H_

180
eflo/src/EfloClient.cc
View File

@@ -51,6 +51,42 @@ EfloClient::EfloClient(const std::string & accessKeyId, const std::string & acce
EfloClient::~EfloClient()
{}
EfloClient::AssignLeniPrivateIpAddressOutcome EfloClient::assignLeniPrivateIpAddress(const AssignLeniPrivateIpAddressRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return AssignLeniPrivateIpAddressOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return AssignLeniPrivateIpAddressOutcome(AssignLeniPrivateIpAddressResult(outcome.result()));
else
return AssignLeniPrivateIpAddressOutcome(outcome.error());
}
void EfloClient::assignLeniPrivateIpAddressAsync(const AssignLeniPrivateIpAddressRequest& request, const AssignLeniPrivateIpAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, assignLeniPrivateIpAddress(request), context);
};
asyncExecute(new Runnable(fn));
}
EfloClient::AssignLeniPrivateIpAddressOutcomeCallable EfloClient::assignLeniPrivateIpAddressCallable(const AssignLeniPrivateIpAddressRequest &request) const
{
auto task = std::make_shared<std::packaged_task<AssignLeniPrivateIpAddressOutcome()>>(
[this, request]()
{
return this->assignLeniPrivateIpAddress(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EfloClient::AssignPrivateIpAddressOutcome EfloClient::assignPrivateIpAddress(const AssignPrivateIpAddressRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1059,6 +1095,42 @@ EfloClient::GetFabricTopologyOutcomeCallable EfloClient::getFabricTopologyCallab
return task->get_future();
}
EfloClient::GetLeniPrivateIpAddressOutcome EfloClient::getLeniPrivateIpAddress(const GetLeniPrivateIpAddressRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetLeniPrivateIpAddressOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetLeniPrivateIpAddressOutcome(GetLeniPrivateIpAddressResult(outcome.result()));
else
return GetLeniPrivateIpAddressOutcome(outcome.error());
}
void EfloClient::getLeniPrivateIpAddressAsync(const GetLeniPrivateIpAddressRequest& request, const GetLeniPrivateIpAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getLeniPrivateIpAddress(request), context);
};
asyncExecute(new Runnable(fn));
}
EfloClient::GetLeniPrivateIpAddressOutcomeCallable EfloClient::getLeniPrivateIpAddressCallable(const GetLeniPrivateIpAddressRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetLeniPrivateIpAddressOutcome()>>(
[this, request]()
{
return this->getLeniPrivateIpAddress(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EfloClient::GetLniPrivateIpAddressOutcome EfloClient::getLniPrivateIpAddress(const GetLniPrivateIpAddressRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1671,6 +1743,42 @@ EfloClient::ListInstancesByNcdOutcomeCallable EfloClient::listInstancesByNcdCall
return task->get_future();
}
EfloClient::ListLeniPrivateIpAddressesOutcome EfloClient::listLeniPrivateIpAddresses(const ListLeniPrivateIpAddressesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListLeniPrivateIpAddressesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListLeniPrivateIpAddressesOutcome(ListLeniPrivateIpAddressesResult(outcome.result()));
else
return ListLeniPrivateIpAddressesOutcome(outcome.error());
}
void EfloClient::listLeniPrivateIpAddressesAsync(const ListLeniPrivateIpAddressesRequest& request, const ListLeniPrivateIpAddressesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listLeniPrivateIpAddresses(request), context);
};
asyncExecute(new Runnable(fn));
}
EfloClient::ListLeniPrivateIpAddressesOutcomeCallable EfloClient::listLeniPrivateIpAddressesCallable(const ListLeniPrivateIpAddressesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListLeniPrivateIpAddressesOutcome()>>(
[this, request]()
{
return this->listLeniPrivateIpAddresses(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EfloClient::ListLniPrivateIpAddressOutcome EfloClient::listLniPrivateIpAddress(const ListLniPrivateIpAddressRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2139,6 +2247,42 @@ EfloClient::UnAssociateVpdCidrBlockOutcomeCallable EfloClient::unAssociateVpdCid
return task->get_future();
}
EfloClient::UnassignLeniPrivateIpAddressOutcome EfloClient::unassignLeniPrivateIpAddress(const UnassignLeniPrivateIpAddressRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UnassignLeniPrivateIpAddressOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UnassignLeniPrivateIpAddressOutcome(UnassignLeniPrivateIpAddressResult(outcome.result()));
else
return UnassignLeniPrivateIpAddressOutcome(outcome.error());
}
void EfloClient::unassignLeniPrivateIpAddressAsync(const UnassignLeniPrivateIpAddressRequest& request, const UnassignLeniPrivateIpAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, unassignLeniPrivateIpAddress(request), context);
};
asyncExecute(new Runnable(fn));
}
EfloClient::UnassignLeniPrivateIpAddressOutcomeCallable EfloClient::unassignLeniPrivateIpAddressCallable(const UnassignLeniPrivateIpAddressRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UnassignLeniPrivateIpAddressOutcome()>>(
[this, request]()
{
return this->unassignLeniPrivateIpAddress(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EfloClient::UpdateElasticNetworkInterfaceOutcome EfloClient::updateElasticNetworkInterface(const UpdateElasticNetworkInterfaceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2283,6 +2427,42 @@ EfloClient::UpdateErRouteMapOutcomeCallable EfloClient::updateErRouteMapCallable
return task->get_future();
}
EfloClient::UpdateLeniPrivateIpAddressOutcome EfloClient::updateLeniPrivateIpAddress(const UpdateLeniPrivateIpAddressRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpdateLeniPrivateIpAddressOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpdateLeniPrivateIpAddressOutcome(UpdateLeniPrivateIpAddressResult(outcome.result()));
else
return UpdateLeniPrivateIpAddressOutcome(outcome.error());
}
void EfloClient::updateLeniPrivateIpAddressAsync(const UpdateLeniPrivateIpAddressRequest& request, const UpdateLeniPrivateIpAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, updateLeniPrivateIpAddress(request), context);
};
asyncExecute(new Runnable(fn));
}
EfloClient::UpdateLeniPrivateIpAddressOutcomeCallable EfloClient::updateLeniPrivateIpAddressCallable(const UpdateLeniPrivateIpAddressRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpdateLeniPrivateIpAddressOutcome()>>(
[this, request]()
{
return this->updateLeniPrivateIpAddress(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EfloClient::UpdateSubnetOutcome EfloClient::updateSubnet(const UpdateSubnetRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

72
eflo/src/model/AssignLeniPrivateIpAddressRequest.cc Normal file
View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/eflo/model/AssignLeniPrivateIpAddressRequest.h>
using AlibabaCloud::Eflo::Model::AssignLeniPrivateIpAddressRequest;
AssignLeniPrivateIpAddressRequest::AssignLeniPrivateIpAddressRequest()
: RpcServiceRequest("eflo", "2022-05-30", "AssignLeniPrivateIpAddress") {
setMethod(HttpRequest::Method::Post);
}
AssignLeniPrivateIpAddressRequest::~AssignLeniPrivateIpAddressRequest() {}
std::string AssignLeniPrivateIpAddressRequest::getClientToken() const {
return clientToken_;
}
void AssignLeniPrivateIpAddressRequest::setClientToken(const std::string &clientToken) {
clientToken_ = clientToken;
setBodyParameter(std::string("ClientToken"), clientToken);
}
std::string AssignLeniPrivateIpAddressRequest::getDescription() const {
return description_;
}
void AssignLeniPrivateIpAddressRequest::setDescription(const std::string &description) {
description_ = description;
setBodyParameter(std::string("Description"), description);
}
std::string AssignLeniPrivateIpAddressRequest::getPrivateIpAddress() const {
return privateIpAddress_;
}
void AssignLeniPrivateIpAddressRequest::setPrivateIpAddress(const std::string &privateIpAddress) {
privateIpAddress_ = privateIpAddress;
setBodyParameter(std::string("PrivateIpAddress"), privateIpAddress);
}
std::string AssignLeniPrivateIpAddressRequest::getRegionId() const {
return regionId_;
}
void AssignLeniPrivateIpAddressRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setBodyParameter(std::string("RegionId"), regionId);
}
std::string AssignLeniPrivateIpAddressRequest::getElasticNetworkInterfaceId() const {
return elasticNetworkInterfaceId_;
}
void AssignLeniPrivateIpAddressRequest::setElasticNetworkInterfaceId(const std::string &elasticNetworkInterfaceId) {
elasticNetworkInterfaceId_ = elasticNetworkInterfaceId;
setBodyParameter(std::string("ElasticNetworkInterfaceId"), elasticNetworkInterfaceId);
}

68
eflo/src/model/AssignLeniPrivateIpAddressResult.cc Normal file
View File

@@ -0,0 +1,68 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/eflo/model/AssignLeniPrivateIpAddressResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Eflo;
using namespace AlibabaCloud::Eflo::Model;
AssignLeniPrivateIpAddressResult::AssignLeniPrivateIpAddressResult() :
ServiceResult()
{}
AssignLeniPrivateIpAddressResult::AssignLeniPrivateIpAddressResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
AssignLeniPrivateIpAddressResult::~AssignLeniPrivateIpAddressResult()
{}
void AssignLeniPrivateIpAddressResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto contentNode = value["Content"];
if(!contentNode["IpName"].isNull())
content_.ipName = contentNode["IpName"].asString();
if(!contentNode["ElasticNetworkInterfaceId"].isNull())
content_.elasticNetworkInterfaceId = contentNode["ElasticNetworkInterfaceId"].asString();
if(!value["Code"].isNull())
code_ = std::stoi(value["Code"].asString());
if(!value["Message"].isNull())
message_ = value["Message"].asString();
}
std::string AssignLeniPrivateIpAddressResult::getMessage()const
{
return message_;
}
AssignLeniPrivateIpAddressResult::Content AssignLeniPrivateIpAddressResult::getContent()const
{
return content_;
}
int AssignLeniPrivateIpAddressResult::getCode()const
{
return code_;
}

18
eflo/src/model/DeleteVpdGrantRuleRequest.cc
View File

@@ -52,15 +52,6 @@ void DeleteVpdGrantRuleRequest::setInstanceId(const std::string &instanceId) {
setBodyParameter(std::string("InstanceId"), instanceId);
}
std::string DeleteVpdGrantRuleRequest::getGrantRuleId() const {
return grantRuleId_;
}
void DeleteVpdGrantRuleRequest::setGrantRuleId(const std::string &grantRuleId) {
grantRuleId_ = grantRuleId;
setBodyParameter(std::string("GrantRuleId"), grantRuleId);
}
std::string DeleteVpdGrantRuleRequest::getRegionId() const {
return regionId_;
}
@@ -70,3 +61,12 @@ void DeleteVpdGrantRuleRequest::setRegionId(const std::string &regionId) {
setBodyParameter(std::string("RegionId"), regionId);
}
std::string DeleteVpdGrantRuleRequest::getGrantRuleId() const {
return grantRuleId_;
}
void DeleteVpdGrantRuleRequest::setGrantRuleId(const std::string &grantRuleId) {
grantRuleId_ = grantRuleId;
setBodyParameter(std::string("GrantRuleId"), grantRuleId);
}

2
eflo/src/model/GetElasticNetworkInterfaceResult.cc
View File

@@ -72,6 +72,8 @@ void GetElasticNetworkInterfaceResult::parse(const std::string &payload)
content_.gmtModified = contentNode["GmtModified"].asString();
if(!contentNode["Description"].isNull())
content_.description = contentNode["Description"].asString();
if(!contentNode["SecurityGroupId"].isNull())
content_.securityGroupId = contentNode["SecurityGroupId"].asString();
auto allPrivateIpAddressesNode = contentNode["PrivateIpAddresses"]["PrivateIpAddress"];
for (auto contentNodePrivateIpAddressesPrivateIpAddress : allPrivateIpAddressesNode)
{

54
eflo/src/model/GetLeniPrivateIpAddressRequest.cc Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/eflo/model/GetLeniPrivateIpAddressRequest.h>
using AlibabaCloud::Eflo::Model::GetLeniPrivateIpAddressRequest;
GetLeniPrivateIpAddressRequest::GetLeniPrivateIpAddressRequest()
: RpcServiceRequest("eflo", "2022-05-30", "GetLeniPrivateIpAddress") {
setMethod(HttpRequest::Method::Post);
}
GetLeniPrivateIpAddressRequest::~GetLeniPrivateIpAddressRequest() {}
std::string GetLeniPrivateIpAddressRequest::getRegionId() const {
return regionId_;
}
void GetLeniPrivateIpAddressRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setBodyParameter(std::string("RegionId"), regionId);
}
std::string GetLeniPrivateIpAddressRequest::getIpName() const {
return ipName_;
}
void GetLeniPrivateIpAddressRequest::setIpName(const std::string &ipName) {
ipName_ = ipName;
setBodyParameter(std::string("IpName"), ipName);
}
std::string GetLeniPrivateIpAddressRequest::getElasticNetworkInterfaceId() const {
return elasticNetworkInterfaceId_;
}
void GetLeniPrivateIpAddressRequest::setElasticNetworkInterfaceId(const std::string &elasticNetworkInterfaceId) {
elasticNetworkInterfaceId_ = elasticNetworkInterfaceId;
setBodyParameter(std::string("ElasticNetworkInterfaceId"), elasticNetworkInterfaceId);
}

82
eflo/src/model/GetLeniPrivateIpAddressResult.cc Normal file
View File

@@ -0,0 +1,82 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/eflo/model/GetLeniPrivateIpAddressResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Eflo;
using namespace AlibabaCloud::Eflo::Model;
GetLeniPrivateIpAddressResult::GetLeniPrivateIpAddressResult() :
ServiceResult()
{}
GetLeniPrivateIpAddressResult::GetLeniPrivateIpAddressResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetLeniPrivateIpAddressResult::~GetLeniPrivateIpAddressResult()
{}
void GetLeniPrivateIpAddressResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto contentNode = value["Content"];
if(!contentNode["ElasticNetworkInterfaceId"].isNull())
content_.elasticNetworkInterfaceId = contentNode["ElasticNetworkInterfaceId"].asString();
if(!contentNode["RegionId"].isNull())
content_.regionId = contentNode["RegionId"].asString();
if(!contentNode["GmtCreate"].isNull())
content_.gmtCreate = contentNode["GmtCreate"].asString();
if(!contentNode["GmtModified"].isNull())
content_.gmtModified = contentNode["GmtModified"].asString();
if(!contentNode["IpName"].isNull())
content_.ipName = contentNode["IpName"].asString();
if(!contentNode["PrivateIpAddress"].isNull())
content_.privateIpAddress = contentNode["PrivateIpAddress"].asString();
if(!contentNode["Status"].isNull())
content_.status = contentNode["Status"].asString();
if(!contentNode["Description"].isNull())
content_.description = contentNode["Description"].asString();
if(!contentNode["Message"].isNull())
content_.message = contentNode["Message"].asString();
if(!value["Code"].isNull())
code_ = std::stoi(value["Code"].asString());
if(!value["Message"].isNull())
message_ = value["Message"].asString();
}
std::string GetLeniPrivateIpAddressResult::getMessage()const
{
return message_;
}
GetLeniPrivateIpAddressResult::Content GetLeniPrivateIpAddressResult::getContent()const
{
return content_;
}
int GetLeniPrivateIpAddressResult::getCode()const
{
return code_;
}

2
eflo/src/model/GetNodeInfoForPodResult.cc
View File

@@ -54,6 +54,8 @@ void GetNodeInfoForPodResult::parse(const std::string &payload)
content_.leniQuota = std::stoi(contentNode["LeniQuota"].asString());
if(!contentNode["LniSipQuota"].isNull())
content_.lniSipQuota = std::stoi(contentNode["LniSipQuota"].asString());
if(!contentNode["HdeniQuota"].isNull())
content_.hdeniQuota = std::stoi(contentNode["HdeniQuota"].asString());
auto allVSwitches = contentNode["VSwitches"]["VSwitche"];
for (auto value : allVSwitches)
content_.vSwitches.push_back(value.asString());

2
eflo/src/model/GetVccGrantRuleResult.cc
View File

@@ -60,6 +60,8 @@ void GetVccGrantRuleResult::parse(const std::string &payload)
content_.createTime = contentNode["CreateTime"].asString();
if(!contentNode["GrantRuleId"].isNull())
content_.grantRuleId = contentNode["GrantRuleId"].asString();
if(!contentNode["ResourceGroupId"].isNull())
content_.resourceGroupId = contentNode["ResourceGroupId"].asString();
if(!value["Code"].isNull())
code_ = std::stoi(value["Code"].asString());
if(!value["Message"].isNull())

9
eflo/src/model/GetVccRequest.cc
View File

@@ -25,6 +25,15 @@ GetVccRequest::GetVccRequest()
GetVccRequest::~GetVccRequest() {}
std::string GetVccRequest::getClientToken() const {
return clientToken_;
}
void GetVccRequest::setClientToken(const std::string &clientToken) {
clientToken_ = clientToken;
setBodyParameter(std::string("ClientToken"), clientToken);
}
int GetVccRequest::getPageNumber() const {
return pageNumber_;
}

32
eflo/src/model/GetVccResult.cc
View File

@@ -184,6 +184,38 @@ void GetVccResult::parse(const std::string &payload)
tagObject.tagValue = contentNodeTagsTag["TagValue"].asString();
content_.tags.push_back(tagObject);
}
auto allVbrInfosNode = contentNode["VbrInfos"]["VbrInfo"];
for (auto contentNodeVbrInfosVbrInfo : allVbrInfosNode)
{
Content::VbrInfo vbrInfoObject;
if(!contentNodeVbrInfosVbrInfo["VbrId"].isNull())
vbrInfoObject.vbrId = contentNodeVbrInfosVbrInfo["VbrId"].asString();
if(!contentNodeVbrInfosVbrInfo["CenId"].isNull())
vbrInfoObject.cenId = contentNodeVbrInfosVbrInfo["CenId"].asString();
if(!contentNodeVbrInfosVbrInfo["Status"].isNull())
vbrInfoObject.status = contentNodeVbrInfosVbrInfo["Status"].asString();
if(!contentNodeVbrInfosVbrInfo["GmtCreate"].isNull())
vbrInfoObject.gmtCreate = contentNodeVbrInfosVbrInfo["GmtCreate"].asString();
if(!contentNodeVbrInfosVbrInfo["GmtModified"].isNull())
vbrInfoObject.gmtModified = contentNodeVbrInfosVbrInfo["GmtModified"].asString();
auto allVbrBgpPeersNode = contentNodeVbrInfosVbrInfo["VbrBgpPeers"]["VbrBgpPeer"];
for (auto contentNodeVbrInfosVbrInfoVbrBgpPeersVbrBgpPeer : allVbrBgpPeersNode)
{
Content::VbrInfo::VbrBgpPeer vbrBgpPeersObject;
if(!contentNodeVbrInfosVbrInfoVbrBgpPeersVbrBgpPeer["BgpGroupId"].isNull())
vbrBgpPeersObject.bgpGroupId = contentNodeVbrInfosVbrInfoVbrBgpPeersVbrBgpPeer["BgpGroupId"].asString();
if(!contentNodeVbrInfosVbrInfoVbrBgpPeersVbrBgpPeer["BgpPeerId"].isNull())
vbrBgpPeersObject.bgpPeerId = contentNodeVbrInfosVbrInfoVbrBgpPeersVbrBgpPeer["BgpPeerId"].asString();
if(!contentNodeVbrInfosVbrInfoVbrBgpPeersVbrBgpPeer["PeerIpAddress"].isNull())
vbrBgpPeersObject.peerIpAddress = contentNodeVbrInfosVbrInfoVbrBgpPeersVbrBgpPeer["PeerIpAddress"].asString();
if(!contentNodeVbrInfosVbrInfoVbrBgpPeersVbrBgpPeer["PeerAsn"].isNull())
vbrBgpPeersObject.peerAsn = contentNodeVbrInfosVbrInfoVbrBgpPeersVbrBgpPeer["PeerAsn"].asString();
if(!contentNodeVbrInfosVbrInfoVbrBgpPeersVbrBgpPeer["Status"].isNull())
vbrBgpPeersObject.status = contentNodeVbrInfosVbrInfoVbrBgpPeersVbrBgpPeer["Status"].asString();
vbrInfoObject.vbrBgpPeers.push_back(vbrBgpPeersObject);
}
content_.vbrInfos.push_back(vbrInfoObject);
}
auto vpdBaseInfoNode = contentNode["VpdBaseInfo"];
if(!vpdBaseInfoNode["VpdId"].isNull())
content_.vpdBaseInfo.vpdId = vpdBaseInfoNode["VpdId"].asString();

2
eflo/src/model/GetVccRouteEntryResult.cc
View File

@@ -60,6 +60,8 @@ void GetVccRouteEntryResult::parse(const std::string &payload)
content_.status = contentNode["Status"].asString();
if(!contentNode["GmtModified"].isNull())
content_.gmtModified = contentNode["GmtModified"].asString();
if(!contentNode["Message"].isNull())
content_.message = contentNode["Message"].asString();
if(!value["Code"].isNull())
code_ = std::stoi(value["Code"].asString());
if(!value["Message"].isNull())

2
eflo/src/model/GetVpdGrantRuleResult.cc
View File

@@ -60,6 +60,8 @@ void GetVpdGrantRuleResult::parse(const std::string &payload)
content_.createTime = contentNode["CreateTime"].asString();
if(!contentNode["GrantRuleId"].isNull())
content_.grantRuleId = contentNode["GrantRuleId"].asString();
if(!contentNode["ResourceGroupId"].isNull())
content_.resourceGroupId = contentNode["ResourceGroupId"].asString();
if(!value["Code"].isNull())
code_ = std::stoi(value["Code"].asString());
if(!value["Message"].isNull())

2
eflo/src/model/ListElasticNetworkInterfacesResult.cc
View File

@@ -78,6 +78,8 @@ void ListElasticNetworkInterfacesResult::parse(const std::string &payload)
dataItemObject.gmtModified = contentNodeDataDataItem["GmtModified"].asString();
if(!contentNodeDataDataItem["Description"].isNull())
dataItemObject.description = contentNodeDataDataItem["Description"].asString();
if(!contentNodeDataDataItem["SecurityGroupId"].isNull())
dataItemObject.securityGroupId = contentNodeDataDataItem["SecurityGroupId"].asString();
content_.data.push_back(dataItemObject);
}
if(!value["Code"].isNull())

90
eflo/src/model/ListLeniPrivateIpAddressesRequest.cc Normal file
View File

@@ -0,0 +1,90 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/eflo/model/ListLeniPrivateIpAddressesRequest.h>
using AlibabaCloud::Eflo::Model::ListLeniPrivateIpAddressesRequest;
ListLeniPrivateIpAddressesRequest::ListLeniPrivateIpAddressesRequest()
: RpcServiceRequest("eflo", "2022-05-30", "ListLeniPrivateIpAddresses") {
setMethod(HttpRequest::Method::Post);
}
ListLeniPrivateIpAddressesRequest::~ListLeniPrivateIpAddressesRequest() {}
int ListLeniPrivateIpAddressesRequest::getPageNumber() const {
return pageNumber_;
}
void ListLeniPrivateIpAddressesRequest::setPageNumber(int pageNumber) {
pageNumber_ = pageNumber;
setBodyParameter(std::string("PageNumber"), std::to_string(pageNumber));
}
std::string ListLeniPrivateIpAddressesRequest::getRegionId() const {
return regionId_;
}
void ListLeniPrivateIpAddressesRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setBodyParameter(std::string("RegionId"), regionId);
}
int ListLeniPrivateIpAddressesRequest::getPageSize() const {
return pageSize_;
}
void ListLeniPrivateIpAddressesRequest::setPageSize(int pageSize) {
pageSize_ = pageSize;
setBodyParameter(std::string("PageSize"), std::to_string(pageSize));
}
std::string ListLeniPrivateIpAddressesRequest::getPrivateIpAddress() const {
return privateIpAddress_;
}
void ListLeniPrivateIpAddressesRequest::setPrivateIpAddress(const std::string &privateIpAddress) {
privateIpAddress_ = privateIpAddress;
setBodyParameter(std::string("PrivateIpAddress"), privateIpAddress);
}
std::string ListLeniPrivateIpAddressesRequest::getIpName() const {
return ipName_;
}
void ListLeniPrivateIpAddressesRequest::setIpName(const std::string &ipName) {
ipName_ = ipName;
setBodyParameter(std::string("IpName"), ipName);
}
std::string ListLeniPrivateIpAddressesRequest::getElasticNetworkInterfaceId() const {
return elasticNetworkInterfaceId_;
}
void ListLeniPrivateIpAddressesRequest::setElasticNetworkInterfaceId(const std::string &elasticNetworkInterfaceId) {
elasticNetworkInterfaceId_ = elasticNetworkInterfaceId;
setBodyParameter(std::string("ElasticNetworkInterfaceId"), elasticNetworkInterfaceId);
}
std::string ListLeniPrivateIpAddressesRequest::getStatus() const {
return status_;
}
void ListLeniPrivateIpAddressesRequest::setStatus(const std::string &status) {
status_ = status;
setBodyParameter(std::string("Status"), status);
}

90
eflo/src/model/ListLeniPrivateIpAddressesResult.cc Normal file
View File

@@ -0,0 +1,90 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/eflo/model/ListLeniPrivateIpAddressesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Eflo;
using namespace AlibabaCloud::Eflo::Model;
ListLeniPrivateIpAddressesResult::ListLeniPrivateIpAddressesResult() :
ServiceResult()
{}
ListLeniPrivateIpAddressesResult::ListLeniPrivateIpAddressesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListLeniPrivateIpAddressesResult::~ListLeniPrivateIpAddressesResult()
{}
void ListLeniPrivateIpAddressesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto contentNode = value["Content"];
if(!contentNode["Total"].isNull())
content_.total = std::stol(contentNode["Total"].asString());
auto allDataNode = contentNode["Data"]["DataItem"];
for (auto contentNodeDataDataItem : allDataNode)
{
Content::DataItem dataItemObject;
if(!contentNodeDataDataItem["ElasticNetworkInterfaceId"].isNull())
dataItemObject.elasticNetworkInterfaceId = contentNodeDataDataItem["ElasticNetworkInterfaceId"].asString();
if(!contentNodeDataDataItem["RegionId"].isNull())
dataItemObject.regionId = contentNodeDataDataItem["RegionId"].asString();
if(!contentNodeDataDataItem["GmtCreate"].isNull())
dataItemObject.gmtCreate = contentNodeDataDataItem["GmtCreate"].asString();
if(!contentNodeDataDataItem["GmtModified"].isNull())
dataItemObject.gmtModified = contentNodeDataDataItem["GmtModified"].asString();
if(!contentNodeDataDataItem["IpName"].isNull())
dataItemObject.ipName = contentNodeDataDataItem["IpName"].asString();
if(!contentNodeDataDataItem["PrivateIpAddress"].isNull())
dataItemObject.privateIpAddress = contentNodeDataDataItem["PrivateIpAddress"].asString();
if(!contentNodeDataDataItem["Status"].isNull())
dataItemObject.status = contentNodeDataDataItem["Status"].asString();
if(!contentNodeDataDataItem["Description"].isNull())
dataItemObject.description = contentNodeDataDataItem["Description"].asString();
if(!contentNodeDataDataItem["Message"].isNull())
dataItemObject.message = contentNodeDataDataItem["Message"].asString();
content_.data.push_back(dataItemObject);
}
if(!value["Code"].isNull())
code_ = std::stoi(value["Code"].asString());
if(!value["Message"].isNull())
message_ = value["Message"].asString();
}
std::string ListLeniPrivateIpAddressesResult::getMessage()const
{
return message_;
}
ListLeniPrivateIpAddressesResult::Content ListLeniPrivateIpAddressesResult::getContent()const
{
return content_;
}
int ListLeniPrivateIpAddressesResult::getCode()const
{
return code_;
}

9
eflo/src/model/ListVccGrantRulesRequest.cc
View File

@@ -43,6 +43,15 @@ void ListVccGrantRulesRequest::setPageNumber(int pageNumber) {
setBodyParameter(std::string("PageNumber"), std::to_string(pageNumber));
}
std::string ListVccGrantRulesRequest::getResourceGroupId() const {
return resourceGroupId_;
}
void ListVccGrantRulesRequest::setResourceGroupId(const std::string &resourceGroupId) {
resourceGroupId_ = resourceGroupId;
setBodyParameter(std::string("ResourceGroupId"), resourceGroupId);
}
std::string ListVccGrantRulesRequest::getRegionId() const {
return regionId_;
}

2
eflo/src/model/ListVccGrantRulesResult.cc
View File

@@ -66,6 +66,8 @@ void ListVccGrantRulesResult::parse(const std::string &payload)
dataItemObject.createTime = contentNodeDataDataItem["CreateTime"].asString();
if(!contentNodeDataDataItem["GrantRuleId"].isNull())
dataItemObject.grantRuleId = contentNodeDataDataItem["GrantRuleId"].asString();
if(!contentNodeDataDataItem["ResourceGroupId"].isNull())
dataItemObject.resourceGroupId = contentNodeDataDataItem["ResourceGroupId"].asString();
content_.data.push_back(dataItemObject);
}
if(!value["Code"].isNull())

2
eflo/src/model/ListVccRouteEntriesResult.cc
View File

@@ -68,6 +68,8 @@ void ListVccRouteEntriesResult::parse(const std::string &payload)
dataItemObject.status = contentNodeDataDataItem["Status"].asString();
if(!contentNodeDataDataItem["GmtModified"].isNull())
dataItemObject.gmtModified = contentNodeDataDataItem["GmtModified"].asString();
if(!contentNodeDataDataItem["Message"].isNull())
dataItemObject.message = contentNodeDataDataItem["Message"].asString();
content_.data.push_back(dataItemObject);
}
if(!value["Code"].isNull())

9
eflo/src/model/ListVpdGrantRulesRequest.cc
View File

@@ -43,6 +43,15 @@ void ListVpdGrantRulesRequest::setPageNumber(int pageNumber) {
setBodyParameter(std::string("PageNumber"), std::to_string(pageNumber));
}
std::string ListVpdGrantRulesRequest::getResourceGroupId() const {
return resourceGroupId_;
}
void ListVpdGrantRulesRequest::setResourceGroupId(const std::string &resourceGroupId) {
resourceGroupId_ = resourceGroupId;
setBodyParameter(std::string("ResourceGroupId"), resourceGroupId);
}
std::string ListVpdGrantRulesRequest::getRegionId() const {
return regionId_;
}

2
eflo/src/model/ListVpdGrantRulesResult.cc
View File

@@ -66,6 +66,8 @@ void ListVpdGrantRulesResult::parse(const std::string &payload)
dataItemObject.createTime = contentNodeDataDataItem["CreateTime"].asString();
if(!contentNodeDataDataItem["GrantRuleId"].isNull())
dataItemObject.grantRuleId = contentNodeDataDataItem["GrantRuleId"].asString();
if(!contentNodeDataDataItem["ResourceGroupId"].isNull())
dataItemObject.resourceGroupId = contentNodeDataDataItem["ResourceGroupId"].asString();
content_.data.push_back(dataItemObject);
}
if(!value["Code"].isNull())

63
eflo/src/model/UnassignLeniPrivateIpAddressRequest.cc Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/eflo/model/UnassignLeniPrivateIpAddressRequest.h>
using AlibabaCloud::Eflo::Model::UnassignLeniPrivateIpAddressRequest;
UnassignLeniPrivateIpAddressRequest::UnassignLeniPrivateIpAddressRequest()
: RpcServiceRequest("eflo", "2022-05-30", "UnassignLeniPrivateIpAddress") {
setMethod(HttpRequest::Method::Post);
}
UnassignLeniPrivateIpAddressRequest::~UnassignLeniPrivateIpAddressRequest() {}
std::string UnassignLeniPrivateIpAddressRequest::getClientToken() const {
return clientToken_;
}
void UnassignLeniPrivateIpAddressRequest::setClientToken(const std::string &clientToken) {
clientToken_ = clientToken;
setBodyParameter(std::string("ClientToken"), clientToken);
}
std::string UnassignLeniPrivateIpAddressRequest::getRegionId() const {
return regionId_;
}
void UnassignLeniPrivateIpAddressRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setBodyParameter(std::string("RegionId"), regionId);
}
std::string UnassignLeniPrivateIpAddressRequest::getIpName() const {
return ipName_;
}
void UnassignLeniPrivateIpAddressRequest::setIpName(const std::string &ipName) {
ipName_ = ipName;
setBodyParameter(std::string("IpName"), ipName);
}
std::string UnassignLeniPrivateIpAddressRequest::getElasticNetworkInterfaceId() const {
return elasticNetworkInterfaceId_;
}
void UnassignLeniPrivateIpAddressRequest::setElasticNetworkInterfaceId(const std::string &elasticNetworkInterfaceId) {
elasticNetworkInterfaceId_ = elasticNetworkInterfaceId;
setBodyParameter(std::string("ElasticNetworkInterfaceId"), elasticNetworkInterfaceId);
}

68
eflo/src/model/UnassignLeniPrivateIpAddressResult.cc Normal file
View File

@@ -0,0 +1,68 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/eflo/model/UnassignLeniPrivateIpAddressResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Eflo;
using namespace AlibabaCloud::Eflo::Model;
UnassignLeniPrivateIpAddressResult::UnassignLeniPrivateIpAddressResult() :
ServiceResult()
{}
UnassignLeniPrivateIpAddressResult::UnassignLeniPrivateIpAddressResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
UnassignLeniPrivateIpAddressResult::~UnassignLeniPrivateIpAddressResult()
{}
void UnassignLeniPrivateIpAddressResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto contentNode = value["Content"];
if(!contentNode["IpName"].isNull())
content_.ipName = contentNode["IpName"].asString();
if(!contentNode["ElasticNetworkInterfaceId"].isNull())
content_.elasticNetworkInterfaceId = contentNode["ElasticNetworkInterfaceId"].asString();
if(!value["Code"].isNull())
code_ = std::stoi(value["Code"].asString());
if(!value["Message"].isNull())
message_ = value["Message"].asString();
}
std::string UnassignLeniPrivateIpAddressResult::getMessage()const
{
return message_;
}
UnassignLeniPrivateIpAddressResult::Content UnassignLeniPrivateIpAddressResult::getContent()const
{
return content_;
}
int UnassignLeniPrivateIpAddressResult::getCode()const
{
return code_;
}

63
eflo/src/model/UpdateLeniPrivateIpAddressRequest.cc Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/eflo/model/UpdateLeniPrivateIpAddressRequest.h>
using AlibabaCloud::Eflo::Model::UpdateLeniPrivateIpAddressRequest;
UpdateLeniPrivateIpAddressRequest::UpdateLeniPrivateIpAddressRequest()
: RpcServiceRequest("eflo", "2022-05-30", "UpdateLeniPrivateIpAddress") {
setMethod(HttpRequest::Method::Post);
}
UpdateLeniPrivateIpAddressRequest::~UpdateLeniPrivateIpAddressRequest() {}
std::string UpdateLeniPrivateIpAddressRequest::getDescription() const {
return description_;
}
void UpdateLeniPrivateIpAddressRequest::setDescription(const std::string &description) {
description_ = description;
setBodyParameter(std::string("Description"), description);
}
std::string UpdateLeniPrivateIpAddressRequest::getRegionId() const {
return regionId_;
}
void UpdateLeniPrivateIpAddressRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setBodyParameter(std::string("RegionId"), regionId);
}
std::string UpdateLeniPrivateIpAddressRequest::getIpName() const {
return ipName_;
}
void UpdateLeniPrivateIpAddressRequest::setIpName(const std::string &ipName) {
ipName_ = ipName;
setBodyParameter(std::string("IpName"), ipName);
}
std::string UpdateLeniPrivateIpAddressRequest::getElasticNetworkInterfaceId() const {
return elasticNetworkInterfaceId_;
}
void UpdateLeniPrivateIpAddressRequest::setElasticNetworkInterfaceId(const std::string &elasticNetworkInterfaceId) {
elasticNetworkInterfaceId_ = elasticNetworkInterfaceId;
setBodyParameter(std::string("ElasticNetworkInterfaceId"), elasticNetworkInterfaceId);
}

68
eflo/src/model/UpdateLeniPrivateIpAddressResult.cc Normal file
View File

@@ -0,0 +1,68 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/eflo/model/UpdateLeniPrivateIpAddressResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Eflo;
using namespace AlibabaCloud::Eflo::Model;
UpdateLeniPrivateIpAddressResult::UpdateLeniPrivateIpAddressResult() :
ServiceResult()
{}
UpdateLeniPrivateIpAddressResult::UpdateLeniPrivateIpAddressResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
UpdateLeniPrivateIpAddressResult::~UpdateLeniPrivateIpAddressResult()
{}
void UpdateLeniPrivateIpAddressResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto contentNode = value["Content"];
if(!contentNode["ElasticNetworkInterfaceId"].isNull())
content_.elasticNetworkInterfaceId = contentNode["ElasticNetworkInterfaceId"].asString();
if(!contentNode["IpName"].isNull())
content_.ipName = contentNode["IpName"].asString();
if(!value["Code"].isNull())
code_ = std::stoi(value["Code"].asString());
if(!value["Message"].isNull())
message_ = value["Message"].asString();
}
std::string UpdateLeniPrivateIpAddressResult::getMessage()const
{
return message_;
}
UpdateLeniPrivateIpAddressResult::Content UpdateLeniPrivateIpAddressResult::getContent()const
{
return content_;
}
int UpdateLeniPrivateIpAddressResult::getCode()const
{
return code_;
}