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

First publish.

Browse Source
This commit is contained in:
sdk-team
2023-01-03 02:17:19 +00:00
parent a382e3172c
commit dabca8e080
65 changed files with 5127 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
VERSION
View File

@@ -1 +1 @@
1.36.1406
1.36.1407

142
eflo/CMakeLists.txt Normal file
View File

@@ -0,0 +1,142 @@
#
# 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.
#
set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include)
set(eflo_public_header
include/alibabacloud/eflo/EfloClient.h
include/alibabacloud/eflo/EfloExport.h )
set(eflo_public_header_model
include/alibabacloud/eflo/model/CreateSubnetRequest.h
include/alibabacloud/eflo/model/CreateSubnetResult.h
include/alibabacloud/eflo/model/CreateVccRequest.h
include/alibabacloud/eflo/model/CreateVccResult.h
include/alibabacloud/eflo/model/CreateVpdRequest.h
include/alibabacloud/eflo/model/CreateVpdResult.h
include/alibabacloud/eflo/model/DeleteSubnetRequest.h
include/alibabacloud/eflo/model/DeleteSubnetResult.h
include/alibabacloud/eflo/model/DeleteVpdRequest.h
include/alibabacloud/eflo/model/DeleteVpdResult.h
include/alibabacloud/eflo/model/GetSubnetRequest.h
include/alibabacloud/eflo/model/GetSubnetResult.h
include/alibabacloud/eflo/model/GetVccRequest.h
include/alibabacloud/eflo/model/GetVccResult.h
include/alibabacloud/eflo/model/GetVpdRequest.h
include/alibabacloud/eflo/model/GetVpdResult.h
include/alibabacloud/eflo/model/InitializeVccRequest.h
include/alibabacloud/eflo/model/InitializeVccResult.h
include/alibabacloud/eflo/model/ListSubnetsRequest.h
include/alibabacloud/eflo/model/ListSubnetsResult.h
include/alibabacloud/eflo/model/ListVccsRequest.h
include/alibabacloud/eflo/model/ListVccsResult.h
include/alibabacloud/eflo/model/ListVpdsRequest.h
include/alibabacloud/eflo/model/ListVpdsResult.h
include/alibabacloud/eflo/model/UpdateSubnetRequest.h
include/alibabacloud/eflo/model/UpdateSubnetResult.h
include/alibabacloud/eflo/model/UpdateVccRequest.h
include/alibabacloud/eflo/model/UpdateVccResult.h
include/alibabacloud/eflo/model/UpdateVpdRequest.h
include/alibabacloud/eflo/model/UpdateVpdResult.h )
set(eflo_src
src/EfloClient.cc
src/model/CreateSubnetRequest.cc
src/model/CreateSubnetResult.cc
src/model/CreateVccRequest.cc
src/model/CreateVccResult.cc
src/model/CreateVpdRequest.cc
src/model/CreateVpdResult.cc
src/model/DeleteSubnetRequest.cc
src/model/DeleteSubnetResult.cc
src/model/DeleteVpdRequest.cc
src/model/DeleteVpdResult.cc
src/model/GetSubnetRequest.cc
src/model/GetSubnetResult.cc
src/model/GetVccRequest.cc
src/model/GetVccResult.cc
src/model/GetVpdRequest.cc
src/model/GetVpdResult.cc
src/model/InitializeVccRequest.cc
src/model/InitializeVccResult.cc
src/model/ListSubnetsRequest.cc
src/model/ListSubnetsResult.cc
src/model/ListVccsRequest.cc
src/model/ListVccsResult.cc
src/model/ListVpdsRequest.cc
src/model/ListVpdsResult.cc
src/model/UpdateSubnetRequest.cc
src/model/UpdateSubnetResult.cc
src/model/UpdateVccRequest.cc
src/model/UpdateVccResult.cc
src/model/UpdateVpdRequest.cc
src/model/UpdateVpdResult.cc )
add_library(eflo ${LIB_TYPE}
${eflo_public_header}
${eflo_public_header_model}
${eflo_src})
set_target_properties(eflo
PROPERTIES
LINKER_LANGUAGE CXX
ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
OUTPUT_NAME ${TARGET_OUTPUT_NAME_PREFIX}eflo
)
if(${LIB_TYPE} STREQUAL "SHARED")
set_target_properties(eflo
PROPERTIES
DEFINE_SYMBOL ALIBABACLOUD_EFLO_LIBRARY)
endif()
target_include_directories(eflo
PRIVATE include
${CMAKE_SOURCE_DIR}/core/include
)
target_link_libraries(eflo
core)
if(CMAKE_HOST_WIN32)
ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
set(jsoncpp_install_dir ${INSTALL_DIR})
add_dependencies(eflo
jsoncpp)
target_include_directories(eflo
PRIVATE ${jsoncpp_install_dir}/include)
target_link_libraries(eflo
${jsoncpp_install_dir}/lib/jsoncpp.lib)
set_target_properties(eflo
PROPERTIES
COMPILE_OPTIONS "/bigobj")
else()
target_include_directories(eflo
PRIVATE /usr/include/jsoncpp)
target_link_libraries(eflo
jsoncpp)
endif()
install(FILES ${eflo_public_header}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/eflo)
install(FILES ${eflo_public_header_model}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/eflo/model)
install(TARGETS eflo
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)

166
eflo/include/alibabacloud/eflo/EfloClient.h Normal file
View File

@@ -0,0 +1,166 @@
/*
* 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_EFLOCLIENT_H_
#define ALIBABACLOUD_EFLO_EFLOCLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "EfloExport.h"
#include "model/CreateSubnetRequest.h"
#include "model/CreateSubnetResult.h"
#include "model/CreateVccRequest.h"
#include "model/CreateVccResult.h"
#include "model/CreateVpdRequest.h"
#include "model/CreateVpdResult.h"
#include "model/DeleteSubnetRequest.h"
#include "model/DeleteSubnetResult.h"
#include "model/DeleteVpdRequest.h"
#include "model/DeleteVpdResult.h"
#include "model/GetSubnetRequest.h"
#include "model/GetSubnetResult.h"
#include "model/GetVccRequest.h"
#include "model/GetVccResult.h"
#include "model/GetVpdRequest.h"
#include "model/GetVpdResult.h"
#include "model/InitializeVccRequest.h"
#include "model/InitializeVccResult.h"
#include "model/ListSubnetsRequest.h"
#include "model/ListSubnetsResult.h"
#include "model/ListVccsRequest.h"
#include "model/ListVccsResult.h"
#include "model/ListVpdsRequest.h"
#include "model/ListVpdsResult.h"
#include "model/UpdateSubnetRequest.h"
#include "model/UpdateSubnetResult.h"
#include "model/UpdateVccRequest.h"
#include "model/UpdateVccResult.h"
#include "model/UpdateVpdRequest.h"
#include "model/UpdateVpdResult.h"
namespace AlibabaCloud
{
namespace Eflo
{
class ALIBABACLOUD_EFLO_EXPORT EfloClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::CreateSubnetResult> CreateSubnetOutcome;
typedef std::future<CreateSubnetOutcome> CreateSubnetOutcomeCallable;
typedef std::function<void(const EfloClient*, const Model::CreateSubnetRequest&, const CreateSubnetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateSubnetAsyncHandler;
typedef Outcome<Error, Model::CreateVccResult> CreateVccOutcome;
typedef std::future<CreateVccOutcome> CreateVccOutcomeCallable;
typedef std::function<void(const EfloClient*, const Model::CreateVccRequest&, const CreateVccOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateVccAsyncHandler;
typedef Outcome<Error, Model::CreateVpdResult> CreateVpdOutcome;
typedef std::future<CreateVpdOutcome> CreateVpdOutcomeCallable;
typedef std::function<void(const EfloClient*, const Model::CreateVpdRequest&, const CreateVpdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateVpdAsyncHandler;
typedef Outcome<Error, Model::DeleteSubnetResult> DeleteSubnetOutcome;
typedef std::future<DeleteSubnetOutcome> DeleteSubnetOutcomeCallable;
typedef std::function<void(const EfloClient*, const Model::DeleteSubnetRequest&, const DeleteSubnetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteSubnetAsyncHandler;
typedef Outcome<Error, Model::DeleteVpdResult> DeleteVpdOutcome;
typedef std::future<DeleteVpdOutcome> DeleteVpdOutcomeCallable;
typedef std::function<void(const EfloClient*, const Model::DeleteVpdRequest&, const DeleteVpdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteVpdAsyncHandler;
typedef Outcome<Error, Model::GetSubnetResult> GetSubnetOutcome;
typedef std::future<GetSubnetOutcome> GetSubnetOutcomeCallable;
typedef std::function<void(const EfloClient*, const Model::GetSubnetRequest&, const GetSubnetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetSubnetAsyncHandler;
typedef Outcome<Error, Model::GetVccResult> GetVccOutcome;
typedef std::future<GetVccOutcome> GetVccOutcomeCallable;
typedef std::function<void(const EfloClient*, const Model::GetVccRequest&, const GetVccOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVccAsyncHandler;
typedef Outcome<Error, Model::GetVpdResult> GetVpdOutcome;
typedef std::future<GetVpdOutcome> GetVpdOutcomeCallable;
typedef std::function<void(const EfloClient*, const Model::GetVpdRequest&, const GetVpdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVpdAsyncHandler;
typedef Outcome<Error, Model::InitializeVccResult> InitializeVccOutcome;
typedef std::future<InitializeVccOutcome> InitializeVccOutcomeCallable;
typedef std::function<void(const EfloClient*, const Model::InitializeVccRequest&, const InitializeVccOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> InitializeVccAsyncHandler;
typedef Outcome<Error, Model::ListSubnetsResult> ListSubnetsOutcome;
typedef std::future<ListSubnetsOutcome> ListSubnetsOutcomeCallable;
typedef std::function<void(const EfloClient*, const Model::ListSubnetsRequest&, const ListSubnetsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListSubnetsAsyncHandler;
typedef Outcome<Error, Model::ListVccsResult> ListVccsOutcome;
typedef std::future<ListVccsOutcome> ListVccsOutcomeCallable;
typedef std::function<void(const EfloClient*, const Model::ListVccsRequest&, const ListVccsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVccsAsyncHandler;
typedef Outcome<Error, Model::ListVpdsResult> ListVpdsOutcome;
typedef std::future<ListVpdsOutcome> ListVpdsOutcomeCallable;
typedef std::function<void(const EfloClient*, const Model::ListVpdsRequest&, const ListVpdsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVpdsAsyncHandler;
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;
typedef Outcome<Error, Model::UpdateVccResult> UpdateVccOutcome;
typedef std::future<UpdateVccOutcome> UpdateVccOutcomeCallable;
typedef std::function<void(const EfloClient*, const Model::UpdateVccRequest&, const UpdateVccOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateVccAsyncHandler;
typedef Outcome<Error, Model::UpdateVpdResult> UpdateVpdOutcome;
typedef std::future<UpdateVpdOutcome> UpdateVpdOutcomeCallable;
typedef std::function<void(const EfloClient*, const Model::UpdateVpdRequest&, const UpdateVpdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateVpdAsyncHandler;
EfloClient(const Credentials &credentials, const ClientConfiguration &configuration);
EfloClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
EfloClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~EfloClient();
CreateSubnetOutcome createSubnet(const Model::CreateSubnetRequest &request)const;
void createSubnetAsync(const Model::CreateSubnetRequest& request, const CreateSubnetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateSubnetOutcomeCallable createSubnetCallable(const Model::CreateSubnetRequest& request) const;
CreateVccOutcome createVcc(const Model::CreateVccRequest &request)const;
void createVccAsync(const Model::CreateVccRequest& request, const CreateVccAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateVccOutcomeCallable createVccCallable(const Model::CreateVccRequest& request) const;
CreateVpdOutcome createVpd(const Model::CreateVpdRequest &request)const;
void createVpdAsync(const Model::CreateVpdRequest& request, const CreateVpdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateVpdOutcomeCallable createVpdCallable(const Model::CreateVpdRequest& request) const;
DeleteSubnetOutcome deleteSubnet(const Model::DeleteSubnetRequest &request)const;
void deleteSubnetAsync(const Model::DeleteSubnetRequest& request, const DeleteSubnetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteSubnetOutcomeCallable deleteSubnetCallable(const Model::DeleteSubnetRequest& request) const;
DeleteVpdOutcome deleteVpd(const Model::DeleteVpdRequest &request)const;
void deleteVpdAsync(const Model::DeleteVpdRequest& request, const DeleteVpdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteVpdOutcomeCallable deleteVpdCallable(const Model::DeleteVpdRequest& request) const;
GetSubnetOutcome getSubnet(const Model::GetSubnetRequest &request)const;
void getSubnetAsync(const Model::GetSubnetRequest& request, const GetSubnetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetSubnetOutcomeCallable getSubnetCallable(const Model::GetSubnetRequest& request) const;
GetVccOutcome getVcc(const Model::GetVccRequest &request)const;
void getVccAsync(const Model::GetVccRequest& request, const GetVccAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetVccOutcomeCallable getVccCallable(const Model::GetVccRequest& request) const;
GetVpdOutcome getVpd(const Model::GetVpdRequest &request)const;
void getVpdAsync(const Model::GetVpdRequest& request, const GetVpdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetVpdOutcomeCallable getVpdCallable(const Model::GetVpdRequest& request) const;
InitializeVccOutcome initializeVcc(const Model::InitializeVccRequest &request)const;
void initializeVccAsync(const Model::InitializeVccRequest& request, const InitializeVccAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
InitializeVccOutcomeCallable initializeVccCallable(const Model::InitializeVccRequest& request) const;
ListSubnetsOutcome listSubnets(const Model::ListSubnetsRequest &request)const;
void listSubnetsAsync(const Model::ListSubnetsRequest& request, const ListSubnetsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListSubnetsOutcomeCallable listSubnetsCallable(const Model::ListSubnetsRequest& request) const;
ListVccsOutcome listVccs(const Model::ListVccsRequest &request)const;
void listVccsAsync(const Model::ListVccsRequest& request, const ListVccsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListVccsOutcomeCallable listVccsCallable(const Model::ListVccsRequest& request) const;
ListVpdsOutcome listVpds(const Model::ListVpdsRequest &request)const;
void listVpdsAsync(const Model::ListVpdsRequest& request, const ListVpdsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListVpdsOutcomeCallable listVpdsCallable(const Model::ListVpdsRequest& 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;
UpdateVccOutcome updateVcc(const Model::UpdateVccRequest &request)const;
void updateVccAsync(const Model::UpdateVccRequest& request, const UpdateVccAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateVccOutcomeCallable updateVccCallable(const Model::UpdateVccRequest& request) const;
UpdateVpdOutcome updateVpd(const Model::UpdateVpdRequest &request)const;
void updateVpdAsync(const Model::UpdateVpdRequest& request, const UpdateVpdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateVpdOutcomeCallable updateVpdCallable(const Model::UpdateVpdRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_EFLO_EFLOCLIENT_H_

32
eflo/include/alibabacloud/eflo/EfloExport.h Normal file
View File

@@ -0,0 +1,32 @@
/*
* 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_EFLOEXPORT_H_
#define ALIBABACLOUD_EFLO_EFLOEXPORT_H_
#include <alibabacloud/core/Global.h>
#if defined(ALIBABACLOUD_SHARED)
# if defined(ALIBABACLOUD_EFLO_LIBRARY)
# define ALIBABACLOUD_EFLO_EXPORT ALIBABACLOUD_DECL_EXPORT
# else
# define ALIBABACLOUD_EFLO_EXPORT ALIBABACLOUD_DECL_IMPORT
# endif
#else
# define ALIBABACLOUD_EFLO_EXPORT
#endif
#endif // !ALIBABACLOUD_EFLO_EFLOEXPORT_H_

57
eflo/include/alibabacloud/eflo/model/CreateSubnetRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* 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_CREATESUBNETREQUEST_H_
#define ALIBABACLOUD_EFLO_MODEL_CREATESUBNETREQUEST_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 CreateSubnetRequest : public RpcServiceRequest {
public:
CreateSubnetRequest();
~CreateSubnetRequest();
std::string getType() const;
void setType(const std::string &type);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getVpdId() const;
void setVpdId(const std::string &vpdId);
std::string getName() const;
void setName(const std::string &name);
std::string getZoneId() const;
void setZoneId(const std::string &zoneId);
std::string getCidr() const;
void setCidr(const std::string &cidr);
private:
std::string type_;
std::string regionId_;
std::string vpdId_;
std::string name_;
std::string zoneId_;
std::string cidr_;
};
} // namespace Model
} // namespace Eflo
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_MODEL_CREATESUBNETREQUEST_H_

59
eflo/include/alibabacloud/eflo/model/CreateSubnetResult.h Normal file
View File

@@ -0,0 +1,59 @@
/*
* 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_CREATESUBNETRESULT_H_
#define ALIBABACLOUD_EFLO_MODEL_CREATESUBNETRESULT_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 CreateSubnetResult : public ServiceResult
{
public:
struct Content
{
std::string subnetId;
};
CreateSubnetResult();
explicit CreateSubnetResult(const std::string &payload);
~CreateSubnetResult();
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_CREATESUBNETRESULT_H_

66
eflo/include/alibabacloud/eflo/model/CreateVccRequest.h Normal file
View File

@@ -0,0 +1,66 @@
/*
* 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_CREATEVCCREQUEST_H_
#define ALIBABACLOUD_EFLO_MODEL_CREATEVCCREQUEST_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 CreateVccRequest : public RpcServiceRequest {
public:
CreateVccRequest();
~CreateVccRequest();
std::string getBgpCidr() const;
void setBgpCidr(const std::string &bgpCidr);
std::string getCenId() const;
void setCenId(const std::string &cenId);
std::string getDescription() const;
void setDescription(const std::string &description);
bool getAccessCouldService() const;
void setAccessCouldService(bool accessCouldService);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getVccId() const;
void setVccId(const std::string &vccId);
std::string getVSwitchId() const;
void setVSwitchId(const std::string &vSwitchId);
std::string getVpdId() const;
void setVpdId(const std::string &vpdId);
std::string getVpcId() const;
void setVpcId(const std::string &vpcId);
private:
std::string bgpCidr_;
std::string cenId_;
std::string description_;
bool accessCouldService_;
std::string regionId_;
std::string vccId_;
std::string vSwitchId_;
std::string vpdId_;
std::string vpcId_;
};
} // namespace Model
} // namespace Eflo
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_MODEL_CREATEVCCREQUEST_H_

59
eflo/include/alibabacloud/eflo/model/CreateVccResult.h Normal file
View File

@@ -0,0 +1,59 @@
/*
* 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_CREATEVCCRESULT_H_
#define ALIBABACLOUD_EFLO_MODEL_CREATEVCCRESULT_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 CreateVccResult : public ServiceResult
{
public:
struct Content
{
std::string vccId;
};
CreateVccResult();
explicit CreateVccResult(const std::string &payload);
~CreateVccResult();
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_CREATEVCCRESULT_H_

58
eflo/include/alibabacloud/eflo/model/CreateVpdRequest.h Normal file
View File

@@ -0,0 +1,58 @@
/*
* 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_CREATEVPDREQUEST_H_
#define ALIBABACLOUD_EFLO_MODEL_CREATEVPDREQUEST_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 CreateVpdRequest : public RpcServiceRequest {
public:
struct Subnets {
std::string regionId;
std::string name;
std::string zoneId;
std::string cidr;
std::string type;
};
CreateVpdRequest();
~CreateVpdRequest();
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getName() const;
void setName(const std::string &name);
std::string getCidr() const;
void setCidr(const std::string &cidr);
std::vector<Subnets> getSubnets() const;
void setSubnets(const std::vector<Subnets> &subnets);
private:
std::string regionId_;
std::string name_;
std::string cidr_;
std::vector<Subnets> subnets_;
};
} // namespace Model
} // namespace Eflo
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_MODEL_CREATEVPDREQUEST_H_

60
eflo/include/alibabacloud/eflo/model/CreateVpdResult.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_CREATEVPDRESULT_H_
#define ALIBABACLOUD_EFLO_MODEL_CREATEVPDRESULT_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 CreateVpdResult : public ServiceResult
{
public:
struct Content
{
std::string vpdId;
std::vector<std::string> subnetIds;
};
CreateVpdResult();
explicit CreateVpdResult(const std::string &payload);
~CreateVpdResult();
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_CREATEVPDRESULT_H_

51
eflo/include/alibabacloud/eflo/model/DeleteSubnetRequest.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_DELETESUBNETREQUEST_H_
#define ALIBABACLOUD_EFLO_MODEL_DELETESUBNETREQUEST_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 DeleteSubnetRequest : public RpcServiceRequest {
public:
DeleteSubnetRequest();
~DeleteSubnetRequest();
std::string getSubnetId() const;
void setSubnetId(const std::string &subnetId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getVpdId() const;
void setVpdId(const std::string &vpdId);
std::string getZoneId() const;
void setZoneId(const std::string &zoneId);
private:
std::string subnetId_;
std::string regionId_;
std::string vpdId_;
std::string zoneId_;
};
} // namespace Model
} // namespace Eflo
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_MODEL_DELETESUBNETREQUEST_H_

49
eflo/include/alibabacloud/eflo/model/DeleteSubnetResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* 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_DELETESUBNETRESULT_H_
#define ALIBABACLOUD_EFLO_MODEL_DELETESUBNETRESULT_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 DeleteSubnetResult : public ServiceResult
{
public:
DeleteSubnetResult();
explicit DeleteSubnetResult(const std::string &payload);
~DeleteSubnetResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_EFLO_MODEL_DELETESUBNETRESULT_H_

45
eflo/include/alibabacloud/eflo/model/DeleteVpdRequest.h Normal file
View File

@@ -0,0 +1,45 @@
/*
* 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_DELETEVPDREQUEST_H_
#define ALIBABACLOUD_EFLO_MODEL_DELETEVPDREQUEST_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 DeleteVpdRequest : public RpcServiceRequest {
public:
DeleteVpdRequest();
~DeleteVpdRequest();
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getVpdId() const;
void setVpdId(const std::string &vpdId);
private:
std::string regionId_;
std::string vpdId_;
};
} // namespace Model
} // namespace Eflo
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_MODEL_DELETEVPDREQUEST_H_

49
eflo/include/alibabacloud/eflo/model/DeleteVpdResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* 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_DELETEVPDRESULT_H_
#define ALIBABACLOUD_EFLO_MODEL_DELETEVPDRESULT_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 DeleteVpdResult : public ServiceResult
{
public:
DeleteVpdResult();
explicit DeleteVpdResult(const std::string &payload);
~DeleteVpdResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_EFLO_MODEL_DELETEVPDRESULT_H_

42
eflo/include/alibabacloud/eflo/model/GetSubnetRequest.h Normal file
View File

@@ -0,0 +1,42 @@
/*
* 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_GETSUBNETREQUEST_H_
#define ALIBABACLOUD_EFLO_MODEL_GETSUBNETREQUEST_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 GetSubnetRequest : public RpcServiceRequest {
public:
GetSubnetRequest();
~GetSubnetRequest();
std::string getSubnetId() const;
void setSubnetId(const std::string &subnetId);
private:
std::string subnetId_;
};
} // namespace Model
} // namespace Eflo
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_MODEL_GETSUBNETREQUEST_H_

82
eflo/include/alibabacloud/eflo/model/GetSubnetResult.h 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.
*/
#ifndef ALIBABACLOUD_EFLO_MODEL_GETSUBNETRESULT_H_
#define ALIBABACLOUD_EFLO_MODEL_GETSUBNETRESULT_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 GetSubnetResult : public ServiceResult
{
public:
struct Content
{
struct VpdBaseInfo
{
std::string gmtCreate;
std::string cidr;
std::string vpdId;
std::string name;
};
std::string status;
long ncCount;
long lbCount;
VpdBaseInfo vpdBaseInfo;
std::string description;
std::string zoneId;
std::string message;
std::string gmtModified;
std::string subnetId;
std::string name;
std::string gmtCreate;
std::string tenantId;
std::string type;
std::string cidr;
std::string vpdId;
long id;
std::string regionId;
};
GetSubnetResult();
explicit GetSubnetResult(const std::string &payload);
~GetSubnetResult();
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_GETSUBNETRESULT_H_

45
eflo/include/alibabacloud/eflo/model/GetVccRequest.h Normal file
View File

@@ -0,0 +1,45 @@
/*
* 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_GETVCCREQUEST_H_
#define ALIBABACLOUD_EFLO_MODEL_GETVCCREQUEST_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 GetVccRequest : public RpcServiceRequest {
public:
GetVccRequest();
~GetVccRequest();
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getVccId() const;
void setVccId(const std::string &vccId);
private:
std::string regionId_;
std::string vccId_;
};
} // namespace Model
} // namespace Eflo
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_MODEL_GETVCCREQUEST_H_

115
eflo/include/alibabacloud/eflo/model/GetVccResult.h Normal file
View File

@@ -0,0 +1,115 @@
/*
* 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_GETVCCRESULT_H_
#define ALIBABACLOUD_EFLO_MODEL_GETVCCRESULT_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 GetVccResult : public ServiceResult
{
public:
struct Content
{
struct VpdBaseInfo
{
std::string gmtCreate;
std::string cidr;
std::string vpdId;
std::string name;
};
struct AliyunRouterInfoItem
{
std::string localGatewayIp;
std::string peerGatewayIp;
std::string mask;
std::string pcId;
std::string vbrId;
std::string vlanId;
};
struct CisRouterInfoItem
{
struct CcInfo
{
std::string status;
std::string localGatewayIp;
std::string remoteGatewayIp;
std::string ccId;
std::string vlanId;
std::string subnetMask;
};
std::string ccrId;
std::vector<CisRouterInfoItem::CcInfo> ccInfos;
};
std::string message;
std::string lineOperator;
std::string pricingCycle;
std::string currentNode;
std::string gmtModified;
std::string bgpCidr;
std::string commodityCode;
std::string vccId;
std::string status;
VpdBaseInfo vpdBaseInfo;
std::string vSwitchId;
std::string createTime;
std::string duration;
std::string payType;
std::vector<AliyunRouterInfoItem> aliyunRouterInfo;
std::string internetChargeType;
std::string bandwidthStr;
std::vector<CisRouterInfoItem> cisRouterInfo;
std::string tenantId;
std::string vpcId;
std::string vpdId;
std::string cenId;
std::string accessPointId;
std::string regionId;
std::string spec;
std::string vccName;
std::string portType;
};
GetVccResult();
explicit GetVccResult(const std::string &payload);
~GetVccResult();
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_GETVCCRESULT_H_

42
eflo/include/alibabacloud/eflo/model/GetVpdRequest.h Normal file
View File

@@ -0,0 +1,42 @@
/*
* 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_GETVPDREQUEST_H_
#define ALIBABACLOUD_EFLO_MODEL_GETVPDREQUEST_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 GetVpdRequest : public RpcServiceRequest {
public:
GetVpdRequest();
~GetVpdRequest();
std::string getVpdId() const;
void setVpdId(const std::string &vpdId);
private:
std::string vpdId_;
};
} // namespace Model
} // namespace Eflo
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_MODEL_GETVPDREQUEST_H_

73
eflo/include/alibabacloud/eflo/model/GetVpdResult.h Normal file
View File

@@ -0,0 +1,73 @@
/*
* 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_GETVPDRESULT_H_
#define ALIBABACLOUD_EFLO_MODEL_GETVPDRESULT_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 GetVpdResult : public ServiceResult
{
public:
struct Content
{
std::string status;
long ncCount;
long lbCount;
std::string description;
std::string message;
long subnetCount;
std::string gmtModified;
std::string name;
std::string gmtCreate;
std::string cidr;
std::string vpdId;
std::string serviceCidr;
std::string regionId;
long vccCount;
int route;
};
GetVpdResult();
explicit GetVpdResult(const std::string &payload);
~GetVpdResult();
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_GETVPDRESULT_H_

39
eflo/include/alibabacloud/eflo/model/InitializeVccRequest.h Normal file
View File

@@ -0,0 +1,39 @@
/*
* 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_INITIALIZEVCCREQUEST_H_
#define ALIBABACLOUD_EFLO_MODEL_INITIALIZEVCCREQUEST_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 InitializeVccRequest : public RpcServiceRequest {
public:
InitializeVccRequest();
~InitializeVccRequest();
private:
};
} // namespace Model
} // namespace Eflo
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_MODEL_INITIALIZEVCCREQUEST_H_

60
eflo/include/alibabacloud/eflo/model/InitializeVccResult.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_INITIALIZEVCCRESULT_H_
#define ALIBABACLOUD_EFLO_MODEL_INITIALIZEVCCRESULT_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 InitializeVccResult : public ServiceResult
{
public:
struct Content
{
std::string roleName;
std::string requestId;
};
InitializeVccResult();
explicit InitializeVccResult(const std::string &payload);
~InitializeVccResult();
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_INITIALIZEVCCRESULT_H_

69
eflo/include/alibabacloud/eflo/model/ListSubnetsRequest.h Normal file
View File

@@ -0,0 +1,69 @@
/*
* 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_LISTSUBNETSREQUEST_H_
#define ALIBABACLOUD_EFLO_MODEL_LISTSUBNETSREQUEST_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 ListSubnetsRequest : public RpcServiceRequest {
public:
ListSubnetsRequest();
~ListSubnetsRequest();
std::string getType() const;
void setType(const std::string &type);
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 getSubnetId() const;
void setSubnetId(const std::string &subnetId);
std::string getVpdId() const;
void setVpdId(const std::string &vpdId);
bool getEnablePage() const;
void setEnablePage(bool enablePage);
std::string getName() const;
void setName(const std::string &name);
std::string getZoneId() const;
void setZoneId(const std::string &zoneId);
std::string getStatus() const;
void setStatus(const std::string &status);
private:
std::string type_;
int pageNumber_;
std::string regionId_;
int pageSize_;
std::string subnetId_;
std::string vpdId_;
bool enablePage_;
std::string name_;
std::string zoneId_;
std::string status_;
};
} // namespace Model
} // namespace Eflo
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_MODEL_LISTSUBNETSREQUEST_H_

85
eflo/include/alibabacloud/eflo/model/ListSubnetsResult.h Normal file
View File

@@ -0,0 +1,85 @@
/*
* 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_LISTSUBNETSRESULT_H_
#define ALIBABACLOUD_EFLO_MODEL_LISTSUBNETSRESULT_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 ListSubnetsResult : public ServiceResult
{
public:
struct Content
{
struct DataItem
{
struct VpdBaseInfo
{
std::string gmtCreate;
std::string cidr;
std::string vpdId;
std::string name;
};
std::string status;
long ncCount;
VpdBaseInfo vpdBaseInfo;
std::string zoneId;
std::string message;
std::string gmtModified;
std::string subnetId;
std::string name;
std::string gmtCreate;
std::string tenantId;
std::string type;
std::string cidr;
std::string vpdId;
long id;
std::string regionId;
};
long total;
std::vector<DataItem> data;
};
ListSubnetsResult();
explicit ListSubnetsResult(const std::string &payload);
~ListSubnetsResult();
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_LISTSUBNETSRESULT_H_

72
eflo/include/alibabacloud/eflo/model/ListVccsRequest.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_LISTVCCSREQUEST_H_
#define ALIBABACLOUD_EFLO_MODEL_LISTVCCSREQUEST_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 ListVccsRequest : public RpcServiceRequest {
public:
ListVccsRequest();
~ListVccsRequest();
std::string getCenId() const;
void setCenId(const std::string &cenId);
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 getVccId() const;
void setVccId(const std::string &vccId);
int getBandwidth() const;
void setBandwidth(int bandwidth);
std::string getExStatus() const;
void setExStatus(const std::string &exStatus);
std::string getVpdId() const;
void setVpdId(const std::string &vpdId);
std::string getVpcId() const;
void setVpcId(const std::string &vpcId);
bool getEnablePage() const;
void setEnablePage(bool enablePage);
std::string getStatus() const;
void setStatus(const std::string &status);
private:
std::string cenId_;
int pageNumber_;
std::string regionId_;
int pageSize_;
std::string vccId_;
int bandwidth_;
std::string exStatus_;
std::string vpdId_;
std::string vpcId_;
bool enablePage_;
std::string status_;
};
} // namespace Model
} // namespace Eflo
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_MODEL_LISTVCCSREQUEST_H_

89
eflo/include/alibabacloud/eflo/model/ListVccsResult.h Normal file
View File

@@ -0,0 +1,89 @@
/*
* 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_LISTVCCSRESULT_H_
#define ALIBABACLOUD_EFLO_MODEL_LISTVCCSRESULT_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 ListVccsResult : public ServiceResult
{
public:
struct Content
{
struct DataItem
{
struct VpdBaseInfo
{
std::string gmtCreate;
std::string cidr;
std::string vpdId;
std::string name;
};
std::string status;
VpdBaseInfo vpdBaseInfo;
std::string message;
std::string lineOperator;
double rate;
std::string createTime;
std::string gmtModified;
std::string bandwidthStr;
std::string tenantId;
std::string vpcId;
std::string vpdId;
std::string bgpCidr;
std::string cenId;
std::string accessPointId;
std::string regionId;
std::string vccId;
std::string spec;
std::string vccName;
std::string portType;
};
long total;
std::vector<DataItem> data;
};
ListVccsResult();
explicit ListVccsResult(const std::string &payload);
~ListVccsResult();
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_LISTVCCSRESULT_H_

72
eflo/include/alibabacloud/eflo/model/ListVpdsRequest.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_LISTVPDSREQUEST_H_
#define ALIBABACLOUD_EFLO_MODEL_LISTVPDSREQUEST_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 ListVpdsRequest : public RpcServiceRequest {
public:
ListVpdsRequest();
~ListVpdsRequest();
int getPageNumber() const;
void setPageNumber(int pageNumber);
bool getWithDependence() const;
void setWithDependence(bool withDependence);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
bool getWithoutVcc() const;
void setWithoutVcc(bool withoutVcc);
int getPageSize() const;
void setPageSize(int pageSize);
bool getForSelect() const;
void setForSelect(bool forSelect);
std::string getFilterErId() const;
void setFilterErId(const std::string &filterErId);
std::string getVpdId() const;
void setVpdId(const std::string &vpdId);
bool getEnablePage() const;
void setEnablePage(bool enablePage);
std::string getName() const;
void setName(const std::string &name);
std::string getStatus() const;
void setStatus(const std::string &status);
private:
int pageNumber_;
bool withDependence_;
std::string regionId_;
bool withoutVcc_;
int pageSize_;
bool forSelect_;
std::string filterErId_;
std::string vpdId_;
bool enablePage_;
std::string name_;
std::string status_;
};
} // namespace Model
} // namespace Eflo
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_MODEL_LISTVPDSREQUEST_H_

76
eflo/include/alibabacloud/eflo/model/ListVpdsResult.h Normal file
View File

@@ -0,0 +1,76 @@
/*
* 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_LISTVPDSRESULT_H_
#define ALIBABACLOUD_EFLO_MODEL_LISTVPDSRESULT_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 ListVpdsResult : public ServiceResult
{
public:
struct Content
{
struct DataItem
{
std::string status;
int ncCount;
std::string message;
int subnetCount;
std::string gmtModified;
std::string name;
std::string gmtCreate;
std::string cidr;
std::string vpdId;
std::string dependence;
std::string serviceCidr;
std::string regionId;
int route;
};
long total;
std::vector<DataItem> data;
};
ListVpdsResult();
explicit ListVpdsResult(const std::string &payload);
~ListVpdsResult();
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_LISTVPDSRESULT_H_

57
eflo/include/alibabacloud/eflo/model/UpdateSubnetRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* 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_UPDATESUBNETREQUEST_H_
#define ALIBABACLOUD_EFLO_MODEL_UPDATESUBNETREQUEST_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 UpdateSubnetRequest : public RpcServiceRequest {
public:
UpdateSubnetRequest();
~UpdateSubnetRequest();
std::string getSubnetId() const;
void setSubnetId(const std::string &subnetId);
std::string getDescription() const;
void setDescription(const std::string &description);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getVpdId() const;
void setVpdId(const std::string &vpdId);
std::string getName() const;
void setName(const std::string &name);
std::string getZoneId() const;
void setZoneId(const std::string &zoneId);
private:
std::string subnetId_;
std::string description_;
std::string regionId_;
std::string vpdId_;
std::string name_;
std::string zoneId_;
};
} // namespace Model
} // namespace Eflo
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_MODEL_UPDATESUBNETREQUEST_H_

59
eflo/include/alibabacloud/eflo/model/UpdateSubnetResult.h Normal file
View File

@@ -0,0 +1,59 @@
/*
* 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_UPDATESUBNETRESULT_H_
#define ALIBABACLOUD_EFLO_MODEL_UPDATESUBNETRESULT_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 UpdateSubnetResult : public ServiceResult
{
public:
struct Content
{
std::string subnetId;
};
UpdateSubnetResult();
explicit UpdateSubnetResult(const std::string &payload);
~UpdateSubnetResult();
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_UPDATESUBNETRESULT_H_

54
eflo/include/alibabacloud/eflo/model/UpdateVccRequest.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_UPDATEVCCREQUEST_H_
#define ALIBABACLOUD_EFLO_MODEL_UPDATEVCCREQUEST_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 UpdateVccRequest : public RpcServiceRequest {
public:
UpdateVccRequest();
~UpdateVccRequest();
int getBandwidth() const;
void setBandwidth(int bandwidth);
std::string getOrderId() const;
void setOrderId(const std::string &orderId);
std::string getVccName() const;
void setVccName(const std::string &vccName);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getVccId() const;
void setVccId(const std::string &vccId);
private:
int bandwidth_;
std::string orderId_;
std::string vccName_;
std::string regionId_;
std::string vccId_;
};
} // namespace Model
} // namespace Eflo
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_MODEL_UPDATEVCCREQUEST_H_

59
eflo/include/alibabacloud/eflo/model/UpdateVccResult.h Normal file
View File

@@ -0,0 +1,59 @@
/*
* 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_UPDATEVCCRESULT_H_
#define ALIBABACLOUD_EFLO_MODEL_UPDATEVCCRESULT_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 UpdateVccResult : public ServiceResult
{
public:
struct Content
{
std::string vccId;
};
UpdateVccResult();
explicit UpdateVccResult(const std::string &payload);
~UpdateVccResult();
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_UPDATEVCCRESULT_H_

51
eflo/include/alibabacloud/eflo/model/UpdateVpdRequest.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_UPDATEVPDREQUEST_H_
#define ALIBABACLOUD_EFLO_MODEL_UPDATEVPDREQUEST_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 UpdateVpdRequest : public RpcServiceRequest {
public:
UpdateVpdRequest();
~UpdateVpdRequest();
std::string getDescription() const;
void setDescription(const std::string &description);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getVpdId() const;
void setVpdId(const std::string &vpdId);
std::string getName() const;
void setName(const std::string &name);
private:
std::string description_;
std::string regionId_;
std::string vpdId_;
std::string name_;
};
} // namespace Model
} // namespace Eflo
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_EFLO_MODEL_UPDATEVPDREQUEST_H_

59
eflo/include/alibabacloud/eflo/model/UpdateVpdResult.h Normal file
View File

@@ -0,0 +1,59 @@
/*
* 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_UPDATEVPDRESULT_H_
#define ALIBABACLOUD_EFLO_MODEL_UPDATEVPDRESULT_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 UpdateVpdResult : public ServiceResult
{
public:
struct Content
{
std::string vpdId;
};
UpdateVpdResult();
explicit UpdateVpdResult(const std::string &payload);
~UpdateVpdResult();
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_UPDATEVPDRESULT_H_

593
eflo/src/EfloClient.cc Normal file
View File

@@ -0,0 +1,593 @@
/*
* 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/EfloClient.h>
#include <alibabacloud/core/SimpleCredentialsProvider.h>
using namespace AlibabaCloud;
using namespace AlibabaCloud::Location;
using namespace AlibabaCloud::Eflo;
using namespace AlibabaCloud::Eflo::Model;
namespace
{
const std::string SERVICE_NAME = "eflo";
}
EfloClient::EfloClient(const Credentials &credentials, const ClientConfiguration &configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "eflo");
}
EfloClient::EfloClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "eflo");
}
EfloClient::EfloClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
{
auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "eflo");
}
EfloClient::~EfloClient()
{}
EfloClient::CreateSubnetOutcome EfloClient::createSubnet(const CreateSubnetRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateSubnetOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateSubnetOutcome(CreateSubnetResult(outcome.result()));
else
return CreateSubnetOutcome(outcome.error());
}
void EfloClient::createSubnetAsync(const CreateSubnetRequest& request, const CreateSubnetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createSubnet(request), context);
};
asyncExecute(new Runnable(fn));
}
EfloClient::CreateSubnetOutcomeCallable EfloClient::createSubnetCallable(const CreateSubnetRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateSubnetOutcome()>>(
[this, request]()
{
return this->createSubnet(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EfloClient::CreateVccOutcome EfloClient::createVcc(const CreateVccRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateVccOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateVccOutcome(CreateVccResult(outcome.result()));
else
return CreateVccOutcome(outcome.error());
}
void EfloClient::createVccAsync(const CreateVccRequest& request, const CreateVccAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createVcc(request), context);
};
asyncExecute(new Runnable(fn));
}
EfloClient::CreateVccOutcomeCallable EfloClient::createVccCallable(const CreateVccRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateVccOutcome()>>(
[this, request]()
{
return this->createVcc(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EfloClient::CreateVpdOutcome EfloClient::createVpd(const CreateVpdRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateVpdOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateVpdOutcome(CreateVpdResult(outcome.result()));
else
return CreateVpdOutcome(outcome.error());
}
void EfloClient::createVpdAsync(const CreateVpdRequest& request, const CreateVpdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createVpd(request), context);
};
asyncExecute(new Runnable(fn));
}
EfloClient::CreateVpdOutcomeCallable EfloClient::createVpdCallable(const CreateVpdRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateVpdOutcome()>>(
[this, request]()
{
return this->createVpd(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EfloClient::DeleteSubnetOutcome EfloClient::deleteSubnet(const DeleteSubnetRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteSubnetOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteSubnetOutcome(DeleteSubnetResult(outcome.result()));
else
return DeleteSubnetOutcome(outcome.error());
}
void EfloClient::deleteSubnetAsync(const DeleteSubnetRequest& request, const DeleteSubnetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteSubnet(request), context);
};
asyncExecute(new Runnable(fn));
}
EfloClient::DeleteSubnetOutcomeCallable EfloClient::deleteSubnetCallable(const DeleteSubnetRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteSubnetOutcome()>>(
[this, request]()
{
return this->deleteSubnet(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EfloClient::DeleteVpdOutcome EfloClient::deleteVpd(const DeleteVpdRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteVpdOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteVpdOutcome(DeleteVpdResult(outcome.result()));
else
return DeleteVpdOutcome(outcome.error());
}
void EfloClient::deleteVpdAsync(const DeleteVpdRequest& request, const DeleteVpdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteVpd(request), context);
};
asyncExecute(new Runnable(fn));
}
EfloClient::DeleteVpdOutcomeCallable EfloClient::deleteVpdCallable(const DeleteVpdRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteVpdOutcome()>>(
[this, request]()
{
return this->deleteVpd(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EfloClient::GetSubnetOutcome EfloClient::getSubnet(const GetSubnetRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetSubnetOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetSubnetOutcome(GetSubnetResult(outcome.result()));
else
return GetSubnetOutcome(outcome.error());
}
void EfloClient::getSubnetAsync(const GetSubnetRequest& request, const GetSubnetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getSubnet(request), context);
};
asyncExecute(new Runnable(fn));
}
EfloClient::GetSubnetOutcomeCallable EfloClient::getSubnetCallable(const GetSubnetRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetSubnetOutcome()>>(
[this, request]()
{
return this->getSubnet(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EfloClient::GetVccOutcome EfloClient::getVcc(const GetVccRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetVccOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetVccOutcome(GetVccResult(outcome.result()));
else
return GetVccOutcome(outcome.error());
}
void EfloClient::getVccAsync(const GetVccRequest& request, const GetVccAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getVcc(request), context);
};
asyncExecute(new Runnable(fn));
}
EfloClient::GetVccOutcomeCallable EfloClient::getVccCallable(const GetVccRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetVccOutcome()>>(
[this, request]()
{
return this->getVcc(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EfloClient::GetVpdOutcome EfloClient::getVpd(const GetVpdRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetVpdOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetVpdOutcome(GetVpdResult(outcome.result()));
else
return GetVpdOutcome(outcome.error());
}
void EfloClient::getVpdAsync(const GetVpdRequest& request, const GetVpdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getVpd(request), context);
};
asyncExecute(new Runnable(fn));
}
EfloClient::GetVpdOutcomeCallable EfloClient::getVpdCallable(const GetVpdRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetVpdOutcome()>>(
[this, request]()
{
return this->getVpd(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EfloClient::InitializeVccOutcome EfloClient::initializeVcc(const InitializeVccRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return InitializeVccOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return InitializeVccOutcome(InitializeVccResult(outcome.result()));
else
return InitializeVccOutcome(outcome.error());
}
void EfloClient::initializeVccAsync(const InitializeVccRequest& request, const InitializeVccAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, initializeVcc(request), context);
};
asyncExecute(new Runnable(fn));
}
EfloClient::InitializeVccOutcomeCallable EfloClient::initializeVccCallable(const InitializeVccRequest &request) const
{
auto task = std::make_shared<std::packaged_task<InitializeVccOutcome()>>(
[this, request]()
{
return this->initializeVcc(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EfloClient::ListSubnetsOutcome EfloClient::listSubnets(const ListSubnetsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListSubnetsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListSubnetsOutcome(ListSubnetsResult(outcome.result()));
else
return ListSubnetsOutcome(outcome.error());
}
void EfloClient::listSubnetsAsync(const ListSubnetsRequest& request, const ListSubnetsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listSubnets(request), context);
};
asyncExecute(new Runnable(fn));
}
EfloClient::ListSubnetsOutcomeCallable EfloClient::listSubnetsCallable(const ListSubnetsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListSubnetsOutcome()>>(
[this, request]()
{
return this->listSubnets(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EfloClient::ListVccsOutcome EfloClient::listVccs(const ListVccsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListVccsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListVccsOutcome(ListVccsResult(outcome.result()));
else
return ListVccsOutcome(outcome.error());
}
void EfloClient::listVccsAsync(const ListVccsRequest& request, const ListVccsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listVccs(request), context);
};
asyncExecute(new Runnable(fn));
}
EfloClient::ListVccsOutcomeCallable EfloClient::listVccsCallable(const ListVccsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListVccsOutcome()>>(
[this, request]()
{
return this->listVccs(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EfloClient::ListVpdsOutcome EfloClient::listVpds(const ListVpdsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListVpdsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListVpdsOutcome(ListVpdsResult(outcome.result()));
else
return ListVpdsOutcome(outcome.error());
}
void EfloClient::listVpdsAsync(const ListVpdsRequest& request, const ListVpdsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listVpds(request), context);
};
asyncExecute(new Runnable(fn));
}
EfloClient::ListVpdsOutcomeCallable EfloClient::listVpdsCallable(const ListVpdsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListVpdsOutcome()>>(
[this, request]()
{
return this->listVpds(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EfloClient::UpdateSubnetOutcome EfloClient::updateSubnet(const UpdateSubnetRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpdateSubnetOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpdateSubnetOutcome(UpdateSubnetResult(outcome.result()));
else
return UpdateSubnetOutcome(outcome.error());
}
void EfloClient::updateSubnetAsync(const UpdateSubnetRequest& request, const UpdateSubnetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, updateSubnet(request), context);
};
asyncExecute(new Runnable(fn));
}
EfloClient::UpdateSubnetOutcomeCallable EfloClient::updateSubnetCallable(const UpdateSubnetRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpdateSubnetOutcome()>>(
[this, request]()
{
return this->updateSubnet(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EfloClient::UpdateVccOutcome EfloClient::updateVcc(const UpdateVccRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpdateVccOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpdateVccOutcome(UpdateVccResult(outcome.result()));
else
return UpdateVccOutcome(outcome.error());
}
void EfloClient::updateVccAsync(const UpdateVccRequest& request, const UpdateVccAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, updateVcc(request), context);
};
asyncExecute(new Runnable(fn));
}
EfloClient::UpdateVccOutcomeCallable EfloClient::updateVccCallable(const UpdateVccRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpdateVccOutcome()>>(
[this, request]()
{
return this->updateVcc(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EfloClient::UpdateVpdOutcome EfloClient::updateVpd(const UpdateVpdRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpdateVpdOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpdateVpdOutcome(UpdateVpdResult(outcome.result()));
else
return UpdateVpdOutcome(outcome.error());
}
void EfloClient::updateVpdAsync(const UpdateVpdRequest& request, const UpdateVpdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, updateVpd(request), context);
};
asyncExecute(new Runnable(fn));
}
EfloClient::UpdateVpdOutcomeCallable EfloClient::updateVpdCallable(const UpdateVpdRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpdateVpdOutcome()>>(
[this, request]()
{
return this->updateVpd(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}

81
eflo/src/model/CreateSubnetRequest.cc Normal file
View File

@@ -0,0 +1,81 @@
/*
* 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/CreateSubnetRequest.h>
using AlibabaCloud::Eflo::Model::CreateSubnetRequest;
CreateSubnetRequest::CreateSubnetRequest()
: RpcServiceRequest("eflo", "2022-05-30", "CreateSubnet") {
setMethod(HttpRequest::Method::Post);
}
CreateSubnetRequest::~CreateSubnetRequest() {}
std::string CreateSubnetRequest::getType() const {
return type_;
}
void CreateSubnetRequest::setType(const std::string &type) {
type_ = type;
setBodyParameter(std::string("Type"), type);
}
std::string CreateSubnetRequest::getRegionId() const {
return regionId_;
}
void CreateSubnetRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setBodyParameter(std::string("RegionId"), regionId);
}
std::string CreateSubnetRequest::getVpdId() const {
return vpdId_;
}
void CreateSubnetRequest::setVpdId(const std::string &vpdId) {
vpdId_ = vpdId;
setBodyParameter(std::string("VpdId"), vpdId);
}
std::string CreateSubnetRequest::getName() const {
return name_;
}
void CreateSubnetRequest::setName(const std::string &name) {
name_ = name;
setBodyParameter(std::string("Name"), name);
}
std::string CreateSubnetRequest::getZoneId() const {
return zoneId_;
}
void CreateSubnetRequest::setZoneId(const std::string &zoneId) {
zoneId_ = zoneId;
setBodyParameter(std::string("ZoneId"), zoneId);
}
std::string CreateSubnetRequest::getCidr() const {
return cidr_;
}
void CreateSubnetRequest::setCidr(const std::string &cidr) {
cidr_ = cidr;
setBodyParameter(std::string("Cidr"), cidr);
}

66
eflo/src/model/CreateSubnetResult.cc Normal file
View File

@@ -0,0 +1,66 @@
/*
* 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/CreateSubnetResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Eflo;
using namespace AlibabaCloud::Eflo::Model;
CreateSubnetResult::CreateSubnetResult() :
ServiceResult()
{}
CreateSubnetResult::CreateSubnetResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateSubnetResult::~CreateSubnetResult()
{}
void CreateSubnetResult::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["SubnetId"].isNull())
content_.subnetId = contentNode["SubnetId"].asString();
if(!value["Code"].isNull())
code_ = std::stoi(value["Code"].asString());
if(!value["Message"].isNull())
message_ = value["Message"].asString();
}
std::string CreateSubnetResult::getMessage()const
{
return message_;
}
CreateSubnetResult::Content CreateSubnetResult::getContent()const
{
return content_;
}
int CreateSubnetResult::getCode()const
{
return code_;
}

108
eflo/src/model/CreateVccRequest.cc Normal file
View File

@@ -0,0 +1,108 @@
/*
* 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/CreateVccRequest.h>
using AlibabaCloud::Eflo::Model::CreateVccRequest;
CreateVccRequest::CreateVccRequest()
: RpcServiceRequest("eflo", "2022-05-30", "CreateVcc") {
setMethod(HttpRequest::Method::Post);
}
CreateVccRequest::~CreateVccRequest() {}
std::string CreateVccRequest::getBgpCidr() const {
return bgpCidr_;
}
void CreateVccRequest::setBgpCidr(const std::string &bgpCidr) {
bgpCidr_ = bgpCidr;
setBodyParameter(std::string("BgpCidr"), bgpCidr);
}
std::string CreateVccRequest::getCenId() const {
return cenId_;
}
void CreateVccRequest::setCenId(const std::string &cenId) {
cenId_ = cenId;
setBodyParameter(std::string("CenId"), cenId);
}
std::string CreateVccRequest::getDescription() const {
return description_;
}
void CreateVccRequest::setDescription(const std::string &description) {
description_ = description;
setBodyParameter(std::string("Description"), description);
}
bool CreateVccRequest::getAccessCouldService() const {
return accessCouldService_;
}
void CreateVccRequest::setAccessCouldService(bool accessCouldService) {
accessCouldService_ = accessCouldService;
setBodyParameter(std::string("AccessCouldService"), accessCouldService ? "true" : "false");
}
std::string CreateVccRequest::getRegionId() const {
return regionId_;
}
void CreateVccRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setBodyParameter(std::string("RegionId"), regionId);
}
std::string CreateVccRequest::getVccId() const {
return vccId_;
}
void CreateVccRequest::setVccId(const std::string &vccId) {
vccId_ = vccId;
setBodyParameter(std::string("VccId"), vccId);
}
std::string CreateVccRequest::getVSwitchId() const {
return vSwitchId_;
}
void CreateVccRequest::setVSwitchId(const std::string &vSwitchId) {
vSwitchId_ = vSwitchId;
setBodyParameter(std::string("VSwitchId"), vSwitchId);
}
std::string CreateVccRequest::getVpdId() const {
return vpdId_;
}
void CreateVccRequest::setVpdId(const std::string &vpdId) {
vpdId_ = vpdId;
setBodyParameter(std::string("VpdId"), vpdId);
}
std::string CreateVccRequest::getVpcId() const {
return vpcId_;
}
void CreateVccRequest::setVpcId(const std::string &vpcId) {
vpcId_ = vpcId;
setBodyParameter(std::string("VpcId"), vpcId);
}

66
eflo/src/model/CreateVccResult.cc Normal file
View File

@@ -0,0 +1,66 @@
/*
* 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/CreateVccResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Eflo;
using namespace AlibabaCloud::Eflo::Model;
CreateVccResult::CreateVccResult() :
ServiceResult()
{}
CreateVccResult::CreateVccResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateVccResult::~CreateVccResult()
{}
void CreateVccResult::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["VccId"].isNull())
content_.vccId = contentNode["VccId"].asString();
if(!value["Code"].isNull())
code_ = std::stoi(value["Code"].asString());
if(!value["Message"].isNull())
message_ = value["Message"].asString();
}
std::string CreateVccResult::getMessage()const
{
return message_;
}
CreateVccResult::Content CreateVccResult::getContent()const
{
return content_;
}
int CreateVccResult::getCode()const
{
return code_;
}

71
eflo/src/model/CreateVpdRequest.cc Normal file
View File

@@ -0,0 +1,71 @@
/*
* 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/CreateVpdRequest.h>
using AlibabaCloud::Eflo::Model::CreateVpdRequest;
CreateVpdRequest::CreateVpdRequest()
: RpcServiceRequest("eflo", "2022-05-30", "CreateVpd") {
setMethod(HttpRequest::Method::Post);
}
CreateVpdRequest::~CreateVpdRequest() {}
std::string CreateVpdRequest::getRegionId() const {
return regionId_;
}
void CreateVpdRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setBodyParameter(std::string("RegionId"), regionId);
}
std::string CreateVpdRequest::getName() const {
return name_;
}
void CreateVpdRequest::setName(const std::string &name) {
name_ = name;
setBodyParameter(std::string("Name"), name);
}
std::string CreateVpdRequest::getCidr() const {
return cidr_;
}
void CreateVpdRequest::setCidr(const std::string &cidr) {
cidr_ = cidr;
setBodyParameter(std::string("Cidr"), cidr);
}
std::vector<CreateVpdRequest::Subnets> CreateVpdRequest::getSubnets() const {
return subnets_;
}
void CreateVpdRequest::setSubnets(const std::vector<CreateVpdRequest::Subnets> &subnets) {
subnets_ = subnets;
for(int dep1 = 0; dep1 != subnets.size(); dep1++) {
auto subnetsObj = subnets.at(dep1);
std::string subnetsObjStr = std::string("Subnets") + "." + std::to_string(dep1 + 1);
setBodyParameter(subnetsObjStr + ".RegionId", subnetsObj.regionId);
setBodyParameter(subnetsObjStr + ".Name", subnetsObj.name);
setBodyParameter(subnetsObjStr + ".ZoneId", subnetsObj.zoneId);
setBodyParameter(subnetsObjStr + ".Cidr", subnetsObj.cidr);
setBodyParameter(subnetsObjStr + ".Type", subnetsObj.type);
}
}

69
eflo/src/model/CreateVpdResult.cc Normal file
View File

@@ -0,0 +1,69 @@
/*
* 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/CreateVpdResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Eflo;
using namespace AlibabaCloud::Eflo::Model;
CreateVpdResult::CreateVpdResult() :
ServiceResult()
{}
CreateVpdResult::CreateVpdResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateVpdResult::~CreateVpdResult()
{}
void CreateVpdResult::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["VpdId"].isNull())
content_.vpdId = contentNode["VpdId"].asString();
auto allSubnetIds = contentNode["SubnetIds"]["SubnetId"];
for (auto value : allSubnetIds)
content_.subnetIds.push_back(value.asString());
if(!value["Code"].isNull())
code_ = std::stoi(value["Code"].asString());
if(!value["Message"].isNull())
message_ = value["Message"].asString();
}
std::string CreateVpdResult::getMessage()const
{
return message_;
}
CreateVpdResult::Content CreateVpdResult::getContent()const
{
return content_;
}
int CreateVpdResult::getCode()const
{
return code_;
}

63
eflo/src/model/DeleteSubnetRequest.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/DeleteSubnetRequest.h>
using AlibabaCloud::Eflo::Model::DeleteSubnetRequest;
DeleteSubnetRequest::DeleteSubnetRequest()
: RpcServiceRequest("eflo", "2022-05-30", "DeleteSubnet") {
setMethod(HttpRequest::Method::Post);
}
DeleteSubnetRequest::~DeleteSubnetRequest() {}
std::string DeleteSubnetRequest::getSubnetId() const {
return subnetId_;
}
void DeleteSubnetRequest::setSubnetId(const std::string &subnetId) {
subnetId_ = subnetId;
setBodyParameter(std::string("SubnetId"), subnetId);
}
std::string DeleteSubnetRequest::getRegionId() const {
return regionId_;
}
void DeleteSubnetRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setBodyParameter(std::string("RegionId"), regionId);
}
std::string DeleteSubnetRequest::getVpdId() const {
return vpdId_;
}
void DeleteSubnetRequest::setVpdId(const std::string &vpdId) {
vpdId_ = vpdId;
setBodyParameter(std::string("VpdId"), vpdId);
}
std::string DeleteSubnetRequest::getZoneId() const {
return zoneId_;
}
void DeleteSubnetRequest::setZoneId(const std::string &zoneId) {
zoneId_ = zoneId;
setBodyParameter(std::string("ZoneId"), zoneId);
}

44
eflo/src/model/DeleteSubnetResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* 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/DeleteSubnetResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Eflo;
using namespace AlibabaCloud::Eflo::Model;
DeleteSubnetResult::DeleteSubnetResult() :
ServiceResult()
{}
DeleteSubnetResult::DeleteSubnetResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteSubnetResult::~DeleteSubnetResult()
{}
void DeleteSubnetResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

45
eflo/src/model/DeleteVpdRequest.cc Normal file
View File

@@ -0,0 +1,45 @@
/*
* 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/DeleteVpdRequest.h>
using AlibabaCloud::Eflo::Model::DeleteVpdRequest;
DeleteVpdRequest::DeleteVpdRequest()
: RpcServiceRequest("eflo", "2022-05-30", "DeleteVpd") {
setMethod(HttpRequest::Method::Post);
}
DeleteVpdRequest::~DeleteVpdRequest() {}
std::string DeleteVpdRequest::getRegionId() const {
return regionId_;
}
void DeleteVpdRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setBodyParameter(std::string("RegionId"), regionId);
}
std::string DeleteVpdRequest::getVpdId() const {
return vpdId_;
}
void DeleteVpdRequest::setVpdId(const std::string &vpdId) {
vpdId_ = vpdId;
setBodyParameter(std::string("VpdId"), vpdId);
}

44
eflo/src/model/DeleteVpdResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* 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/DeleteVpdResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Eflo;
using namespace AlibabaCloud::Eflo::Model;
DeleteVpdResult::DeleteVpdResult() :
ServiceResult()
{}
DeleteVpdResult::DeleteVpdResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteVpdResult::~DeleteVpdResult()
{}
void DeleteVpdResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

36
eflo/src/model/GetSubnetRequest.cc Normal file
View File

@@ -0,0 +1,36 @@
/*
* 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/GetSubnetRequest.h>
using AlibabaCloud::Eflo::Model::GetSubnetRequest;
GetSubnetRequest::GetSubnetRequest()
: RpcServiceRequest("eflo", "2022-05-30", "GetSubnet") {
setMethod(HttpRequest::Method::Post);
}
GetSubnetRequest::~GetSubnetRequest() {}
std::string GetSubnetRequest::getSubnetId() const {
return subnetId_;
}
void GetSubnetRequest::setSubnetId(const std::string &subnetId) {
subnetId_ = subnetId;
setBodyParameter(std::string("SubnetId"), subnetId);
}

105
eflo/src/model/GetSubnetResult.cc Normal file
View File

@@ -0,0 +1,105 @@
/*
* 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/GetSubnetResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Eflo;
using namespace AlibabaCloud::Eflo::Model;
GetSubnetResult::GetSubnetResult() :
ServiceResult()
{}
GetSubnetResult::GetSubnetResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetSubnetResult::~GetSubnetResult()
{}
void GetSubnetResult::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["Id"].isNull())
content_.id = std::stol(contentNode["Id"].asString());
if(!contentNode["GmtCreate"].isNull())
content_.gmtCreate = contentNode["GmtCreate"].asString();
if(!contentNode["GmtModified"].isNull())
content_.gmtModified = contentNode["GmtModified"].asString();
if(!contentNode["TenantId"].isNull())
content_.tenantId = contentNode["TenantId"].asString();
if(!contentNode["RegionId"].isNull())
content_.regionId = contentNode["RegionId"].asString();
if(!contentNode["ZoneId"].isNull())
content_.zoneId = contentNode["ZoneId"].asString();
if(!contentNode["SubnetId"].isNull())
content_.subnetId = contentNode["SubnetId"].asString();
if(!contentNode["Name"].isNull())
content_.name = contentNode["Name"].asString();
if(!contentNode["Cidr"].isNull())
content_.cidr = contentNode["Cidr"].asString();
if(!contentNode["Description"].isNull())
content_.description = contentNode["Description"].asString();
if(!contentNode["VpdId"].isNull())
content_.vpdId = contentNode["VpdId"].asString();
if(!contentNode["Type"].isNull())
content_.type = contentNode["Type"].asString();
if(!contentNode["Status"].isNull())
content_.status = contentNode["Status"].asString();
if(!contentNode["Message"].isNull())
content_.message = contentNode["Message"].asString();
if(!contentNode["NcCount"].isNull())
content_.ncCount = std::stol(contentNode["NcCount"].asString());
if(!contentNode["LbCount"].isNull())
content_.lbCount = std::stol(contentNode["LbCount"].asString());
auto vpdBaseInfoNode = contentNode["VpdBaseInfo"];
if(!vpdBaseInfoNode["VpdId"].isNull())
content_.vpdBaseInfo.vpdId = vpdBaseInfoNode["VpdId"].asString();
if(!vpdBaseInfoNode["Name"].isNull())
content_.vpdBaseInfo.name = vpdBaseInfoNode["Name"].asString();
if(!vpdBaseInfoNode["Cidr"].isNull())
content_.vpdBaseInfo.cidr = vpdBaseInfoNode["Cidr"].asString();
if(!vpdBaseInfoNode["GmtCreate"].isNull())
content_.vpdBaseInfo.gmtCreate = vpdBaseInfoNode["GmtCreate"].asString();
if(!value["Code"].isNull())
code_ = std::stoi(value["Code"].asString());
if(!value["Message"].isNull())
message_ = value["Message"].asString();
}
std::string GetSubnetResult::getMessage()const
{
return message_;
}
GetSubnetResult::Content GetSubnetResult::getContent()const
{
return content_;
}
int GetSubnetResult::getCode()const
{
return code_;
}

45
eflo/src/model/GetVccRequest.cc Normal file
View File

@@ -0,0 +1,45 @@
/*
* 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/GetVccRequest.h>
using AlibabaCloud::Eflo::Model::GetVccRequest;
GetVccRequest::GetVccRequest()
: RpcServiceRequest("eflo", "2022-05-30", "GetVcc") {
setMethod(HttpRequest::Method::Post);
}
GetVccRequest::~GetVccRequest() {}
std::string GetVccRequest::getRegionId() const {
return regionId_;
}
void GetVccRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setBodyParameter(std::string("RegionId"), regionId);
}
std::string GetVccRequest::getVccId() const {
return vccId_;
}
void GetVccRequest::setVccId(const std::string &vccId) {
vccId_ = vccId;
setBodyParameter(std::string("VccId"), vccId);
}

165
eflo/src/model/GetVccResult.cc Normal file
View File

@@ -0,0 +1,165 @@
/*
* 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/GetVccResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Eflo;
using namespace AlibabaCloud::Eflo::Model;
GetVccResult::GetVccResult() :
ServiceResult()
{}
GetVccResult::GetVccResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetVccResult::~GetVccResult()
{}
void GetVccResult::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["TenantId"].isNull())
content_.tenantId = contentNode["TenantId"].asString();
if(!contentNode["RegionId"].isNull())
content_.regionId = contentNode["RegionId"].asString();
if(!contentNode["VccId"].isNull())
content_.vccId = contentNode["VccId"].asString();
if(!contentNode["VpdId"].isNull())
content_.vpdId = contentNode["VpdId"].asString();
if(!contentNode["VpcId"].isNull())
content_.vpcId = contentNode["VpcId"].asString();
if(!contentNode["VSwitchId"].isNull())
content_.vSwitchId = contentNode["VSwitchId"].asString();
if(!contentNode["CenId"].isNull())
content_.cenId = contentNode["CenId"].asString();
if(!contentNode["VccName"].isNull())
content_.vccName = contentNode["VccName"].asString();
if(!contentNode["AccessPointId"].isNull())
content_.accessPointId = contentNode["AccessPointId"].asString();
if(!contentNode["LineOperator"].isNull())
content_.lineOperator = contentNode["LineOperator"].asString();
if(!contentNode["Spec"].isNull())
content_.spec = contentNode["Spec"].asString();
if(!contentNode["PortType"].isNull())
content_.portType = contentNode["PortType"].asString();
if(!contentNode["PricingCycle"].isNull())
content_.pricingCycle = contentNode["PricingCycle"].asString();
if(!contentNode["PayType"].isNull())
content_.payType = contentNode["PayType"].asString();
if(!contentNode["Duration"].isNull())
content_.duration = contentNode["Duration"].asString();
if(!contentNode["Status"].isNull())
content_.status = contentNode["Status"].asString();
if(!contentNode["CurrentNode"].isNull())
content_.currentNode = contentNode["CurrentNode"].asString();
if(!contentNode["InternetChargeType"].isNull())
content_.internetChargeType = contentNode["InternetChargeType"].asString();
if(!contentNode["BandwidthStr"].isNull())
content_.bandwidthStr = contentNode["BandwidthStr"].asString();
if(!contentNode["Message"].isNull())
content_.message = contentNode["Message"].asString();
if(!contentNode["CreateTime"].isNull())
content_.createTime = contentNode["CreateTime"].asString();
if(!contentNode["GmtModified"].isNull())
content_.gmtModified = contentNode["GmtModified"].asString();
if(!contentNode["CommodityCode"].isNull())
content_.commodityCode = contentNode["CommodityCode"].asString();
if(!contentNode["BgpCidr"].isNull())
content_.bgpCidr = contentNode["BgpCidr"].asString();
auto allAliyunRouterInfoNode = contentNode["AliyunRouterInfo"]["AliyunRouterInfoItem"];
for (auto contentNodeAliyunRouterInfoAliyunRouterInfoItem : allAliyunRouterInfoNode)
{
Content::AliyunRouterInfoItem aliyunRouterInfoItemObject;
if(!contentNodeAliyunRouterInfoAliyunRouterInfoItem["PcId"].isNull())
aliyunRouterInfoItemObject.pcId = contentNodeAliyunRouterInfoAliyunRouterInfoItem["PcId"].asString();
if(!contentNodeAliyunRouterInfoAliyunRouterInfoItem["VbrId"].isNull())
aliyunRouterInfoItemObject.vbrId = contentNodeAliyunRouterInfoAliyunRouterInfoItem["VbrId"].asString();
if(!contentNodeAliyunRouterInfoAliyunRouterInfoItem["LocalGatewayIp"].isNull())
aliyunRouterInfoItemObject.localGatewayIp = contentNodeAliyunRouterInfoAliyunRouterInfoItem["LocalGatewayIp"].asString();
if(!contentNodeAliyunRouterInfoAliyunRouterInfoItem["PeerGatewayIp"].isNull())
aliyunRouterInfoItemObject.peerGatewayIp = contentNodeAliyunRouterInfoAliyunRouterInfoItem["PeerGatewayIp"].asString();
if(!contentNodeAliyunRouterInfoAliyunRouterInfoItem["Mask"].isNull())
aliyunRouterInfoItemObject.mask = contentNodeAliyunRouterInfoAliyunRouterInfoItem["Mask"].asString();
if(!contentNodeAliyunRouterInfoAliyunRouterInfoItem["VlanId"].isNull())
aliyunRouterInfoItemObject.vlanId = contentNodeAliyunRouterInfoAliyunRouterInfoItem["VlanId"].asString();
content_.aliyunRouterInfo.push_back(aliyunRouterInfoItemObject);
}
auto allCisRouterInfoNode = contentNode["CisRouterInfo"]["CisRouterInfoItem"];
for (auto contentNodeCisRouterInfoCisRouterInfoItem : allCisRouterInfoNode)
{
Content::CisRouterInfoItem cisRouterInfoItemObject;
if(!contentNodeCisRouterInfoCisRouterInfoItem["CcrId"].isNull())
cisRouterInfoItemObject.ccrId = contentNodeCisRouterInfoCisRouterInfoItem["CcrId"].asString();
auto allCcInfosNode = contentNodeCisRouterInfoCisRouterInfoItem["CcInfos"]["CcInfo"];
for (auto contentNodeCisRouterInfoCisRouterInfoItemCcInfosCcInfo : allCcInfosNode)
{
Content::CisRouterInfoItem::CcInfo ccInfosObject;
if(!contentNodeCisRouterInfoCisRouterInfoItemCcInfosCcInfo["CcId"].isNull())
ccInfosObject.ccId = contentNodeCisRouterInfoCisRouterInfoItemCcInfosCcInfo["CcId"].asString();
if(!contentNodeCisRouterInfoCisRouterInfoItemCcInfosCcInfo["VlanId"].isNull())
ccInfosObject.vlanId = contentNodeCisRouterInfoCisRouterInfoItemCcInfosCcInfo["VlanId"].asString();
if(!contentNodeCisRouterInfoCisRouterInfoItemCcInfosCcInfo["LocalGatewayIp"].isNull())
ccInfosObject.localGatewayIp = contentNodeCisRouterInfoCisRouterInfoItemCcInfosCcInfo["LocalGatewayIp"].asString();
if(!contentNodeCisRouterInfoCisRouterInfoItemCcInfosCcInfo["RemoteGatewayIp"].isNull())
ccInfosObject.remoteGatewayIp = contentNodeCisRouterInfoCisRouterInfoItemCcInfosCcInfo["RemoteGatewayIp"].asString();
if(!contentNodeCisRouterInfoCisRouterInfoItemCcInfosCcInfo["SubnetMask"].isNull())
ccInfosObject.subnetMask = contentNodeCisRouterInfoCisRouterInfoItemCcInfosCcInfo["SubnetMask"].asString();
if(!contentNodeCisRouterInfoCisRouterInfoItemCcInfosCcInfo["Status"].isNull())
ccInfosObject.status = contentNodeCisRouterInfoCisRouterInfoItemCcInfosCcInfo["Status"].asString();
cisRouterInfoItemObject.ccInfos.push_back(ccInfosObject);
}
content_.cisRouterInfo.push_back(cisRouterInfoItemObject);
}
auto vpdBaseInfoNode = contentNode["VpdBaseInfo"];
if(!vpdBaseInfoNode["VpdId"].isNull())
content_.vpdBaseInfo.vpdId = vpdBaseInfoNode["VpdId"].asString();
if(!vpdBaseInfoNode["Name"].isNull())
content_.vpdBaseInfo.name = vpdBaseInfoNode["Name"].asString();
if(!vpdBaseInfoNode["Cidr"].isNull())
content_.vpdBaseInfo.cidr = vpdBaseInfoNode["Cidr"].asString();
if(!vpdBaseInfoNode["GmtCreate"].isNull())
content_.vpdBaseInfo.gmtCreate = vpdBaseInfoNode["GmtCreate"].asString();
if(!value["Code"].isNull())
code_ = std::stoi(value["Code"].asString());
if(!value["Message"].isNull())
message_ = value["Message"].asString();
}
std::string GetVccResult::getMessage()const
{
return message_;
}
GetVccResult::Content GetVccResult::getContent()const
{
return content_;
}
int GetVccResult::getCode()const
{
return code_;
}

36
eflo/src/model/GetVpdRequest.cc Normal file
View File

@@ -0,0 +1,36 @@
/*
* 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/GetVpdRequest.h>
using AlibabaCloud::Eflo::Model::GetVpdRequest;
GetVpdRequest::GetVpdRequest()
: RpcServiceRequest("eflo", "2022-05-30", "GetVpd") {
setMethod(HttpRequest::Method::Post);
}
GetVpdRequest::~GetVpdRequest() {}
std::string GetVpdRequest::getVpdId() const {
return vpdId_;
}
void GetVpdRequest::setVpdId(const std::string &vpdId) {
vpdId_ = vpdId;
setBodyParameter(std::string("VpdId"), vpdId);
}

94
eflo/src/model/GetVpdResult.cc Normal file
View File

@@ -0,0 +1,94 @@
/*
* 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/GetVpdResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Eflo;
using namespace AlibabaCloud::Eflo::Model;
GetVpdResult::GetVpdResult() :
ServiceResult()
{}
GetVpdResult::GetVpdResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetVpdResult::~GetVpdResult()
{}
void GetVpdResult::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["RegionId"].isNull())
content_.regionId = contentNode["RegionId"].asString();
if(!contentNode["VpdId"].isNull())
content_.vpdId = contentNode["VpdId"].asString();
if(!contentNode["Name"].isNull())
content_.name = contentNode["Name"].asString();
if(!contentNode["Cidr"].isNull())
content_.cidr = contentNode["Cidr"].asString();
if(!contentNode["ServiceCidr"].isNull())
content_.serviceCidr = contentNode["ServiceCidr"].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(!contentNode["Route"].isNull())
content_.route = std::stoi(contentNode["Route"].asString());
if(!contentNode["NcCount"].isNull())
content_.ncCount = std::stol(contentNode["NcCount"].asString());
if(!contentNode["SubnetCount"].isNull())
content_.subnetCount = std::stol(contentNode["SubnetCount"].asString());
if(!contentNode["LbCount"].isNull())
content_.lbCount = std::stol(contentNode["LbCount"].asString());
if(!contentNode["VccCount"].isNull())
content_.vccCount = std::stol(contentNode["VccCount"].asString());
if(!contentNode["GmtCreate"].isNull())
content_.gmtCreate = contentNode["GmtCreate"].asString();
if(!contentNode["GmtModified"].isNull())
content_.gmtModified = contentNode["GmtModified"].asString();
if(!value["Code"].isNull())
code_ = std::stoi(value["Code"].asString());
if(!value["Message"].isNull())
message_ = value["Message"].asString();
}
std::string GetVpdResult::getMessage()const
{
return message_;
}
GetVpdResult::Content GetVpdResult::getContent()const
{
return content_;
}
int GetVpdResult::getCode()const
{
return code_;
}

27
eflo/src/model/InitializeVccRequest.cc Normal file
View File

@@ -0,0 +1,27 @@
/*
* 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/InitializeVccRequest.h>
using AlibabaCloud::Eflo::Model::InitializeVccRequest;
InitializeVccRequest::InitializeVccRequest()
: RpcServiceRequest("eflo", "2022-05-30", "InitializeVcc") {
setMethod(HttpRequest::Method::Post);
}
InitializeVccRequest::~InitializeVccRequest() {}

68
eflo/src/model/InitializeVccResult.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/InitializeVccResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Eflo;
using namespace AlibabaCloud::Eflo::Model;
InitializeVccResult::InitializeVccResult() :
ServiceResult()
{}
InitializeVccResult::InitializeVccResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
InitializeVccResult::~InitializeVccResult()
{}
void InitializeVccResult::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["RoleName"].isNull())
content_.roleName = contentNode["RoleName"].asString();
if(!contentNode["RequestId"].isNull())
content_.requestId = contentNode["RequestId"].asString();
if(!value["Code"].isNull())
code_ = std::stoi(value["Code"].asString());
if(!value["Message"].isNull())
message_ = value["Message"].asString();
}
std::string InitializeVccResult::getMessage()const
{
return message_;
}
InitializeVccResult::Content InitializeVccResult::getContent()const
{
return content_;
}
int InitializeVccResult::getCode()const
{
return code_;
}

117
eflo/src/model/ListSubnetsRequest.cc Normal file
View File

@@ -0,0 +1,117 @@
/*
* 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/ListSubnetsRequest.h>
using AlibabaCloud::Eflo::Model::ListSubnetsRequest;
ListSubnetsRequest::ListSubnetsRequest()
: RpcServiceRequest("eflo", "2022-05-30", "ListSubnets") {
setMethod(HttpRequest::Method::Post);
}
ListSubnetsRequest::~ListSubnetsRequest() {}
std::string ListSubnetsRequest::getType() const {
return type_;
}
void ListSubnetsRequest::setType(const std::string &type) {
type_ = type;
setBodyParameter(std::string("Type"), type);
}
int ListSubnetsRequest::getPageNumber() const {
return pageNumber_;
}
void ListSubnetsRequest::setPageNumber(int pageNumber) {
pageNumber_ = pageNumber;
setBodyParameter(std::string("PageNumber"), std::to_string(pageNumber));
}
std::string ListSubnetsRequest::getRegionId() const {
return regionId_;
}
void ListSubnetsRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setBodyParameter(std::string("RegionId"), regionId);
}
int ListSubnetsRequest::getPageSize() const {
return pageSize_;
}
void ListSubnetsRequest::setPageSize(int pageSize) {
pageSize_ = pageSize;
setBodyParameter(std::string("PageSize"), std::to_string(pageSize));
}
std::string ListSubnetsRequest::getSubnetId() const {
return subnetId_;
}
void ListSubnetsRequest::setSubnetId(const std::string &subnetId) {
subnetId_ = subnetId;
setBodyParameter(std::string("SubnetId"), subnetId);
}
std::string ListSubnetsRequest::getVpdId() const {
return vpdId_;
}
void ListSubnetsRequest::setVpdId(const std::string &vpdId) {
vpdId_ = vpdId;
setBodyParameter(std::string("VpdId"), vpdId);
}
bool ListSubnetsRequest::getEnablePage() const {
return enablePage_;
}
void ListSubnetsRequest::setEnablePage(bool enablePage) {
enablePage_ = enablePage;
setBodyParameter(std::string("EnablePage"), enablePage ? "true" : "false");
}
std::string ListSubnetsRequest::getName() const {
return name_;
}
void ListSubnetsRequest::setName(const std::string &name) {
name_ = name;
setBodyParameter(std::string("Name"), name);
}
std::string ListSubnetsRequest::getZoneId() const {
return zoneId_;
}
void ListSubnetsRequest::setZoneId(const std::string &zoneId) {
zoneId_ = zoneId;
setBodyParameter(std::string("ZoneId"), zoneId);
}
std::string ListSubnetsRequest::getStatus() const {
return status_;
}
void ListSubnetsRequest::setStatus(const std::string &status) {
status_ = status;
setBodyParameter(std::string("Status"), status);
}

109
eflo/src/model/ListSubnetsResult.cc Normal file
View File

@@ -0,0 +1,109 @@
/*
* 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/ListSubnetsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Eflo;
using namespace AlibabaCloud::Eflo::Model;
ListSubnetsResult::ListSubnetsResult() :
ServiceResult()
{}
ListSubnetsResult::ListSubnetsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListSubnetsResult::~ListSubnetsResult()
{}
void ListSubnetsResult::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["Id"].isNull())
dataItemObject.id = std::stol(contentNodeDataDataItem["Id"].asString());
if(!contentNodeDataDataItem["GmtCreate"].isNull())
dataItemObject.gmtCreate = contentNodeDataDataItem["GmtCreate"].asString();
if(!contentNodeDataDataItem["GmtModified"].isNull())
dataItemObject.gmtModified = contentNodeDataDataItem["GmtModified"].asString();
if(!contentNodeDataDataItem["TenantId"].isNull())
dataItemObject.tenantId = contentNodeDataDataItem["TenantId"].asString();
if(!contentNodeDataDataItem["RegionId"].isNull())
dataItemObject.regionId = contentNodeDataDataItem["RegionId"].asString();
if(!contentNodeDataDataItem["ZoneId"].isNull())
dataItemObject.zoneId = contentNodeDataDataItem["ZoneId"].asString();
if(!contentNodeDataDataItem["Type"].isNull())
dataItemObject.type = contentNodeDataDataItem["Type"].asString();
if(!contentNodeDataDataItem["SubnetId"].isNull())
dataItemObject.subnetId = contentNodeDataDataItem["SubnetId"].asString();
if(!contentNodeDataDataItem["Name"].isNull())
dataItemObject.name = contentNodeDataDataItem["Name"].asString();
if(!contentNodeDataDataItem["Cidr"].isNull())
dataItemObject.cidr = contentNodeDataDataItem["Cidr"].asString();
if(!contentNodeDataDataItem["VpdId"].isNull())
dataItemObject.vpdId = contentNodeDataDataItem["VpdId"].asString();
if(!contentNodeDataDataItem["Status"].isNull())
dataItemObject.status = contentNodeDataDataItem["Status"].asString();
if(!contentNodeDataDataItem["Message"].isNull())
dataItemObject.message = contentNodeDataDataItem["Message"].asString();
if(!contentNodeDataDataItem["NcCount"].isNull())
dataItemObject.ncCount = std::stol(contentNodeDataDataItem["NcCount"].asString());
auto vpdBaseInfoNode = value["VpdBaseInfo"];
if(!vpdBaseInfoNode["VpdId"].isNull())
dataItemObject.vpdBaseInfo.vpdId = vpdBaseInfoNode["VpdId"].asString();
if(!vpdBaseInfoNode["Name"].isNull())
dataItemObject.vpdBaseInfo.name = vpdBaseInfoNode["Name"].asString();
if(!vpdBaseInfoNode["Cidr"].isNull())
dataItemObject.vpdBaseInfo.cidr = vpdBaseInfoNode["Cidr"].asString();
if(!vpdBaseInfoNode["GmtCreate"].isNull())
dataItemObject.vpdBaseInfo.gmtCreate = vpdBaseInfoNode["GmtCreate"].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 ListSubnetsResult::getMessage()const
{
return message_;
}
ListSubnetsResult::Content ListSubnetsResult::getContent()const
{
return content_;
}
int ListSubnetsResult::getCode()const
{
return code_;
}

126
eflo/src/model/ListVccsRequest.cc Normal file
View File

@@ -0,0 +1,126 @@
/*
* 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/ListVccsRequest.h>
using AlibabaCloud::Eflo::Model::ListVccsRequest;
ListVccsRequest::ListVccsRequest()
: RpcServiceRequest("eflo", "2022-05-30", "ListVccs") {
setMethod(HttpRequest::Method::Post);
}
ListVccsRequest::~ListVccsRequest() {}
std::string ListVccsRequest::getCenId() const {
return cenId_;
}
void ListVccsRequest::setCenId(const std::string &cenId) {
cenId_ = cenId;
setBodyParameter(std::string("CenId"), cenId);
}
int ListVccsRequest::getPageNumber() const {
return pageNumber_;
}
void ListVccsRequest::setPageNumber(int pageNumber) {
pageNumber_ = pageNumber;
setBodyParameter(std::string("PageNumber"), std::to_string(pageNumber));
}
std::string ListVccsRequest::getRegionId() const {
return regionId_;
}
void ListVccsRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setBodyParameter(std::string("RegionId"), regionId);
}
int ListVccsRequest::getPageSize() const {
return pageSize_;
}
void ListVccsRequest::setPageSize(int pageSize) {
pageSize_ = pageSize;
setBodyParameter(std::string("PageSize"), std::to_string(pageSize));
}
std::string ListVccsRequest::getVccId() const {
return vccId_;
}
void ListVccsRequest::setVccId(const std::string &vccId) {
vccId_ = vccId;
setBodyParameter(std::string("VccId"), vccId);
}
int ListVccsRequest::getBandwidth() const {
return bandwidth_;
}
void ListVccsRequest::setBandwidth(int bandwidth) {
bandwidth_ = bandwidth;
setBodyParameter(std::string("Bandwidth"), std::to_string(bandwidth));
}
std::string ListVccsRequest::getExStatus() const {
return exStatus_;
}
void ListVccsRequest::setExStatus(const std::string &exStatus) {
exStatus_ = exStatus;
setBodyParameter(std::string("ExStatus"), exStatus);
}
std::string ListVccsRequest::getVpdId() const {
return vpdId_;
}
void ListVccsRequest::setVpdId(const std::string &vpdId) {
vpdId_ = vpdId;
setBodyParameter(std::string("VpdId"), vpdId);
}
std::string ListVccsRequest::getVpcId() const {
return vpcId_;
}
void ListVccsRequest::setVpcId(const std::string &vpcId) {
vpcId_ = vpcId;
setBodyParameter(std::string("VpcId"), vpcId);
}
bool ListVccsRequest::getEnablePage() const {
return enablePage_;
}
void ListVccsRequest::setEnablePage(bool enablePage) {
enablePage_ = enablePage;
setBodyParameter(std::string("EnablePage"), enablePage ? "true" : "false");
}
std::string ListVccsRequest::getStatus() const {
return status_;
}
void ListVccsRequest::setStatus(const std::string &status) {
status_ = status;
setBodyParameter(std::string("Status"), status);
}

117
eflo/src/model/ListVccsResult.cc Normal file
View File

@@ -0,0 +1,117 @@
/*
* 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/ListVccsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Eflo;
using namespace AlibabaCloud::Eflo::Model;
ListVccsResult::ListVccsResult() :
ServiceResult()
{}
ListVccsResult::ListVccsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListVccsResult::~ListVccsResult()
{}
void ListVccsResult::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["TenantId"].isNull())
dataItemObject.tenantId = contentNodeDataDataItem["TenantId"].asString();
if(!contentNodeDataDataItem["RegionId"].isNull())
dataItemObject.regionId = contentNodeDataDataItem["RegionId"].asString();
if(!contentNodeDataDataItem["VccId"].isNull())
dataItemObject.vccId = contentNodeDataDataItem["VccId"].asString();
if(!contentNodeDataDataItem["VpdId"].isNull())
dataItemObject.vpdId = contentNodeDataDataItem["VpdId"].asString();
if(!contentNodeDataDataItem["VpcId"].isNull())
dataItemObject.vpcId = contentNodeDataDataItem["VpcId"].asString();
if(!contentNodeDataDataItem["CenId"].isNull())
dataItemObject.cenId = contentNodeDataDataItem["CenId"].asString();
if(!contentNodeDataDataItem["VccName"].isNull())
dataItemObject.vccName = contentNodeDataDataItem["VccName"].asString();
if(!contentNodeDataDataItem["AccessPointId"].isNull())
dataItemObject.accessPointId = contentNodeDataDataItem["AccessPointId"].asString();
if(!contentNodeDataDataItem["LineOperator"].isNull())
dataItemObject.lineOperator = contentNodeDataDataItem["LineOperator"].asString();
if(!contentNodeDataDataItem["Spec"].isNull())
dataItemObject.spec = contentNodeDataDataItem["Spec"].asString();
if(!contentNodeDataDataItem["PortType"].isNull())
dataItemObject.portType = contentNodeDataDataItem["PortType"].asString();
if(!contentNodeDataDataItem["Status"].isNull())
dataItemObject.status = contentNodeDataDataItem["Status"].asString();
if(!contentNodeDataDataItem["Message"].isNull())
dataItemObject.message = contentNodeDataDataItem["Message"].asString();
if(!contentNodeDataDataItem["CreateTime"].isNull())
dataItemObject.createTime = contentNodeDataDataItem["CreateTime"].asString();
if(!contentNodeDataDataItem["GmtModified"].isNull())
dataItemObject.gmtModified = contentNodeDataDataItem["GmtModified"].asString();
if(!contentNodeDataDataItem["Rate"].isNull())
dataItemObject.rate = contentNodeDataDataItem["Rate"].asString();
if(!contentNodeDataDataItem["BandwidthStr"].isNull())
dataItemObject.bandwidthStr = contentNodeDataDataItem["BandwidthStr"].asString();
if(!contentNodeDataDataItem["BgpCidr"].isNull())
dataItemObject.bgpCidr = contentNodeDataDataItem["BgpCidr"].asString();
auto vpdBaseInfoNode = value["VpdBaseInfo"];
if(!vpdBaseInfoNode["VpdId"].isNull())
dataItemObject.vpdBaseInfo.vpdId = vpdBaseInfoNode["VpdId"].asString();
if(!vpdBaseInfoNode["Name"].isNull())
dataItemObject.vpdBaseInfo.name = vpdBaseInfoNode["Name"].asString();
if(!vpdBaseInfoNode["Cidr"].isNull())
dataItemObject.vpdBaseInfo.cidr = vpdBaseInfoNode["Cidr"].asString();
if(!vpdBaseInfoNode["GmtCreate"].isNull())
dataItemObject.vpdBaseInfo.gmtCreate = vpdBaseInfoNode["GmtCreate"].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 ListVccsResult::getMessage()const
{
return message_;
}
ListVccsResult::Content ListVccsResult::getContent()const
{
return content_;
}
int ListVccsResult::getCode()const
{
return code_;
}

126
eflo/src/model/ListVpdsRequest.cc Normal file
View File

@@ -0,0 +1,126 @@
/*
* 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/ListVpdsRequest.h>
using AlibabaCloud::Eflo::Model::ListVpdsRequest;
ListVpdsRequest::ListVpdsRequest()
: RpcServiceRequest("eflo", "2022-05-30", "ListVpds") {
setMethod(HttpRequest::Method::Post);
}
ListVpdsRequest::~ListVpdsRequest() {}
int ListVpdsRequest::getPageNumber() const {
return pageNumber_;
}
void ListVpdsRequest::setPageNumber(int pageNumber) {
pageNumber_ = pageNumber;
setBodyParameter(std::string("PageNumber"), std::to_string(pageNumber));
}
bool ListVpdsRequest::getWithDependence() const {
return withDependence_;
}
void ListVpdsRequest::setWithDependence(bool withDependence) {
withDependence_ = withDependence;
setBodyParameter(std::string("WithDependence"), withDependence ? "true" : "false");
}
std::string ListVpdsRequest::getRegionId() const {
return regionId_;
}
void ListVpdsRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setBodyParameter(std::string("RegionId"), regionId);
}
bool ListVpdsRequest::getWithoutVcc() const {
return withoutVcc_;
}
void ListVpdsRequest::setWithoutVcc(bool withoutVcc) {
withoutVcc_ = withoutVcc;
setBodyParameter(std::string("WithoutVcc"), withoutVcc ? "true" : "false");
}
int ListVpdsRequest::getPageSize() const {
return pageSize_;
}
void ListVpdsRequest::setPageSize(int pageSize) {
pageSize_ = pageSize;
setBodyParameter(std::string("PageSize"), std::to_string(pageSize));
}
bool ListVpdsRequest::getForSelect() const {
return forSelect_;
}
void ListVpdsRequest::setForSelect(bool forSelect) {
forSelect_ = forSelect;
setBodyParameter(std::string("ForSelect"), forSelect ? "true" : "false");
}
std::string ListVpdsRequest::getFilterErId() const {
return filterErId_;
}
void ListVpdsRequest::setFilterErId(const std::string &filterErId) {
filterErId_ = filterErId;
setBodyParameter(std::string("FilterErId"), filterErId);
}
std::string ListVpdsRequest::getVpdId() const {
return vpdId_;
}
void ListVpdsRequest::setVpdId(const std::string &vpdId) {
vpdId_ = vpdId;
setBodyParameter(std::string("VpdId"), vpdId);
}
bool ListVpdsRequest::getEnablePage() const {
return enablePage_;
}
void ListVpdsRequest::setEnablePage(bool enablePage) {
enablePage_ = enablePage;
setBodyParameter(std::string("EnablePage"), enablePage ? "true" : "false");
}
std::string ListVpdsRequest::getName() const {
return name_;
}
void ListVpdsRequest::setName(const std::string &name) {
name_ = name;
setBodyParameter(std::string("Name"), name);
}
std::string ListVpdsRequest::getStatus() const {
return status_;
}
void ListVpdsRequest::setStatus(const std::string &status) {
status_ = status;
setBodyParameter(std::string("Status"), status);
}

98
eflo/src/model/ListVpdsResult.cc Normal file
View File

@@ -0,0 +1,98 @@
/*
* 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/ListVpdsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Eflo;
using namespace AlibabaCloud::Eflo::Model;
ListVpdsResult::ListVpdsResult() :
ServiceResult()
{}
ListVpdsResult::ListVpdsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListVpdsResult::~ListVpdsResult()
{}
void ListVpdsResult::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["RegionId"].isNull())
dataItemObject.regionId = contentNodeDataDataItem["RegionId"].asString();
if(!contentNodeDataDataItem["VpdId"].isNull())
dataItemObject.vpdId = contentNodeDataDataItem["VpdId"].asString();
if(!contentNodeDataDataItem["Name"].isNull())
dataItemObject.name = contentNodeDataDataItem["Name"].asString();
if(!contentNodeDataDataItem["Cidr"].isNull())
dataItemObject.cidr = contentNodeDataDataItem["Cidr"].asString();
if(!contentNodeDataDataItem["ServiceCidr"].isNull())
dataItemObject.serviceCidr = contentNodeDataDataItem["ServiceCidr"].asString();
if(!contentNodeDataDataItem["Status"].isNull())
dataItemObject.status = contentNodeDataDataItem["Status"].asString();
if(!contentNodeDataDataItem["Message"].isNull())
dataItemObject.message = contentNodeDataDataItem["Message"].asString();
if(!contentNodeDataDataItem["Route"].isNull())
dataItemObject.route = std::stoi(contentNodeDataDataItem["Route"].asString());
if(!contentNodeDataDataItem["NcCount"].isNull())
dataItemObject.ncCount = std::stoi(contentNodeDataDataItem["NcCount"].asString());
if(!contentNodeDataDataItem["SubnetCount"].isNull())
dataItemObject.subnetCount = std::stoi(contentNodeDataDataItem["SubnetCount"].asString());
if(!contentNodeDataDataItem["GmtCreate"].isNull())
dataItemObject.gmtCreate = contentNodeDataDataItem["GmtCreate"].asString();
if(!contentNodeDataDataItem["GmtModified"].isNull())
dataItemObject.gmtModified = contentNodeDataDataItem["GmtModified"].asString();
if(!contentNodeDataDataItem["Dependence"].isNull())
dataItemObject.dependence = contentNodeDataDataItem["Dependence"].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 ListVpdsResult::getMessage()const
{
return message_;
}
ListVpdsResult::Content ListVpdsResult::getContent()const
{
return content_;
}
int ListVpdsResult::getCode()const
{
return code_;
}

81
eflo/src/model/UpdateSubnetRequest.cc Normal file
View File

@@ -0,0 +1,81 @@
/*
* 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/UpdateSubnetRequest.h>
using AlibabaCloud::Eflo::Model::UpdateSubnetRequest;
UpdateSubnetRequest::UpdateSubnetRequest()
: RpcServiceRequest("eflo", "2022-05-30", "UpdateSubnet") {
setMethod(HttpRequest::Method::Post);
}
UpdateSubnetRequest::~UpdateSubnetRequest() {}
std::string UpdateSubnetRequest::getSubnetId() const {
return subnetId_;
}
void UpdateSubnetRequest::setSubnetId(const std::string &subnetId) {
subnetId_ = subnetId;
setBodyParameter(std::string("SubnetId"), subnetId);
}
std::string UpdateSubnetRequest::getDescription() const {
return description_;
}
void UpdateSubnetRequest::setDescription(const std::string &description) {
description_ = description;
setBodyParameter(std::string("Description"), description);
}
std::string UpdateSubnetRequest::getRegionId() const {
return regionId_;
}
void UpdateSubnetRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setBodyParameter(std::string("RegionId"), regionId);
}
std::string UpdateSubnetRequest::getVpdId() const {
return vpdId_;
}
void UpdateSubnetRequest::setVpdId(const std::string &vpdId) {
vpdId_ = vpdId;
setBodyParameter(std::string("VpdId"), vpdId);
}
std::string UpdateSubnetRequest::getName() const {
return name_;
}
void UpdateSubnetRequest::setName(const std::string &name) {
name_ = name;
setBodyParameter(std::string("Name"), name);
}
std::string UpdateSubnetRequest::getZoneId() const {
return zoneId_;
}
void UpdateSubnetRequest::setZoneId(const std::string &zoneId) {
zoneId_ = zoneId;
setBodyParameter(std::string("ZoneId"), zoneId);
}

66
eflo/src/model/UpdateSubnetResult.cc Normal file
View File

@@ -0,0 +1,66 @@
/*
* 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/UpdateSubnetResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Eflo;
using namespace AlibabaCloud::Eflo::Model;
UpdateSubnetResult::UpdateSubnetResult() :
ServiceResult()
{}
UpdateSubnetResult::UpdateSubnetResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
UpdateSubnetResult::~UpdateSubnetResult()
{}
void UpdateSubnetResult::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["SubnetId"].isNull())
content_.subnetId = contentNode["SubnetId"].asString();
if(!value["Code"].isNull())
code_ = std::stoi(value["Code"].asString());
if(!value["Message"].isNull())
message_ = value["Message"].asString();
}
std::string UpdateSubnetResult::getMessage()const
{
return message_;
}
UpdateSubnetResult::Content UpdateSubnetResult::getContent()const
{
return content_;
}
int UpdateSubnetResult::getCode()const
{
return code_;
}

72
eflo/src/model/UpdateVccRequest.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/UpdateVccRequest.h>
using AlibabaCloud::Eflo::Model::UpdateVccRequest;
UpdateVccRequest::UpdateVccRequest()
: RpcServiceRequest("eflo", "2022-05-30", "UpdateVcc") {
setMethod(HttpRequest::Method::Post);
}
UpdateVccRequest::~UpdateVccRequest() {}
int UpdateVccRequest::getBandwidth() const {
return bandwidth_;
}
void UpdateVccRequest::setBandwidth(int bandwidth) {
bandwidth_ = bandwidth;
setBodyParameter(std::string("Bandwidth"), std::to_string(bandwidth));
}
std::string UpdateVccRequest::getOrderId() const {
return orderId_;
}
void UpdateVccRequest::setOrderId(const std::string &orderId) {
orderId_ = orderId;
setBodyParameter(std::string("OrderId"), orderId);
}
std::string UpdateVccRequest::getVccName() const {
return vccName_;
}
void UpdateVccRequest::setVccName(const std::string &vccName) {
vccName_ = vccName;
setBodyParameter(std::string("VccName"), vccName);
}
std::string UpdateVccRequest::getRegionId() const {
return regionId_;
}
void UpdateVccRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setBodyParameter(std::string("RegionId"), regionId);
}
std::string UpdateVccRequest::getVccId() const {
return vccId_;
}
void UpdateVccRequest::setVccId(const std::string &vccId) {
vccId_ = vccId;
setBodyParameter(std::string("VccId"), vccId);
}

66
eflo/src/model/UpdateVccResult.cc Normal file
View File

@@ -0,0 +1,66 @@
/*
* 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/UpdateVccResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Eflo;
using namespace AlibabaCloud::Eflo::Model;
UpdateVccResult::UpdateVccResult() :
ServiceResult()
{}
UpdateVccResult::UpdateVccResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
UpdateVccResult::~UpdateVccResult()
{}
void UpdateVccResult::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["VccId"].isNull())
content_.vccId = contentNode["VccId"].asString();
if(!value["Code"].isNull())
code_ = std::stoi(value["Code"].asString());
if(!value["Message"].isNull())
message_ = value["Message"].asString();
}
std::string UpdateVccResult::getMessage()const
{
return message_;
}
UpdateVccResult::Content UpdateVccResult::getContent()const
{
return content_;
}
int UpdateVccResult::getCode()const
{
return code_;
}

63
eflo/src/model/UpdateVpdRequest.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/UpdateVpdRequest.h>
using AlibabaCloud::Eflo::Model::UpdateVpdRequest;
UpdateVpdRequest::UpdateVpdRequest()
: RpcServiceRequest("eflo", "2022-05-30", "UpdateVpd") {
setMethod(HttpRequest::Method::Post);
}
UpdateVpdRequest::~UpdateVpdRequest() {}
std::string UpdateVpdRequest::getDescription() const {
return description_;
}
void UpdateVpdRequest::setDescription(const std::string &description) {
description_ = description;
setBodyParameter(std::string("Description"), description);
}
std::string UpdateVpdRequest::getRegionId() const {
return regionId_;
}
void UpdateVpdRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setBodyParameter(std::string("RegionId"), regionId);
}
std::string UpdateVpdRequest::getVpdId() const {
return vpdId_;
}
void UpdateVpdRequest::setVpdId(const std::string &vpdId) {
vpdId_ = vpdId;
setBodyParameter(std::string("VpdId"), vpdId);
}
std::string UpdateVpdRequest::getName() const {
return name_;
}
void UpdateVpdRequest::setName(const std::string &name) {
name_ = name;
setBodyParameter(std::string("Name"), name);
}

66
eflo/src/model/UpdateVpdResult.cc Normal file
View File

@@ -0,0 +1,66 @@
/*
* 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/UpdateVpdResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Eflo;
using namespace AlibabaCloud::Eflo::Model;
UpdateVpdResult::UpdateVpdResult() :
ServiceResult()
{}
UpdateVpdResult::UpdateVpdResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
UpdateVpdResult::~UpdateVpdResult()
{}
void UpdateVpdResult::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["VpdId"].isNull())
content_.vpdId = contentNode["VpdId"].asString();
if(!value["Code"].isNull())
code_ = std::stoi(value["Code"].asString());
if(!value["Message"].isNull())
message_ = value["Message"].asString();
}
std::string UpdateVpdResult::getMessage()const
{
return message_;
}
UpdateVpdResult::Content UpdateVpdResult::getContent()const
{
return content_;
}
int UpdateVpdResult::getCode()const
{
return code_;
}