Remove useless packages

This commit is contained in:
nanhe
2022-12-12 21:01:46 +08:00
parent d4e14749ca
commit 4074a5b52e
136 changed files with 0 additions and 10090 deletions

View File

@@ -1,134 +0,0 @@
#
# 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(amptest_public_header
include/alibabacloud/amptest/AmpTestClient.h
include/alibabacloud/amptest/AmpTestExport.h )
set(amptest_public_header_model
include/alibabacloud/amptest/model/CreateRulesRequest.h
include/alibabacloud/amptest/model/CreateRulesResult.h
include/alibabacloud/amptest/model/HuichengTestGrayRequest.h
include/alibabacloud/amptest/model/HuichengTestGrayResult.h
include/alibabacloud/amptest/model/HuichengTestGrayEightRequest.h
include/alibabacloud/amptest/model/HuichengTestGrayEightResult.h
include/alibabacloud/amptest/model/HuichengTestGrayFifthRequest.h
include/alibabacloud/amptest/model/HuichengTestGrayFifthResult.h
include/alibabacloud/amptest/model/HuichengTestGrayNineRequest.h
include/alibabacloud/amptest/model/HuichengTestGrayNineResult.h
include/alibabacloud/amptest/model/HuichengTestGraySecondRequest.h
include/alibabacloud/amptest/model/HuichengTestGraySecondResult.h
include/alibabacloud/amptest/model/HuichengTestGraySevenRequest.h
include/alibabacloud/amptest/model/HuichengTestGraySevenResult.h
include/alibabacloud/amptest/model/HuichengTestGraySixRequest.h
include/alibabacloud/amptest/model/HuichengTestGraySixResult.h
include/alibabacloud/amptest/model/HuichengTestGrayTenRequest.h
include/alibabacloud/amptest/model/HuichengTestGrayTenResult.h
include/alibabacloud/amptest/model/HuichengTestGrayThirdRequest.h
include/alibabacloud/amptest/model/HuichengTestGrayThirdResult.h
include/alibabacloud/amptest/model/HuichengTestResourceOwnerIdRequest.h
include/alibabacloud/amptest/model/HuichengTestResourceOwnerIdResult.h
include/alibabacloud/amptest/model/HuichengetRequest.h
include/alibabacloud/amptest/model/HuichengetResult.h
include/alibabacloud/amptest/model/HuichengetestRequest.h
include/alibabacloud/amptest/model/HuichengetestResult.h )
set(amptest_src
src/AmpTestClient.cc
src/model/CreateRulesRequest.cc
src/model/CreateRulesResult.cc
src/model/HuichengTestGrayRequest.cc
src/model/HuichengTestGrayResult.cc
src/model/HuichengTestGrayEightRequest.cc
src/model/HuichengTestGrayEightResult.cc
src/model/HuichengTestGrayFifthRequest.cc
src/model/HuichengTestGrayFifthResult.cc
src/model/HuichengTestGrayNineRequest.cc
src/model/HuichengTestGrayNineResult.cc
src/model/HuichengTestGraySecondRequest.cc
src/model/HuichengTestGraySecondResult.cc
src/model/HuichengTestGraySevenRequest.cc
src/model/HuichengTestGraySevenResult.cc
src/model/HuichengTestGraySixRequest.cc
src/model/HuichengTestGraySixResult.cc
src/model/HuichengTestGrayTenRequest.cc
src/model/HuichengTestGrayTenResult.cc
src/model/HuichengTestGrayThirdRequest.cc
src/model/HuichengTestGrayThirdResult.cc
src/model/HuichengTestResourceOwnerIdRequest.cc
src/model/HuichengTestResourceOwnerIdResult.cc
src/model/HuichengetRequest.cc
src/model/HuichengetResult.cc
src/model/HuichengetestRequest.cc
src/model/HuichengetestResult.cc )
add_library(amptest ${LIB_TYPE}
${amptest_public_header}
${amptest_public_header_model}
${amptest_src})
set_target_properties(amptest
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}amptest
)
if(${LIB_TYPE} STREQUAL "SHARED")
set_target_properties(amptest
PROPERTIES
DEFINE_SYMBOL ALIBABACLOUD_AMPTEST_LIBRARY)
endif()
target_include_directories(amptest
PRIVATE include
${CMAKE_SOURCE_DIR}/core/include
)
target_link_libraries(amptest
core)
if(CMAKE_HOST_WIN32)
ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
set(jsoncpp_install_dir ${INSTALL_DIR})
add_dependencies(amptest
jsoncpp)
target_include_directories(amptest
PRIVATE ${jsoncpp_install_dir}/include)
target_link_libraries(amptest
${jsoncpp_install_dir}/lib/jsoncpp.lib)
set_target_properties(amptest
PROPERTIES
COMPILE_OPTIONS "/bigobj")
else()
target_include_directories(amptest
PRIVATE /usr/include/jsoncpp)
target_link_libraries(amptest
jsoncpp)
endif()
install(FILES ${amptest_public_header}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/amptest)
install(FILES ${amptest_public_header_model}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/amptest/model)
install(TARGETS amptest
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)

View File

@@ -1,150 +0,0 @@
/*
* 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_AMPTEST_AMPTESTCLIENT_H_
#define ALIBABACLOUD_AMPTEST_AMPTESTCLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "AmpTestExport.h"
#include "model/CreateRulesRequest.h"
#include "model/CreateRulesResult.h"
#include "model/HuichengTestGrayRequest.h"
#include "model/HuichengTestGrayResult.h"
#include "model/HuichengTestGrayEightRequest.h"
#include "model/HuichengTestGrayEightResult.h"
#include "model/HuichengTestGrayFifthRequest.h"
#include "model/HuichengTestGrayFifthResult.h"
#include "model/HuichengTestGrayNineRequest.h"
#include "model/HuichengTestGrayNineResult.h"
#include "model/HuichengTestGraySecondRequest.h"
#include "model/HuichengTestGraySecondResult.h"
#include "model/HuichengTestGraySevenRequest.h"
#include "model/HuichengTestGraySevenResult.h"
#include "model/HuichengTestGraySixRequest.h"
#include "model/HuichengTestGraySixResult.h"
#include "model/HuichengTestGrayTenRequest.h"
#include "model/HuichengTestGrayTenResult.h"
#include "model/HuichengTestGrayThirdRequest.h"
#include "model/HuichengTestGrayThirdResult.h"
#include "model/HuichengTestResourceOwnerIdRequest.h"
#include "model/HuichengTestResourceOwnerIdResult.h"
#include "model/HuichengetRequest.h"
#include "model/HuichengetResult.h"
#include "model/HuichengetestRequest.h"
#include "model/HuichengetestResult.h"
namespace AlibabaCloud
{
namespace AmpTest
{
class ALIBABACLOUD_AMPTEST_EXPORT AmpTestClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::CreateRulesResult> CreateRulesOutcome;
typedef std::future<CreateRulesOutcome> CreateRulesOutcomeCallable;
typedef std::function<void(const AmpTestClient*, const Model::CreateRulesRequest&, const CreateRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateRulesAsyncHandler;
typedef Outcome<Error, Model::HuichengTestGrayResult> HuichengTestGrayOutcome;
typedef std::future<HuichengTestGrayOutcome> HuichengTestGrayOutcomeCallable;
typedef std::function<void(const AmpTestClient*, const Model::HuichengTestGrayRequest&, const HuichengTestGrayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> HuichengTestGrayAsyncHandler;
typedef Outcome<Error, Model::HuichengTestGrayEightResult> HuichengTestGrayEightOutcome;
typedef std::future<HuichengTestGrayEightOutcome> HuichengTestGrayEightOutcomeCallable;
typedef std::function<void(const AmpTestClient*, const Model::HuichengTestGrayEightRequest&, const HuichengTestGrayEightOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> HuichengTestGrayEightAsyncHandler;
typedef Outcome<Error, Model::HuichengTestGrayFifthResult> HuichengTestGrayFifthOutcome;
typedef std::future<HuichengTestGrayFifthOutcome> HuichengTestGrayFifthOutcomeCallable;
typedef std::function<void(const AmpTestClient*, const Model::HuichengTestGrayFifthRequest&, const HuichengTestGrayFifthOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> HuichengTestGrayFifthAsyncHandler;
typedef Outcome<Error, Model::HuichengTestGrayNineResult> HuichengTestGrayNineOutcome;
typedef std::future<HuichengTestGrayNineOutcome> HuichengTestGrayNineOutcomeCallable;
typedef std::function<void(const AmpTestClient*, const Model::HuichengTestGrayNineRequest&, const HuichengTestGrayNineOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> HuichengTestGrayNineAsyncHandler;
typedef Outcome<Error, Model::HuichengTestGraySecondResult> HuichengTestGraySecondOutcome;
typedef std::future<HuichengTestGraySecondOutcome> HuichengTestGraySecondOutcomeCallable;
typedef std::function<void(const AmpTestClient*, const Model::HuichengTestGraySecondRequest&, const HuichengTestGraySecondOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> HuichengTestGraySecondAsyncHandler;
typedef Outcome<Error, Model::HuichengTestGraySevenResult> HuichengTestGraySevenOutcome;
typedef std::future<HuichengTestGraySevenOutcome> HuichengTestGraySevenOutcomeCallable;
typedef std::function<void(const AmpTestClient*, const Model::HuichengTestGraySevenRequest&, const HuichengTestGraySevenOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> HuichengTestGraySevenAsyncHandler;
typedef Outcome<Error, Model::HuichengTestGraySixResult> HuichengTestGraySixOutcome;
typedef std::future<HuichengTestGraySixOutcome> HuichengTestGraySixOutcomeCallable;
typedef std::function<void(const AmpTestClient*, const Model::HuichengTestGraySixRequest&, const HuichengTestGraySixOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> HuichengTestGraySixAsyncHandler;
typedef Outcome<Error, Model::HuichengTestGrayTenResult> HuichengTestGrayTenOutcome;
typedef std::future<HuichengTestGrayTenOutcome> HuichengTestGrayTenOutcomeCallable;
typedef std::function<void(const AmpTestClient*, const Model::HuichengTestGrayTenRequest&, const HuichengTestGrayTenOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> HuichengTestGrayTenAsyncHandler;
typedef Outcome<Error, Model::HuichengTestGrayThirdResult> HuichengTestGrayThirdOutcome;
typedef std::future<HuichengTestGrayThirdOutcome> HuichengTestGrayThirdOutcomeCallable;
typedef std::function<void(const AmpTestClient*, const Model::HuichengTestGrayThirdRequest&, const HuichengTestGrayThirdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> HuichengTestGrayThirdAsyncHandler;
typedef Outcome<Error, Model::HuichengTestResourceOwnerIdResult> HuichengTestResourceOwnerIdOutcome;
typedef std::future<HuichengTestResourceOwnerIdOutcome> HuichengTestResourceOwnerIdOutcomeCallable;
typedef std::function<void(const AmpTestClient*, const Model::HuichengTestResourceOwnerIdRequest&, const HuichengTestResourceOwnerIdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> HuichengTestResourceOwnerIdAsyncHandler;
typedef Outcome<Error, Model::HuichengetResult> HuichengetOutcome;
typedef std::future<HuichengetOutcome> HuichengetOutcomeCallable;
typedef std::function<void(const AmpTestClient*, const Model::HuichengetRequest&, const HuichengetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> HuichengetAsyncHandler;
typedef Outcome<Error, Model::HuichengetestResult> HuichengetestOutcome;
typedef std::future<HuichengetestOutcome> HuichengetestOutcomeCallable;
typedef std::function<void(const AmpTestClient*, const Model::HuichengetestRequest&, const HuichengetestOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> HuichengetestAsyncHandler;
AmpTestClient(const Credentials &credentials, const ClientConfiguration &configuration);
AmpTestClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
AmpTestClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~AmpTestClient();
CreateRulesOutcome createRules(const Model::CreateRulesRequest &request)const;
void createRulesAsync(const Model::CreateRulesRequest& request, const CreateRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateRulesOutcomeCallable createRulesCallable(const Model::CreateRulesRequest& request) const;
HuichengTestGrayOutcome huichengTestGray(const Model::HuichengTestGrayRequest &request)const;
void huichengTestGrayAsync(const Model::HuichengTestGrayRequest& request, const HuichengTestGrayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
HuichengTestGrayOutcomeCallable huichengTestGrayCallable(const Model::HuichengTestGrayRequest& request) const;
HuichengTestGrayEightOutcome huichengTestGrayEight(const Model::HuichengTestGrayEightRequest &request)const;
void huichengTestGrayEightAsync(const Model::HuichengTestGrayEightRequest& request, const HuichengTestGrayEightAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
HuichengTestGrayEightOutcomeCallable huichengTestGrayEightCallable(const Model::HuichengTestGrayEightRequest& request) const;
HuichengTestGrayFifthOutcome huichengTestGrayFifth(const Model::HuichengTestGrayFifthRequest &request)const;
void huichengTestGrayFifthAsync(const Model::HuichengTestGrayFifthRequest& request, const HuichengTestGrayFifthAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
HuichengTestGrayFifthOutcomeCallable huichengTestGrayFifthCallable(const Model::HuichengTestGrayFifthRequest& request) const;
HuichengTestGrayNineOutcome huichengTestGrayNine(const Model::HuichengTestGrayNineRequest &request)const;
void huichengTestGrayNineAsync(const Model::HuichengTestGrayNineRequest& request, const HuichengTestGrayNineAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
HuichengTestGrayNineOutcomeCallable huichengTestGrayNineCallable(const Model::HuichengTestGrayNineRequest& request) const;
HuichengTestGraySecondOutcome huichengTestGraySecond(const Model::HuichengTestGraySecondRequest &request)const;
void huichengTestGraySecondAsync(const Model::HuichengTestGraySecondRequest& request, const HuichengTestGraySecondAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
HuichengTestGraySecondOutcomeCallable huichengTestGraySecondCallable(const Model::HuichengTestGraySecondRequest& request) const;
HuichengTestGraySevenOutcome huichengTestGraySeven(const Model::HuichengTestGraySevenRequest &request)const;
void huichengTestGraySevenAsync(const Model::HuichengTestGraySevenRequest& request, const HuichengTestGraySevenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
HuichengTestGraySevenOutcomeCallable huichengTestGraySevenCallable(const Model::HuichengTestGraySevenRequest& request) const;
HuichengTestGraySixOutcome huichengTestGraySix(const Model::HuichengTestGraySixRequest &request)const;
void huichengTestGraySixAsync(const Model::HuichengTestGraySixRequest& request, const HuichengTestGraySixAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
HuichengTestGraySixOutcomeCallable huichengTestGraySixCallable(const Model::HuichengTestGraySixRequest& request) const;
HuichengTestGrayTenOutcome huichengTestGrayTen(const Model::HuichengTestGrayTenRequest &request)const;
void huichengTestGrayTenAsync(const Model::HuichengTestGrayTenRequest& request, const HuichengTestGrayTenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
HuichengTestGrayTenOutcomeCallable huichengTestGrayTenCallable(const Model::HuichengTestGrayTenRequest& request) const;
HuichengTestGrayThirdOutcome huichengTestGrayThird(const Model::HuichengTestGrayThirdRequest &request)const;
void huichengTestGrayThirdAsync(const Model::HuichengTestGrayThirdRequest& request, const HuichengTestGrayThirdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
HuichengTestGrayThirdOutcomeCallable huichengTestGrayThirdCallable(const Model::HuichengTestGrayThirdRequest& request) const;
HuichengTestResourceOwnerIdOutcome huichengTestResourceOwnerId(const Model::HuichengTestResourceOwnerIdRequest &request)const;
void huichengTestResourceOwnerIdAsync(const Model::HuichengTestResourceOwnerIdRequest& request, const HuichengTestResourceOwnerIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
HuichengTestResourceOwnerIdOutcomeCallable huichengTestResourceOwnerIdCallable(const Model::HuichengTestResourceOwnerIdRequest& request) const;
HuichengetOutcome huichenget(const Model::HuichengetRequest &request)const;
void huichengetAsync(const Model::HuichengetRequest& request, const HuichengetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
HuichengetOutcomeCallable huichengetCallable(const Model::HuichengetRequest& request) const;
HuichengetestOutcome huichengetest(const Model::HuichengetestRequest &request)const;
void huichengetestAsync(const Model::HuichengetestRequest& request, const HuichengetestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
HuichengetestOutcomeCallable huichengetestCallable(const Model::HuichengetestRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_AMPTEST_AMPTESTCLIENT_H_

View File

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

View File

@@ -1,80 +0,0 @@
/*
* 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_AMPTEST_MODEL_CREATERULESREQUEST_H_
#define ALIBABACLOUD_AMPTEST_MODEL_CREATERULESREQUEST_H_
#include <alibabacloud/amptest/AmpTestExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace AmpTest {
namespace Model {
class ALIBABACLOUD_AMPTEST_EXPORT CreateRulesRequest : public RpcServiceRequest {
public:
struct Home {
struct Address {
struct T {
std::string _class;
};
T t;
struct Location {
long late;
long lon;
};
Location location;
std::string detail;
};
Address address;
struct T {
std::string _class;
};
T t;
std::string string;
std::vector<std::string> phoneNumbers;
struct DMapItem {
struct Location {
long late;
long lon;
};
Location location;
std::string detail;
};
DMapItem dMapItem;
std::map<std::string, DMapItem> dMap;
std::map<std::string, int> nameToAge;
struct LocationsItem {
long late;
long lon;
};
LocationsItem locationsItem;
std::vector<LocationsItem> locations;
};
CreateRulesRequest();
~CreateRulesRequest();
Home getHome() const;
void setHome(const Home &home);
private:
Home home_;
};
} // namespace Model
} // namespace AmpTest
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AMPTEST_MODEL_CREATERULESREQUEST_H_

View File

@@ -1,53 +0,0 @@
/*
* 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_AMPTEST_MODEL_CREATERULESRESULT_H_
#define ALIBABACLOUD_AMPTEST_MODEL_CREATERULESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/amptest/AmpTestExport.h>
namespace AlibabaCloud
{
namespace AmpTest
{
namespace Model
{
class ALIBABACLOUD_AMPTEST_EXPORT CreateRulesResult : public ServiceResult
{
public:
CreateRulesResult();
explicit CreateRulesResult(const std::string &payload);
~CreateRulesResult();
int getSize()const;
std::string getValue()const;
protected:
void parse(const std::string &payload);
private:
int size_;
std::string value_;
};
}
}
}
#endif // !ALIBABACLOUD_AMPTEST_MODEL_CREATERULESRESULT_H_

View File

@@ -1,80 +0,0 @@
/*
* 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_AMPTEST_MODEL_HUICHENGTESTGRAYEIGHTREQUEST_H_
#define ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYEIGHTREQUEST_H_
#include <alibabacloud/amptest/AmpTestExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace AmpTest {
namespace Model {
class ALIBABACLOUD_AMPTEST_EXPORT HuichengTestGrayEightRequest : public RpcServiceRequest {
public:
struct Home {
struct Address {
struct T {
std::string _class;
};
T t;
struct Location {
long late;
long lon;
};
Location location;
std::string detail;
};
Address address;
struct T {
std::string _class;
};
T t;
std::string string;
std::vector<std::string> phoneNumbers;
struct DMapItem {
struct Location {
long late;
long lon;
};
Location location;
std::string detail;
};
DMapItem dMapItem;
std::map<std::string, DMapItem> dMap;
std::map<std::string, int> nameToAge;
struct LocationsItem {
long late;
long lon;
};
LocationsItem locationsItem;
std::vector<LocationsItem> locations;
};
HuichengTestGrayEightRequest();
~HuichengTestGrayEightRequest();
Home getHome() const;
void setHome(const Home &home);
private:
Home home_;
};
} // namespace Model
} // namespace AmpTest
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYEIGHTREQUEST_H_

View File

@@ -1,53 +0,0 @@
/*
* 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_AMPTEST_MODEL_HUICHENGTESTGRAYEIGHTRESULT_H_
#define ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYEIGHTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/amptest/AmpTestExport.h>
namespace AlibabaCloud
{
namespace AmpTest
{
namespace Model
{
class ALIBABACLOUD_AMPTEST_EXPORT HuichengTestGrayEightResult : public ServiceResult
{
public:
HuichengTestGrayEightResult();
explicit HuichengTestGrayEightResult(const std::string &payload);
~HuichengTestGrayEightResult();
int getSize()const;
std::string getValue()const;
protected:
void parse(const std::string &payload);
private:
int size_;
std::string value_;
};
}
}
}
#endif // !ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYEIGHTRESULT_H_

View File

@@ -1,80 +0,0 @@
/*
* 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_AMPTEST_MODEL_HUICHENGTESTGRAYFIFTHREQUEST_H_
#define ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYFIFTHREQUEST_H_
#include <alibabacloud/amptest/AmpTestExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace AmpTest {
namespace Model {
class ALIBABACLOUD_AMPTEST_EXPORT HuichengTestGrayFifthRequest : public RpcServiceRequest {
public:
struct Home {
struct Address {
struct T {
std::string _class;
};
T t;
struct Location {
long late;
long lon;
};
Location location;
std::string detail;
};
Address address;
struct T {
std::string _class;
};
T t;
std::string string;
std::vector<std::string> phoneNumbers;
struct DMapItem {
struct Location {
long late;
long lon;
};
Location location;
std::string detail;
};
DMapItem dMapItem;
std::map<std::string, DMapItem> dMap;
std::map<std::string, int> nameToAge;
struct LocationsItem {
long late;
long lon;
};
LocationsItem locationsItem;
std::vector<LocationsItem> locations;
};
HuichengTestGrayFifthRequest();
~HuichengTestGrayFifthRequest();
Home getHome() const;
void setHome(const Home &home);
private:
Home home_;
};
} // namespace Model
} // namespace AmpTest
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYFIFTHREQUEST_H_

View File

@@ -1,53 +0,0 @@
/*
* 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_AMPTEST_MODEL_HUICHENGTESTGRAYFIFTHRESULT_H_
#define ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYFIFTHRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/amptest/AmpTestExport.h>
namespace AlibabaCloud
{
namespace AmpTest
{
namespace Model
{
class ALIBABACLOUD_AMPTEST_EXPORT HuichengTestGrayFifthResult : public ServiceResult
{
public:
HuichengTestGrayFifthResult();
explicit HuichengTestGrayFifthResult(const std::string &payload);
~HuichengTestGrayFifthResult();
int getSize()const;
std::string getValue()const;
protected:
void parse(const std::string &payload);
private:
int size_;
std::string value_;
};
}
}
}
#endif // !ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYFIFTHRESULT_H_

View File

@@ -1,80 +0,0 @@
/*
* 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_AMPTEST_MODEL_HUICHENGTESTGRAYNINEREQUEST_H_
#define ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYNINEREQUEST_H_
#include <alibabacloud/amptest/AmpTestExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace AmpTest {
namespace Model {
class ALIBABACLOUD_AMPTEST_EXPORT HuichengTestGrayNineRequest : public RpcServiceRequest {
public:
struct Home {
struct Address {
struct T {
std::string _class;
};
T t;
struct Location {
long late;
long lon;
};
Location location;
std::string detail;
};
Address address;
struct T {
std::string _class;
};
T t;
std::string string;
std::vector<std::string> phoneNumbers;
struct DMapItem {
struct Location {
long late;
long lon;
};
Location location;
std::string detail;
};
DMapItem dMapItem;
std::map<std::string, DMapItem> dMap;
std::map<std::string, int> nameToAge;
struct LocationsItem {
long late;
long lon;
};
LocationsItem locationsItem;
std::vector<LocationsItem> locations;
};
HuichengTestGrayNineRequest();
~HuichengTestGrayNineRequest();
Home getHome() const;
void setHome(const Home &home);
private:
Home home_;
};
} // namespace Model
} // namespace AmpTest
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYNINEREQUEST_H_

View File

@@ -1,53 +0,0 @@
/*
* 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_AMPTEST_MODEL_HUICHENGTESTGRAYNINERESULT_H_
#define ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYNINERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/amptest/AmpTestExport.h>
namespace AlibabaCloud
{
namespace AmpTest
{
namespace Model
{
class ALIBABACLOUD_AMPTEST_EXPORT HuichengTestGrayNineResult : public ServiceResult
{
public:
HuichengTestGrayNineResult();
explicit HuichengTestGrayNineResult(const std::string &payload);
~HuichengTestGrayNineResult();
int getSize()const;
std::string getValue()const;
protected:
void parse(const std::string &payload);
private:
int size_;
std::string value_;
};
}
}
}
#endif // !ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYNINERESULT_H_

View File

@@ -1,80 +0,0 @@
/*
* 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_AMPTEST_MODEL_HUICHENGTESTGRAYREQUEST_H_
#define ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYREQUEST_H_
#include <alibabacloud/amptest/AmpTestExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace AmpTest {
namespace Model {
class ALIBABACLOUD_AMPTEST_EXPORT HuichengTestGrayRequest : public RpcServiceRequest {
public:
struct Home {
struct Address {
struct T {
std::string _class;
};
T t;
struct Location {
long late;
long lon;
};
Location location;
std::string detail;
};
Address address;
struct T {
std::string _class;
};
T t;
std::string string;
std::vector<std::string> phoneNumbers;
struct DMapItem {
struct Location {
long late;
long lon;
};
Location location;
std::string detail;
};
DMapItem dMapItem;
std::map<std::string, DMapItem> dMap;
std::map<std::string, int> nameToAge;
struct LocationsItem {
long late;
long lon;
};
LocationsItem locationsItem;
std::vector<LocationsItem> locations;
};
HuichengTestGrayRequest();
~HuichengTestGrayRequest();
Home getHome() const;
void setHome(const Home &home);
private:
Home home_;
};
} // namespace Model
} // namespace AmpTest
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYREQUEST_H_

View File

@@ -1,53 +0,0 @@
/*
* 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_AMPTEST_MODEL_HUICHENGTESTGRAYRESULT_H_
#define ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/amptest/AmpTestExport.h>
namespace AlibabaCloud
{
namespace AmpTest
{
namespace Model
{
class ALIBABACLOUD_AMPTEST_EXPORT HuichengTestGrayResult : public ServiceResult
{
public:
HuichengTestGrayResult();
explicit HuichengTestGrayResult(const std::string &payload);
~HuichengTestGrayResult();
int getSize()const;
std::string getValue()const;
protected:
void parse(const std::string &payload);
private:
int size_;
std::string value_;
};
}
}
}
#endif // !ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYRESULT_H_

View File

@@ -1,80 +0,0 @@
/*
* 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_AMPTEST_MODEL_HUICHENGTESTGRAYSECONDREQUEST_H_
#define ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYSECONDREQUEST_H_
#include <alibabacloud/amptest/AmpTestExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace AmpTest {
namespace Model {
class ALIBABACLOUD_AMPTEST_EXPORT HuichengTestGraySecondRequest : public RpcServiceRequest {
public:
struct Home {
struct Address {
struct T {
std::string _class;
};
T t;
struct Location {
long late;
long lon;
};
Location location;
std::string detail;
};
Address address;
struct T {
std::string _class;
};
T t;
std::string string;
std::vector<std::string> phoneNumbers;
struct DMapItem {
struct Location {
long late;
long lon;
};
Location location;
std::string detail;
};
DMapItem dMapItem;
std::map<std::string, DMapItem> dMap;
std::map<std::string, int> nameToAge;
struct LocationsItem {
long late;
long lon;
};
LocationsItem locationsItem;
std::vector<LocationsItem> locations;
};
HuichengTestGraySecondRequest();
~HuichengTestGraySecondRequest();
Home getHome() const;
void setHome(const Home &home);
private:
Home home_;
};
} // namespace Model
} // namespace AmpTest
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYSECONDREQUEST_H_

View File

@@ -1,53 +0,0 @@
/*
* 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_AMPTEST_MODEL_HUICHENGTESTGRAYSECONDRESULT_H_
#define ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYSECONDRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/amptest/AmpTestExport.h>
namespace AlibabaCloud
{
namespace AmpTest
{
namespace Model
{
class ALIBABACLOUD_AMPTEST_EXPORT HuichengTestGraySecondResult : public ServiceResult
{
public:
HuichengTestGraySecondResult();
explicit HuichengTestGraySecondResult(const std::string &payload);
~HuichengTestGraySecondResult();
int getSize()const;
std::string getValue()const;
protected:
void parse(const std::string &payload);
private:
int size_;
std::string value_;
};
}
}
}
#endif // !ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYSECONDRESULT_H_

View File

@@ -1,80 +0,0 @@
/*
* 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_AMPTEST_MODEL_HUICHENGTESTGRAYSEVENREQUEST_H_
#define ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYSEVENREQUEST_H_
#include <alibabacloud/amptest/AmpTestExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace AmpTest {
namespace Model {
class ALIBABACLOUD_AMPTEST_EXPORT HuichengTestGraySevenRequest : public RpcServiceRequest {
public:
struct Home {
struct Address {
struct T {
std::string _class;
};
T t;
struct Location {
long late;
long lon;
};
Location location;
std::string detail;
};
Address address;
struct T {
std::string _class;
};
T t;
std::string string;
std::vector<std::string> phoneNumbers;
struct DMapItem {
struct Location {
long late;
long lon;
};
Location location;
std::string detail;
};
DMapItem dMapItem;
std::map<std::string, DMapItem> dMap;
std::map<std::string, int> nameToAge;
struct LocationsItem {
long late;
long lon;
};
LocationsItem locationsItem;
std::vector<LocationsItem> locations;
};
HuichengTestGraySevenRequest();
~HuichengTestGraySevenRequest();
Home getHome() const;
void setHome(const Home &home);
private:
Home home_;
};
} // namespace Model
} // namespace AmpTest
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYSEVENREQUEST_H_

View File

@@ -1,53 +0,0 @@
/*
* 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_AMPTEST_MODEL_HUICHENGTESTGRAYSEVENRESULT_H_
#define ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYSEVENRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/amptest/AmpTestExport.h>
namespace AlibabaCloud
{
namespace AmpTest
{
namespace Model
{
class ALIBABACLOUD_AMPTEST_EXPORT HuichengTestGraySevenResult : public ServiceResult
{
public:
HuichengTestGraySevenResult();
explicit HuichengTestGraySevenResult(const std::string &payload);
~HuichengTestGraySevenResult();
int getSize()const;
std::string getValue()const;
protected:
void parse(const std::string &payload);
private:
int size_;
std::string value_;
};
}
}
}
#endif // !ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYSEVENRESULT_H_

View File

@@ -1,80 +0,0 @@
/*
* 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_AMPTEST_MODEL_HUICHENGTESTGRAYSIXREQUEST_H_
#define ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYSIXREQUEST_H_
#include <alibabacloud/amptest/AmpTestExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace AmpTest {
namespace Model {
class ALIBABACLOUD_AMPTEST_EXPORT HuichengTestGraySixRequest : public RpcServiceRequest {
public:
struct Home {
struct Address {
struct T {
std::string _class;
};
T t;
struct Location {
long late;
long lon;
};
Location location;
std::string detail;
};
Address address;
struct T {
std::string _class;
};
T t;
std::string string;
std::vector<std::string> phoneNumbers;
struct DMapItem {
struct Location {
long late;
long lon;
};
Location location;
std::string detail;
};
DMapItem dMapItem;
std::map<std::string, DMapItem> dMap;
std::map<std::string, int> nameToAge;
struct LocationsItem {
long late;
long lon;
};
LocationsItem locationsItem;
std::vector<LocationsItem> locations;
};
HuichengTestGraySixRequest();
~HuichengTestGraySixRequest();
Home getHome() const;
void setHome(const Home &home);
private:
Home home_;
};
} // namespace Model
} // namespace AmpTest
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYSIXREQUEST_H_

View File

@@ -1,53 +0,0 @@
/*
* 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_AMPTEST_MODEL_HUICHENGTESTGRAYSIXRESULT_H_
#define ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYSIXRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/amptest/AmpTestExport.h>
namespace AlibabaCloud
{
namespace AmpTest
{
namespace Model
{
class ALIBABACLOUD_AMPTEST_EXPORT HuichengTestGraySixResult : public ServiceResult
{
public:
HuichengTestGraySixResult();
explicit HuichengTestGraySixResult(const std::string &payload);
~HuichengTestGraySixResult();
int getSize()const;
std::string getValue()const;
protected:
void parse(const std::string &payload);
private:
int size_;
std::string value_;
};
}
}
}
#endif // !ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYSIXRESULT_H_

View File

@@ -1,80 +0,0 @@
/*
* 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_AMPTEST_MODEL_HUICHENGTESTGRAYTENREQUEST_H_
#define ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYTENREQUEST_H_
#include <alibabacloud/amptest/AmpTestExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace AmpTest {
namespace Model {
class ALIBABACLOUD_AMPTEST_EXPORT HuichengTestGrayTenRequest : public RpcServiceRequest {
public:
struct Home {
struct Address {
struct T {
std::string _class;
};
T t;
struct Location {
long late;
long lon;
};
Location location;
std::string detail;
};
Address address;
struct T {
std::string _class;
};
T t;
std::string string;
std::vector<std::string> phoneNumbers;
struct DMapItem {
struct Location {
long late;
long lon;
};
Location location;
std::string detail;
};
DMapItem dMapItem;
std::map<std::string, DMapItem> dMap;
std::map<std::string, int> nameToAge;
struct LocationsItem {
long late;
long lon;
};
LocationsItem locationsItem;
std::vector<LocationsItem> locations;
};
HuichengTestGrayTenRequest();
~HuichengTestGrayTenRequest();
Home getHome() const;
void setHome(const Home &home);
private:
Home home_;
};
} // namespace Model
} // namespace AmpTest
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYTENREQUEST_H_

View File

@@ -1,53 +0,0 @@
/*
* 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_AMPTEST_MODEL_HUICHENGTESTGRAYTENRESULT_H_
#define ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYTENRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/amptest/AmpTestExport.h>
namespace AlibabaCloud
{
namespace AmpTest
{
namespace Model
{
class ALIBABACLOUD_AMPTEST_EXPORT HuichengTestGrayTenResult : public ServiceResult
{
public:
HuichengTestGrayTenResult();
explicit HuichengTestGrayTenResult(const std::string &payload);
~HuichengTestGrayTenResult();
int getSize()const;
std::string getValue()const;
protected:
void parse(const std::string &payload);
private:
int size_;
std::string value_;
};
}
}
}
#endif // !ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYTENRESULT_H_

View File

@@ -1,80 +0,0 @@
/*
* 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_AMPTEST_MODEL_HUICHENGTESTGRAYTHIRDREQUEST_H_
#define ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYTHIRDREQUEST_H_
#include <alibabacloud/amptest/AmpTestExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace AmpTest {
namespace Model {
class ALIBABACLOUD_AMPTEST_EXPORT HuichengTestGrayThirdRequest : public RpcServiceRequest {
public:
struct Home {
struct Address {
struct T {
std::string _class;
};
T t;
struct Location {
long late;
long lon;
};
Location location;
std::string detail;
};
Address address;
struct T {
std::string _class;
};
T t;
std::string string;
std::vector<std::string> phoneNumbers;
struct DMapItem {
struct Location {
long late;
long lon;
};
Location location;
std::string detail;
};
DMapItem dMapItem;
std::map<std::string, DMapItem> dMap;
std::map<std::string, int> nameToAge;
struct LocationsItem {
long late;
long lon;
};
LocationsItem locationsItem;
std::vector<LocationsItem> locations;
};
HuichengTestGrayThirdRequest();
~HuichengTestGrayThirdRequest();
Home getHome() const;
void setHome(const Home &home);
private:
Home home_;
};
} // namespace Model
} // namespace AmpTest
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYTHIRDREQUEST_H_

View File

@@ -1,53 +0,0 @@
/*
* 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_AMPTEST_MODEL_HUICHENGTESTGRAYTHIRDRESULT_H_
#define ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYTHIRDRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/amptest/AmpTestExport.h>
namespace AlibabaCloud
{
namespace AmpTest
{
namespace Model
{
class ALIBABACLOUD_AMPTEST_EXPORT HuichengTestGrayThirdResult : public ServiceResult
{
public:
HuichengTestGrayThirdResult();
explicit HuichengTestGrayThirdResult(const std::string &payload);
~HuichengTestGrayThirdResult();
int getSize()const;
std::string getValue()const;
protected:
void parse(const std::string &payload);
private:
int size_;
std::string value_;
};
}
}
}
#endif // !ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTGRAYTHIRDRESULT_H_

View File

@@ -1,39 +0,0 @@
/*
* 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_AMPTEST_MODEL_HUICHENGTESTRESOURCEOWNERIDREQUEST_H_
#define ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTRESOURCEOWNERIDREQUEST_H_
#include <alibabacloud/amptest/AmpTestExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace AmpTest {
namespace Model {
class ALIBABACLOUD_AMPTEST_EXPORT HuichengTestResourceOwnerIdRequest : public RpcServiceRequest {
public:
HuichengTestResourceOwnerIdRequest();
~HuichengTestResourceOwnerIdRequest();
private:
};
} // namespace Model
} // namespace AmpTest
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTRESOURCEOWNERIDREQUEST_H_

View File

@@ -1,49 +0,0 @@
/*
* 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_AMPTEST_MODEL_HUICHENGTESTRESOURCEOWNERIDRESULT_H_
#define ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTRESOURCEOWNERIDRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/amptest/AmpTestExport.h>
namespace AlibabaCloud
{
namespace AmpTest
{
namespace Model
{
class ALIBABACLOUD_AMPTEST_EXPORT HuichengTestResourceOwnerIdResult : public ServiceResult
{
public:
HuichengTestResourceOwnerIdResult();
explicit HuichengTestResourceOwnerIdResult(const std::string &payload);
~HuichengTestResourceOwnerIdResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_AMPTEST_MODEL_HUICHENGTESTRESOURCEOWNERIDRESULT_H_

View File

@@ -1,93 +0,0 @@
/*
* 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_AMPTEST_MODEL_HUICHENGETREQUEST_H_
#define ALIBABACLOUD_AMPTEST_MODEL_HUICHENGETREQUEST_H_
#include <alibabacloud/amptest/AmpTestExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace AmpTest {
namespace Model {
class ALIBABACLOUD_AMPTEST_EXPORT HuichengetRequest : public RpcServiceRequest {
public:
HuichengetRequest();
~HuichengetRequest();
std::string getAdd() const;
void setAdd(const std::string &add);
std::string getAddress() const;
void setAddress(const std::string &address);
std::string getSix() const;
void setSix(const std::string &six);
std::string getEnight() const;
void setEnight(const std::string &enight);
std::string getNewName() const;
void setNewName(const std::string &newName);
std::string getList() const;
void setList(const std::string &list);
std::string getTwo() const;
void setTwo(const std::string &two);
std::string getThree() const;
void setThree(const std::string &three);
std::string getNigh() const;
void setNigh(const std::string &nigh);
std::string getRed() const;
void setRed(const std::string &red);
std::string getApple() const;
void setApple(const std::string &apple);
std::string getTea() const;
void setTea(const std::string &tea);
std::string getBlue() const;
void setBlue(const std::string &blue);
std::string getWhite() const;
void setWhite(const std::string &white);
std::string getFour() const;
void setFour(const std::string &four);
std::string getNow() const;
void setNow(const std::string &now);
std::string getTen() const;
void setTen(const std::string &ten);
std::string getFive() const;
void setFive(const std::string &five);
private:
std::string add_;
std::string address_;
std::string six_;
std::string enight_;
std::string newName_;
std::string list_;
std::string two_;
std::string three_;
std::string nigh_;
std::string red_;
std::string apple_;
std::string tea_;
std::string blue_;
std::string white_;
std::string four_;
std::string now_;
std::string ten_;
std::string five_;
};
} // namespace Model
} // namespace AmpTest
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AMPTEST_MODEL_HUICHENGETREQUEST_H_

View File

@@ -1,65 +0,0 @@
/*
* 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_AMPTEST_MODEL_HUICHENGETRESULT_H_
#define ALIBABACLOUD_AMPTEST_MODEL_HUICHENGETRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/amptest/AmpTestExport.h>
namespace AlibabaCloud
{
namespace AmpTest
{
namespace Model
{
class ALIBABACLOUD_AMPTEST_EXPORT HuichengetResult : public ServiceResult
{
public:
HuichengetResult();
explicit HuichengetResult(const std::string &payload);
~HuichengetResult();
std::string getApple()const;
std::string getFive()const;
std::string getSix()const;
std::string getMessage()const;
std::string getInstanceId4()const;
std::string getSeven()const;
std::string getCode()const;
std::string getAge()const;
protected:
void parse(const std::string &payload);
private:
std::string apple_;
std::string five_;
std::string six_;
std::string message_;
std::string instanceId4_;
std::string seven_;
std::string code_;
std::string age_;
};
}
}
}
#endif // !ALIBABACLOUD_AMPTEST_MODEL_HUICHENGETRESULT_H_

View File

@@ -1,39 +0,0 @@
/*
* 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_AMPTEST_MODEL_HUICHENGETESTREQUEST_H_
#define ALIBABACLOUD_AMPTEST_MODEL_HUICHENGETESTREQUEST_H_
#include <alibabacloud/amptest/AmpTestExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace AmpTest {
namespace Model {
class ALIBABACLOUD_AMPTEST_EXPORT HuichengetestRequest : public RpcServiceRequest {
public:
HuichengetestRequest();
~HuichengetestRequest();
private:
};
} // namespace Model
} // namespace AmpTest
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_AMPTEST_MODEL_HUICHENGETESTREQUEST_H_

View File

@@ -1,49 +0,0 @@
/*
* 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_AMPTEST_MODEL_HUICHENGETESTRESULT_H_
#define ALIBABACLOUD_AMPTEST_MODEL_HUICHENGETESTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/amptest/AmpTestExport.h>
namespace AlibabaCloud
{
namespace AmpTest
{
namespace Model
{
class ALIBABACLOUD_AMPTEST_EXPORT HuichengetestResult : public ServiceResult
{
public:
HuichengetestResult();
explicit HuichengetestResult(const std::string &payload);
~HuichengetestResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_AMPTEST_MODEL_HUICHENGETESTRESULT_H_

View File

@@ -1,521 +0,0 @@
/*
* 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/amptest/AmpTestClient.h>
#include <alibabacloud/core/SimpleCredentialsProvider.h>
using namespace AlibabaCloud;
using namespace AlibabaCloud::Location;
using namespace AlibabaCloud::AmpTest;
using namespace AlibabaCloud::AmpTest::Model;
namespace
{
const std::string SERVICE_NAME = "AmpTest";
}
AmpTestClient::AmpTestClient(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, "AmpTest");
}
AmpTestClient::AmpTestClient(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, "AmpTest");
}
AmpTestClient::AmpTestClient(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, "AmpTest");
}
AmpTestClient::~AmpTestClient()
{}
AmpTestClient::CreateRulesOutcome AmpTestClient::createRules(const CreateRulesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateRulesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateRulesOutcome(CreateRulesResult(outcome.result()));
else
return CreateRulesOutcome(outcome.error());
}
void AmpTestClient::createRulesAsync(const CreateRulesRequest& request, const CreateRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createRules(request), context);
};
asyncExecute(new Runnable(fn));
}
AmpTestClient::CreateRulesOutcomeCallable AmpTestClient::createRulesCallable(const CreateRulesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateRulesOutcome()>>(
[this, request]()
{
return this->createRules(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
AmpTestClient::HuichengTestGrayOutcome AmpTestClient::huichengTestGray(const HuichengTestGrayRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return HuichengTestGrayOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return HuichengTestGrayOutcome(HuichengTestGrayResult(outcome.result()));
else
return HuichengTestGrayOutcome(outcome.error());
}
void AmpTestClient::huichengTestGrayAsync(const HuichengTestGrayRequest& request, const HuichengTestGrayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, huichengTestGray(request), context);
};
asyncExecute(new Runnable(fn));
}
AmpTestClient::HuichengTestGrayOutcomeCallable AmpTestClient::huichengTestGrayCallable(const HuichengTestGrayRequest &request) const
{
auto task = std::make_shared<std::packaged_task<HuichengTestGrayOutcome()>>(
[this, request]()
{
return this->huichengTestGray(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
AmpTestClient::HuichengTestGrayEightOutcome AmpTestClient::huichengTestGrayEight(const HuichengTestGrayEightRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return HuichengTestGrayEightOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return HuichengTestGrayEightOutcome(HuichengTestGrayEightResult(outcome.result()));
else
return HuichengTestGrayEightOutcome(outcome.error());
}
void AmpTestClient::huichengTestGrayEightAsync(const HuichengTestGrayEightRequest& request, const HuichengTestGrayEightAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, huichengTestGrayEight(request), context);
};
asyncExecute(new Runnable(fn));
}
AmpTestClient::HuichengTestGrayEightOutcomeCallable AmpTestClient::huichengTestGrayEightCallable(const HuichengTestGrayEightRequest &request) const
{
auto task = std::make_shared<std::packaged_task<HuichengTestGrayEightOutcome()>>(
[this, request]()
{
return this->huichengTestGrayEight(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
AmpTestClient::HuichengTestGrayFifthOutcome AmpTestClient::huichengTestGrayFifth(const HuichengTestGrayFifthRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return HuichengTestGrayFifthOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return HuichengTestGrayFifthOutcome(HuichengTestGrayFifthResult(outcome.result()));
else
return HuichengTestGrayFifthOutcome(outcome.error());
}
void AmpTestClient::huichengTestGrayFifthAsync(const HuichengTestGrayFifthRequest& request, const HuichengTestGrayFifthAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, huichengTestGrayFifth(request), context);
};
asyncExecute(new Runnable(fn));
}
AmpTestClient::HuichengTestGrayFifthOutcomeCallable AmpTestClient::huichengTestGrayFifthCallable(const HuichengTestGrayFifthRequest &request) const
{
auto task = std::make_shared<std::packaged_task<HuichengTestGrayFifthOutcome()>>(
[this, request]()
{
return this->huichengTestGrayFifth(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
AmpTestClient::HuichengTestGrayNineOutcome AmpTestClient::huichengTestGrayNine(const HuichengTestGrayNineRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return HuichengTestGrayNineOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return HuichengTestGrayNineOutcome(HuichengTestGrayNineResult(outcome.result()));
else
return HuichengTestGrayNineOutcome(outcome.error());
}
void AmpTestClient::huichengTestGrayNineAsync(const HuichengTestGrayNineRequest& request, const HuichengTestGrayNineAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, huichengTestGrayNine(request), context);
};
asyncExecute(new Runnable(fn));
}
AmpTestClient::HuichengTestGrayNineOutcomeCallable AmpTestClient::huichengTestGrayNineCallable(const HuichengTestGrayNineRequest &request) const
{
auto task = std::make_shared<std::packaged_task<HuichengTestGrayNineOutcome()>>(
[this, request]()
{
return this->huichengTestGrayNine(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
AmpTestClient::HuichengTestGraySecondOutcome AmpTestClient::huichengTestGraySecond(const HuichengTestGraySecondRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return HuichengTestGraySecondOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return HuichengTestGraySecondOutcome(HuichengTestGraySecondResult(outcome.result()));
else
return HuichengTestGraySecondOutcome(outcome.error());
}
void AmpTestClient::huichengTestGraySecondAsync(const HuichengTestGraySecondRequest& request, const HuichengTestGraySecondAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, huichengTestGraySecond(request), context);
};
asyncExecute(new Runnable(fn));
}
AmpTestClient::HuichengTestGraySecondOutcomeCallable AmpTestClient::huichengTestGraySecondCallable(const HuichengTestGraySecondRequest &request) const
{
auto task = std::make_shared<std::packaged_task<HuichengTestGraySecondOutcome()>>(
[this, request]()
{
return this->huichengTestGraySecond(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
AmpTestClient::HuichengTestGraySevenOutcome AmpTestClient::huichengTestGraySeven(const HuichengTestGraySevenRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return HuichengTestGraySevenOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return HuichengTestGraySevenOutcome(HuichengTestGraySevenResult(outcome.result()));
else
return HuichengTestGraySevenOutcome(outcome.error());
}
void AmpTestClient::huichengTestGraySevenAsync(const HuichengTestGraySevenRequest& request, const HuichengTestGraySevenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, huichengTestGraySeven(request), context);
};
asyncExecute(new Runnable(fn));
}
AmpTestClient::HuichengTestGraySevenOutcomeCallable AmpTestClient::huichengTestGraySevenCallable(const HuichengTestGraySevenRequest &request) const
{
auto task = std::make_shared<std::packaged_task<HuichengTestGraySevenOutcome()>>(
[this, request]()
{
return this->huichengTestGraySeven(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
AmpTestClient::HuichengTestGraySixOutcome AmpTestClient::huichengTestGraySix(const HuichengTestGraySixRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return HuichengTestGraySixOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return HuichengTestGraySixOutcome(HuichengTestGraySixResult(outcome.result()));
else
return HuichengTestGraySixOutcome(outcome.error());
}
void AmpTestClient::huichengTestGraySixAsync(const HuichengTestGraySixRequest& request, const HuichengTestGraySixAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, huichengTestGraySix(request), context);
};
asyncExecute(new Runnable(fn));
}
AmpTestClient::HuichengTestGraySixOutcomeCallable AmpTestClient::huichengTestGraySixCallable(const HuichengTestGraySixRequest &request) const
{
auto task = std::make_shared<std::packaged_task<HuichengTestGraySixOutcome()>>(
[this, request]()
{
return this->huichengTestGraySix(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
AmpTestClient::HuichengTestGrayTenOutcome AmpTestClient::huichengTestGrayTen(const HuichengTestGrayTenRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return HuichengTestGrayTenOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return HuichengTestGrayTenOutcome(HuichengTestGrayTenResult(outcome.result()));
else
return HuichengTestGrayTenOutcome(outcome.error());
}
void AmpTestClient::huichengTestGrayTenAsync(const HuichengTestGrayTenRequest& request, const HuichengTestGrayTenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, huichengTestGrayTen(request), context);
};
asyncExecute(new Runnable(fn));
}
AmpTestClient::HuichengTestGrayTenOutcomeCallable AmpTestClient::huichengTestGrayTenCallable(const HuichengTestGrayTenRequest &request) const
{
auto task = std::make_shared<std::packaged_task<HuichengTestGrayTenOutcome()>>(
[this, request]()
{
return this->huichengTestGrayTen(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
AmpTestClient::HuichengTestGrayThirdOutcome AmpTestClient::huichengTestGrayThird(const HuichengTestGrayThirdRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return HuichengTestGrayThirdOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return HuichengTestGrayThirdOutcome(HuichengTestGrayThirdResult(outcome.result()));
else
return HuichengTestGrayThirdOutcome(outcome.error());
}
void AmpTestClient::huichengTestGrayThirdAsync(const HuichengTestGrayThirdRequest& request, const HuichengTestGrayThirdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, huichengTestGrayThird(request), context);
};
asyncExecute(new Runnable(fn));
}
AmpTestClient::HuichengTestGrayThirdOutcomeCallable AmpTestClient::huichengTestGrayThirdCallable(const HuichengTestGrayThirdRequest &request) const
{
auto task = std::make_shared<std::packaged_task<HuichengTestGrayThirdOutcome()>>(
[this, request]()
{
return this->huichengTestGrayThird(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
AmpTestClient::HuichengTestResourceOwnerIdOutcome AmpTestClient::huichengTestResourceOwnerId(const HuichengTestResourceOwnerIdRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return HuichengTestResourceOwnerIdOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return HuichengTestResourceOwnerIdOutcome(HuichengTestResourceOwnerIdResult(outcome.result()));
else
return HuichengTestResourceOwnerIdOutcome(outcome.error());
}
void AmpTestClient::huichengTestResourceOwnerIdAsync(const HuichengTestResourceOwnerIdRequest& request, const HuichengTestResourceOwnerIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, huichengTestResourceOwnerId(request), context);
};
asyncExecute(new Runnable(fn));
}
AmpTestClient::HuichengTestResourceOwnerIdOutcomeCallable AmpTestClient::huichengTestResourceOwnerIdCallable(const HuichengTestResourceOwnerIdRequest &request) const
{
auto task = std::make_shared<std::packaged_task<HuichengTestResourceOwnerIdOutcome()>>(
[this, request]()
{
return this->huichengTestResourceOwnerId(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
AmpTestClient::HuichengetOutcome AmpTestClient::huichenget(const HuichengetRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return HuichengetOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return HuichengetOutcome(HuichengetResult(outcome.result()));
else
return HuichengetOutcome(outcome.error());
}
void AmpTestClient::huichengetAsync(const HuichengetRequest& request, const HuichengetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, huichenget(request), context);
};
asyncExecute(new Runnable(fn));
}
AmpTestClient::HuichengetOutcomeCallable AmpTestClient::huichengetCallable(const HuichengetRequest &request) const
{
auto task = std::make_shared<std::packaged_task<HuichengetOutcome()>>(
[this, request]()
{
return this->huichenget(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
AmpTestClient::HuichengetestOutcome AmpTestClient::huichengetest(const HuichengetestRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return HuichengetestOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return HuichengetestOutcome(HuichengetestResult(outcome.result()));
else
return HuichengetestOutcome(outcome.error());
}
void AmpTestClient::huichengetestAsync(const HuichengetestRequest& request, const HuichengetestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, huichengetest(request), context);
};
asyncExecute(new Runnable(fn));
}
AmpTestClient::HuichengetestOutcomeCallable AmpTestClient::huichengetestCallable(const HuichengetestRequest &request) const
{
auto task = std::make_shared<std::packaged_task<HuichengetestOutcome()>>(
[this, request]()
{
return this->huichengetest(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}

View File

@@ -1,55 +0,0 @@
/*
* 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/amptest/model/CreateRulesRequest.h>
using AlibabaCloud::AmpTest::Model::CreateRulesRequest;
CreateRulesRequest::CreateRulesRequest()
: RpcServiceRequest("amptest", "2020-12-30", "CreateRules") {
setMethod(HttpRequest::Method::Post);
}
CreateRulesRequest::~CreateRulesRequest() {}
CreateRulesRequest::Home CreateRulesRequest::getHome() const {
return home_;
}
void CreateRulesRequest::setHome(const CreateRulesRequest::Home &home) {
home_ = home;
setParameter(std::string("Home") + ".Address.T.Class", home.address.t._class);
setParameter(std::string("Home") + ".Address.Location.Late", std::to_string(home.address.location.late));
setParameter(std::string("Home") + ".Address.Location.Lon", std::to_string(home.address.location.lon));
setParameter(std::string("Home") + ".Address.Detail", home.address.detail);
setParameter(std::string("Home") + ".T.Class", home.t._class);
for(int dep1 = 0; dep1 != home.phoneNumbers.size(); dep1++) {
setParameter(std::string("Home") + ".PhoneNumbers." + std::to_string(dep1 + 1), home.phoneNumbers[dep1]);
}
for(auto const &iter1 : home.dMap) {
setParameter(std::string("Home") + ".DMap." + iter1.first + ".Location.Late", std::to_string(iter1.second.location.late));
setParameter(std::string("Home") + ".DMap." + iter1.first + ".Location.Lon", std::to_string(iter1.second.location.lon));
setParameter(std::string("Home") + ".DMap." + iter1.first + ".Detail", iter1.second.detail);
}
for(auto const &iter1 : home.nameToAge) {
setParameter(std::string("Home") + ".NameToAge." + iter1.first, std::to_string(iter1.second));
}
for(int dep1 = 0; dep1 != home.locations.size(); dep1++) {
setParameter(std::string("Home") + ".Locations." + std::to_string(dep1 + 1) + ".Late", std::to_string(home.locations[dep1].late));
setParameter(std::string("Home") + ".Locations." + std::to_string(dep1 + 1) + ".Lon", std::to_string(home.locations[dep1].lon));
}
}

View File

@@ -1,58 +0,0 @@
/*
* 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/amptest/model/CreateRulesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::AmpTest;
using namespace AlibabaCloud::AmpTest::Model;
CreateRulesResult::CreateRulesResult() :
ServiceResult()
{}
CreateRulesResult::CreateRulesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateRulesResult::~CreateRulesResult()
{}
void CreateRulesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Size"].isNull())
size_ = std::stoi(value["Size"].asString());
if(!value["Value"].isNull())
value_ = value["Value"].asString();
}
int CreateRulesResult::getSize()const
{
return size_;
}
std::string CreateRulesResult::getValue()const
{
return value_;
}

View File

@@ -1,55 +0,0 @@
/*
* 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/amptest/model/HuichengTestGrayEightRequest.h>
using AlibabaCloud::AmpTest::Model::HuichengTestGrayEightRequest;
HuichengTestGrayEightRequest::HuichengTestGrayEightRequest()
: RpcServiceRequest("amptest", "2020-12-30", "HuichengTestGrayEight") {
setMethod(HttpRequest::Method::Post);
}
HuichengTestGrayEightRequest::~HuichengTestGrayEightRequest() {}
HuichengTestGrayEightRequest::Home HuichengTestGrayEightRequest::getHome() const {
return home_;
}
void HuichengTestGrayEightRequest::setHome(const HuichengTestGrayEightRequest::Home &home) {
home_ = home;
setParameter(std::string("Home") + ".Address.T.Class", home.address.t._class);
setParameter(std::string("Home") + ".Address.Location.Late", std::to_string(home.address.location.late));
setParameter(std::string("Home") + ".Address.Location.Lon", std::to_string(home.address.location.lon));
setParameter(std::string("Home") + ".Address.Detail", home.address.detail);
setParameter(std::string("Home") + ".T.Class", home.t._class);
for(int dep1 = 0; dep1 != home.phoneNumbers.size(); dep1++) {
setParameter(std::string("Home") + ".PhoneNumbers." + std::to_string(dep1 + 1), home.phoneNumbers[dep1]);
}
for(auto const &iter1 : home.dMap) {
setParameter(std::string("Home") + ".DMap." + iter1.first + ".Location.Late", std::to_string(iter1.second.location.late));
setParameter(std::string("Home") + ".DMap." + iter1.first + ".Location.Lon", std::to_string(iter1.second.location.lon));
setParameter(std::string("Home") + ".DMap." + iter1.first + ".Detail", iter1.second.detail);
}
for(auto const &iter1 : home.nameToAge) {
setParameter(std::string("Home") + ".NameToAge." + iter1.first, std::to_string(iter1.second));
}
for(int dep1 = 0; dep1 != home.locations.size(); dep1++) {
setParameter(std::string("Home") + ".Locations." + std::to_string(dep1 + 1) + ".Late", std::to_string(home.locations[dep1].late));
setParameter(std::string("Home") + ".Locations." + std::to_string(dep1 + 1) + ".Lon", std::to_string(home.locations[dep1].lon));
}
}

View File

@@ -1,58 +0,0 @@
/*
* 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/amptest/model/HuichengTestGrayEightResult.h>
#include <json/json.h>
using namespace AlibabaCloud::AmpTest;
using namespace AlibabaCloud::AmpTest::Model;
HuichengTestGrayEightResult::HuichengTestGrayEightResult() :
ServiceResult()
{}
HuichengTestGrayEightResult::HuichengTestGrayEightResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
HuichengTestGrayEightResult::~HuichengTestGrayEightResult()
{}
void HuichengTestGrayEightResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Size"].isNull())
size_ = std::stoi(value["Size"].asString());
if(!value["Value"].isNull())
value_ = value["Value"].asString();
}
int HuichengTestGrayEightResult::getSize()const
{
return size_;
}
std::string HuichengTestGrayEightResult::getValue()const
{
return value_;
}

View File

@@ -1,55 +0,0 @@
/*
* 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/amptest/model/HuichengTestGrayFifthRequest.h>
using AlibabaCloud::AmpTest::Model::HuichengTestGrayFifthRequest;
HuichengTestGrayFifthRequest::HuichengTestGrayFifthRequest()
: RpcServiceRequest("amptest", "2020-12-30", "HuichengTestGrayFifth") {
setMethod(HttpRequest::Method::Post);
}
HuichengTestGrayFifthRequest::~HuichengTestGrayFifthRequest() {}
HuichengTestGrayFifthRequest::Home HuichengTestGrayFifthRequest::getHome() const {
return home_;
}
void HuichengTestGrayFifthRequest::setHome(const HuichengTestGrayFifthRequest::Home &home) {
home_ = home;
setParameter(std::string("Home") + ".Address.T.Class", home.address.t._class);
setParameter(std::string("Home") + ".Address.Location.Late", std::to_string(home.address.location.late));
setParameter(std::string("Home") + ".Address.Location.Lon", std::to_string(home.address.location.lon));
setParameter(std::string("Home") + ".Address.Detail", home.address.detail);
setParameter(std::string("Home") + ".T.Class", home.t._class);
for(int dep1 = 0; dep1 != home.phoneNumbers.size(); dep1++) {
setParameter(std::string("Home") + ".PhoneNumbers." + std::to_string(dep1 + 1), home.phoneNumbers[dep1]);
}
for(auto const &iter1 : home.dMap) {
setParameter(std::string("Home") + ".DMap." + iter1.first + ".Location.Late", std::to_string(iter1.second.location.late));
setParameter(std::string("Home") + ".DMap." + iter1.first + ".Location.Lon", std::to_string(iter1.second.location.lon));
setParameter(std::string("Home") + ".DMap." + iter1.first + ".Detail", iter1.second.detail);
}
for(auto const &iter1 : home.nameToAge) {
setParameter(std::string("Home") + ".NameToAge." + iter1.first, std::to_string(iter1.second));
}
for(int dep1 = 0; dep1 != home.locations.size(); dep1++) {
setParameter(std::string("Home") + ".Locations." + std::to_string(dep1 + 1) + ".Late", std::to_string(home.locations[dep1].late));
setParameter(std::string("Home") + ".Locations." + std::to_string(dep1 + 1) + ".Lon", std::to_string(home.locations[dep1].lon));
}
}

View File

@@ -1,58 +0,0 @@
/*
* 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/amptest/model/HuichengTestGrayFifthResult.h>
#include <json/json.h>
using namespace AlibabaCloud::AmpTest;
using namespace AlibabaCloud::AmpTest::Model;
HuichengTestGrayFifthResult::HuichengTestGrayFifthResult() :
ServiceResult()
{}
HuichengTestGrayFifthResult::HuichengTestGrayFifthResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
HuichengTestGrayFifthResult::~HuichengTestGrayFifthResult()
{}
void HuichengTestGrayFifthResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Size"].isNull())
size_ = std::stoi(value["Size"].asString());
if(!value["Value"].isNull())
value_ = value["Value"].asString();
}
int HuichengTestGrayFifthResult::getSize()const
{
return size_;
}
std::string HuichengTestGrayFifthResult::getValue()const
{
return value_;
}

View File

@@ -1,55 +0,0 @@
/*
* 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/amptest/model/HuichengTestGrayNineRequest.h>
using AlibabaCloud::AmpTest::Model::HuichengTestGrayNineRequest;
HuichengTestGrayNineRequest::HuichengTestGrayNineRequest()
: RpcServiceRequest("amptest", "2020-12-30", "HuichengTestGrayNine") {
setMethod(HttpRequest::Method::Post);
}
HuichengTestGrayNineRequest::~HuichengTestGrayNineRequest() {}
HuichengTestGrayNineRequest::Home HuichengTestGrayNineRequest::getHome() const {
return home_;
}
void HuichengTestGrayNineRequest::setHome(const HuichengTestGrayNineRequest::Home &home) {
home_ = home;
setParameter(std::string("Home") + ".Address.T.Class", home.address.t._class);
setParameter(std::string("Home") + ".Address.Location.Late", std::to_string(home.address.location.late));
setParameter(std::string("Home") + ".Address.Location.Lon", std::to_string(home.address.location.lon));
setParameter(std::string("Home") + ".Address.Detail", home.address.detail);
setParameter(std::string("Home") + ".T.Class", home.t._class);
for(int dep1 = 0; dep1 != home.phoneNumbers.size(); dep1++) {
setParameter(std::string("Home") + ".PhoneNumbers." + std::to_string(dep1 + 1), home.phoneNumbers[dep1]);
}
for(auto const &iter1 : home.dMap) {
setParameter(std::string("Home") + ".DMap." + iter1.first + ".Location.Late", std::to_string(iter1.second.location.late));
setParameter(std::string("Home") + ".DMap." + iter1.first + ".Location.Lon", std::to_string(iter1.second.location.lon));
setParameter(std::string("Home") + ".DMap." + iter1.first + ".Detail", iter1.second.detail);
}
for(auto const &iter1 : home.nameToAge) {
setParameter(std::string("Home") + ".NameToAge." + iter1.first, std::to_string(iter1.second));
}
for(int dep1 = 0; dep1 != home.locations.size(); dep1++) {
setParameter(std::string("Home") + ".Locations." + std::to_string(dep1 + 1) + ".Late", std::to_string(home.locations[dep1].late));
setParameter(std::string("Home") + ".Locations." + std::to_string(dep1 + 1) + ".Lon", std::to_string(home.locations[dep1].lon));
}
}

View File

@@ -1,58 +0,0 @@
/*
* 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/amptest/model/HuichengTestGrayNineResult.h>
#include <json/json.h>
using namespace AlibabaCloud::AmpTest;
using namespace AlibabaCloud::AmpTest::Model;
HuichengTestGrayNineResult::HuichengTestGrayNineResult() :
ServiceResult()
{}
HuichengTestGrayNineResult::HuichengTestGrayNineResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
HuichengTestGrayNineResult::~HuichengTestGrayNineResult()
{}
void HuichengTestGrayNineResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Size"].isNull())
size_ = std::stoi(value["Size"].asString());
if(!value["Value"].isNull())
value_ = value["Value"].asString();
}
int HuichengTestGrayNineResult::getSize()const
{
return size_;
}
std::string HuichengTestGrayNineResult::getValue()const
{
return value_;
}

View File

@@ -1,55 +0,0 @@
/*
* 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/amptest/model/HuichengTestGrayRequest.h>
using AlibabaCloud::AmpTest::Model::HuichengTestGrayRequest;
HuichengTestGrayRequest::HuichengTestGrayRequest()
: RpcServiceRequest("amptest", "2020-12-30", "HuichengTestGray") {
setMethod(HttpRequest::Method::Post);
}
HuichengTestGrayRequest::~HuichengTestGrayRequest() {}
HuichengTestGrayRequest::Home HuichengTestGrayRequest::getHome() const {
return home_;
}
void HuichengTestGrayRequest::setHome(const HuichengTestGrayRequest::Home &home) {
home_ = home;
setParameter(std::string("Home") + ".Address.T.Class", home.address.t._class);
setParameter(std::string("Home") + ".Address.Location.Late", std::to_string(home.address.location.late));
setParameter(std::string("Home") + ".Address.Location.Lon", std::to_string(home.address.location.lon));
setParameter(std::string("Home") + ".Address.Detail", home.address.detail);
setParameter(std::string("Home") + ".T.Class", home.t._class);
for(int dep1 = 0; dep1 != home.phoneNumbers.size(); dep1++) {
setParameter(std::string("Home") + ".PhoneNumbers." + std::to_string(dep1 + 1), home.phoneNumbers[dep1]);
}
for(auto const &iter1 : home.dMap) {
setParameter(std::string("Home") + ".DMap." + iter1.first + ".Location.Late", std::to_string(iter1.second.location.late));
setParameter(std::string("Home") + ".DMap." + iter1.first + ".Location.Lon", std::to_string(iter1.second.location.lon));
setParameter(std::string("Home") + ".DMap." + iter1.first + ".Detail", iter1.second.detail);
}
for(auto const &iter1 : home.nameToAge) {
setParameter(std::string("Home") + ".NameToAge." + iter1.first, std::to_string(iter1.second));
}
for(int dep1 = 0; dep1 != home.locations.size(); dep1++) {
setParameter(std::string("Home") + ".Locations." + std::to_string(dep1 + 1) + ".Late", std::to_string(home.locations[dep1].late));
setParameter(std::string("Home") + ".Locations." + std::to_string(dep1 + 1) + ".Lon", std::to_string(home.locations[dep1].lon));
}
}

View File

@@ -1,58 +0,0 @@
/*
* 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/amptest/model/HuichengTestGrayResult.h>
#include <json/json.h>
using namespace AlibabaCloud::AmpTest;
using namespace AlibabaCloud::AmpTest::Model;
HuichengTestGrayResult::HuichengTestGrayResult() :
ServiceResult()
{}
HuichengTestGrayResult::HuichengTestGrayResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
HuichengTestGrayResult::~HuichengTestGrayResult()
{}
void HuichengTestGrayResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Size"].isNull())
size_ = std::stoi(value["Size"].asString());
if(!value["Value"].isNull())
value_ = value["Value"].asString();
}
int HuichengTestGrayResult::getSize()const
{
return size_;
}
std::string HuichengTestGrayResult::getValue()const
{
return value_;
}

View File

@@ -1,55 +0,0 @@
/*
* 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/amptest/model/HuichengTestGraySecondRequest.h>
using AlibabaCloud::AmpTest::Model::HuichengTestGraySecondRequest;
HuichengTestGraySecondRequest::HuichengTestGraySecondRequest()
: RpcServiceRequest("amptest", "2020-12-30", "HuichengTestGraySecond") {
setMethod(HttpRequest::Method::Post);
}
HuichengTestGraySecondRequest::~HuichengTestGraySecondRequest() {}
HuichengTestGraySecondRequest::Home HuichengTestGraySecondRequest::getHome() const {
return home_;
}
void HuichengTestGraySecondRequest::setHome(const HuichengTestGraySecondRequest::Home &home) {
home_ = home;
setParameter(std::string("Home") + ".Address.T.Class", home.address.t._class);
setParameter(std::string("Home") + ".Address.Location.Late", std::to_string(home.address.location.late));
setParameter(std::string("Home") + ".Address.Location.Lon", std::to_string(home.address.location.lon));
setParameter(std::string("Home") + ".Address.Detail", home.address.detail);
setParameter(std::string("Home") + ".T.Class", home.t._class);
for(int dep1 = 0; dep1 != home.phoneNumbers.size(); dep1++) {
setParameter(std::string("Home") + ".PhoneNumbers." + std::to_string(dep1 + 1), home.phoneNumbers[dep1]);
}
for(auto const &iter1 : home.dMap) {
setParameter(std::string("Home") + ".DMap." + iter1.first + ".Location.Late", std::to_string(iter1.second.location.late));
setParameter(std::string("Home") + ".DMap." + iter1.first + ".Location.Lon", std::to_string(iter1.second.location.lon));
setParameter(std::string("Home") + ".DMap." + iter1.first + ".Detail", iter1.second.detail);
}
for(auto const &iter1 : home.nameToAge) {
setParameter(std::string("Home") + ".NameToAge." + iter1.first, std::to_string(iter1.second));
}
for(int dep1 = 0; dep1 != home.locations.size(); dep1++) {
setParameter(std::string("Home") + ".Locations." + std::to_string(dep1 + 1) + ".Late", std::to_string(home.locations[dep1].late));
setParameter(std::string("Home") + ".Locations." + std::to_string(dep1 + 1) + ".Lon", std::to_string(home.locations[dep1].lon));
}
}

View File

@@ -1,58 +0,0 @@
/*
* 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/amptest/model/HuichengTestGraySecondResult.h>
#include <json/json.h>
using namespace AlibabaCloud::AmpTest;
using namespace AlibabaCloud::AmpTest::Model;
HuichengTestGraySecondResult::HuichengTestGraySecondResult() :
ServiceResult()
{}
HuichengTestGraySecondResult::HuichengTestGraySecondResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
HuichengTestGraySecondResult::~HuichengTestGraySecondResult()
{}
void HuichengTestGraySecondResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Size"].isNull())
size_ = std::stoi(value["Size"].asString());
if(!value["Value"].isNull())
value_ = value["Value"].asString();
}
int HuichengTestGraySecondResult::getSize()const
{
return size_;
}
std::string HuichengTestGraySecondResult::getValue()const
{
return value_;
}

View File

@@ -1,55 +0,0 @@
/*
* 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/amptest/model/HuichengTestGraySevenRequest.h>
using AlibabaCloud::AmpTest::Model::HuichengTestGraySevenRequest;
HuichengTestGraySevenRequest::HuichengTestGraySevenRequest()
: RpcServiceRequest("amptest", "2020-12-30", "HuichengTestGraySeven") {
setMethod(HttpRequest::Method::Post);
}
HuichengTestGraySevenRequest::~HuichengTestGraySevenRequest() {}
HuichengTestGraySevenRequest::Home HuichengTestGraySevenRequest::getHome() const {
return home_;
}
void HuichengTestGraySevenRequest::setHome(const HuichengTestGraySevenRequest::Home &home) {
home_ = home;
setParameter(std::string("Home") + ".Address.T.Class", home.address.t._class);
setParameter(std::string("Home") + ".Address.Location.Late", std::to_string(home.address.location.late));
setParameter(std::string("Home") + ".Address.Location.Lon", std::to_string(home.address.location.lon));
setParameter(std::string("Home") + ".Address.Detail", home.address.detail);
setParameter(std::string("Home") + ".T.Class", home.t._class);
for(int dep1 = 0; dep1 != home.phoneNumbers.size(); dep1++) {
setParameter(std::string("Home") + ".PhoneNumbers." + std::to_string(dep1 + 1), home.phoneNumbers[dep1]);
}
for(auto const &iter1 : home.dMap) {
setParameter(std::string("Home") + ".DMap." + iter1.first + ".Location.Late", std::to_string(iter1.second.location.late));
setParameter(std::string("Home") + ".DMap." + iter1.first + ".Location.Lon", std::to_string(iter1.second.location.lon));
setParameter(std::string("Home") + ".DMap." + iter1.first + ".Detail", iter1.second.detail);
}
for(auto const &iter1 : home.nameToAge) {
setParameter(std::string("Home") + ".NameToAge." + iter1.first, std::to_string(iter1.second));
}
for(int dep1 = 0; dep1 != home.locations.size(); dep1++) {
setParameter(std::string("Home") + ".Locations." + std::to_string(dep1 + 1) + ".Late", std::to_string(home.locations[dep1].late));
setParameter(std::string("Home") + ".Locations." + std::to_string(dep1 + 1) + ".Lon", std::to_string(home.locations[dep1].lon));
}
}

View File

@@ -1,58 +0,0 @@
/*
* 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/amptest/model/HuichengTestGraySevenResult.h>
#include <json/json.h>
using namespace AlibabaCloud::AmpTest;
using namespace AlibabaCloud::AmpTest::Model;
HuichengTestGraySevenResult::HuichengTestGraySevenResult() :
ServiceResult()
{}
HuichengTestGraySevenResult::HuichengTestGraySevenResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
HuichengTestGraySevenResult::~HuichengTestGraySevenResult()
{}
void HuichengTestGraySevenResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Size"].isNull())
size_ = std::stoi(value["Size"].asString());
if(!value["Value"].isNull())
value_ = value["Value"].asString();
}
int HuichengTestGraySevenResult::getSize()const
{
return size_;
}
std::string HuichengTestGraySevenResult::getValue()const
{
return value_;
}

View File

@@ -1,55 +0,0 @@
/*
* 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/amptest/model/HuichengTestGraySixRequest.h>
using AlibabaCloud::AmpTest::Model::HuichengTestGraySixRequest;
HuichengTestGraySixRequest::HuichengTestGraySixRequest()
: RpcServiceRequest("amptest", "2020-12-30", "HuichengTestGraySix") {
setMethod(HttpRequest::Method::Post);
}
HuichengTestGraySixRequest::~HuichengTestGraySixRequest() {}
HuichengTestGraySixRequest::Home HuichengTestGraySixRequest::getHome() const {
return home_;
}
void HuichengTestGraySixRequest::setHome(const HuichengTestGraySixRequest::Home &home) {
home_ = home;
setParameter(std::string("Home") + ".Address.T.Class", home.address.t._class);
setParameter(std::string("Home") + ".Address.Location.Late", std::to_string(home.address.location.late));
setParameter(std::string("Home") + ".Address.Location.Lon", std::to_string(home.address.location.lon));
setParameter(std::string("Home") + ".Address.Detail", home.address.detail);
setParameter(std::string("Home") + ".T.Class", home.t._class);
for(int dep1 = 0; dep1 != home.phoneNumbers.size(); dep1++) {
setParameter(std::string("Home") + ".PhoneNumbers." + std::to_string(dep1 + 1), home.phoneNumbers[dep1]);
}
for(auto const &iter1 : home.dMap) {
setParameter(std::string("Home") + ".DMap." + iter1.first + ".Location.Late", std::to_string(iter1.second.location.late));
setParameter(std::string("Home") + ".DMap." + iter1.first + ".Location.Lon", std::to_string(iter1.second.location.lon));
setParameter(std::string("Home") + ".DMap." + iter1.first + ".Detail", iter1.second.detail);
}
for(auto const &iter1 : home.nameToAge) {
setParameter(std::string("Home") + ".NameToAge." + iter1.first, std::to_string(iter1.second));
}
for(int dep1 = 0; dep1 != home.locations.size(); dep1++) {
setParameter(std::string("Home") + ".Locations." + std::to_string(dep1 + 1) + ".Late", std::to_string(home.locations[dep1].late));
setParameter(std::string("Home") + ".Locations." + std::to_string(dep1 + 1) + ".Lon", std::to_string(home.locations[dep1].lon));
}
}

View File

@@ -1,58 +0,0 @@
/*
* 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/amptest/model/HuichengTestGraySixResult.h>
#include <json/json.h>
using namespace AlibabaCloud::AmpTest;
using namespace AlibabaCloud::AmpTest::Model;
HuichengTestGraySixResult::HuichengTestGraySixResult() :
ServiceResult()
{}
HuichengTestGraySixResult::HuichengTestGraySixResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
HuichengTestGraySixResult::~HuichengTestGraySixResult()
{}
void HuichengTestGraySixResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Size"].isNull())
size_ = std::stoi(value["Size"].asString());
if(!value["Value"].isNull())
value_ = value["Value"].asString();
}
int HuichengTestGraySixResult::getSize()const
{
return size_;
}
std::string HuichengTestGraySixResult::getValue()const
{
return value_;
}

View File

@@ -1,55 +0,0 @@
/*
* 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/amptest/model/HuichengTestGrayTenRequest.h>
using AlibabaCloud::AmpTest::Model::HuichengTestGrayTenRequest;
HuichengTestGrayTenRequest::HuichengTestGrayTenRequest()
: RpcServiceRequest("amptest", "2020-12-30", "HuichengTestGrayTen") {
setMethod(HttpRequest::Method::Post);
}
HuichengTestGrayTenRequest::~HuichengTestGrayTenRequest() {}
HuichengTestGrayTenRequest::Home HuichengTestGrayTenRequest::getHome() const {
return home_;
}
void HuichengTestGrayTenRequest::setHome(const HuichengTestGrayTenRequest::Home &home) {
home_ = home;
setParameter(std::string("Home") + ".Address.T.Class", home.address.t._class);
setParameter(std::string("Home") + ".Address.Location.Late", std::to_string(home.address.location.late));
setParameter(std::string("Home") + ".Address.Location.Lon", std::to_string(home.address.location.lon));
setParameter(std::string("Home") + ".Address.Detail", home.address.detail);
setParameter(std::string("Home") + ".T.Class", home.t._class);
for(int dep1 = 0; dep1 != home.phoneNumbers.size(); dep1++) {
setParameter(std::string("Home") + ".PhoneNumbers." + std::to_string(dep1 + 1), home.phoneNumbers[dep1]);
}
for(auto const &iter1 : home.dMap) {
setParameter(std::string("Home") + ".DMap." + iter1.first + ".Location.Late", std::to_string(iter1.second.location.late));
setParameter(std::string("Home") + ".DMap." + iter1.first + ".Location.Lon", std::to_string(iter1.second.location.lon));
setParameter(std::string("Home") + ".DMap." + iter1.first + ".Detail", iter1.second.detail);
}
for(auto const &iter1 : home.nameToAge) {
setParameter(std::string("Home") + ".NameToAge." + iter1.first, std::to_string(iter1.second));
}
for(int dep1 = 0; dep1 != home.locations.size(); dep1++) {
setParameter(std::string("Home") + ".Locations." + std::to_string(dep1 + 1) + ".Late", std::to_string(home.locations[dep1].late));
setParameter(std::string("Home") + ".Locations." + std::to_string(dep1 + 1) + ".Lon", std::to_string(home.locations[dep1].lon));
}
}

View File

@@ -1,58 +0,0 @@
/*
* 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/amptest/model/HuichengTestGrayTenResult.h>
#include <json/json.h>
using namespace AlibabaCloud::AmpTest;
using namespace AlibabaCloud::AmpTest::Model;
HuichengTestGrayTenResult::HuichengTestGrayTenResult() :
ServiceResult()
{}
HuichengTestGrayTenResult::HuichengTestGrayTenResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
HuichengTestGrayTenResult::~HuichengTestGrayTenResult()
{}
void HuichengTestGrayTenResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Size"].isNull())
size_ = std::stoi(value["Size"].asString());
if(!value["Value"].isNull())
value_ = value["Value"].asString();
}
int HuichengTestGrayTenResult::getSize()const
{
return size_;
}
std::string HuichengTestGrayTenResult::getValue()const
{
return value_;
}

View File

@@ -1,55 +0,0 @@
/*
* 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/amptest/model/HuichengTestGrayThirdRequest.h>
using AlibabaCloud::AmpTest::Model::HuichengTestGrayThirdRequest;
HuichengTestGrayThirdRequest::HuichengTestGrayThirdRequest()
: RpcServiceRequest("amptest", "2020-12-30", "HuichengTestGrayThird") {
setMethod(HttpRequest::Method::Post);
}
HuichengTestGrayThirdRequest::~HuichengTestGrayThirdRequest() {}
HuichengTestGrayThirdRequest::Home HuichengTestGrayThirdRequest::getHome() const {
return home_;
}
void HuichengTestGrayThirdRequest::setHome(const HuichengTestGrayThirdRequest::Home &home) {
home_ = home;
setParameter(std::string("Home") + ".Address.T.Class", home.address.t._class);
setParameter(std::string("Home") + ".Address.Location.Late", std::to_string(home.address.location.late));
setParameter(std::string("Home") + ".Address.Location.Lon", std::to_string(home.address.location.lon));
setParameter(std::string("Home") + ".Address.Detail", home.address.detail);
setParameter(std::string("Home") + ".T.Class", home.t._class);
for(int dep1 = 0; dep1 != home.phoneNumbers.size(); dep1++) {
setParameter(std::string("Home") + ".PhoneNumbers." + std::to_string(dep1 + 1), home.phoneNumbers[dep1]);
}
for(auto const &iter1 : home.dMap) {
setParameter(std::string("Home") + ".DMap." + iter1.first + ".Location.Late", std::to_string(iter1.second.location.late));
setParameter(std::string("Home") + ".DMap." + iter1.first + ".Location.Lon", std::to_string(iter1.second.location.lon));
setParameter(std::string("Home") + ".DMap." + iter1.first + ".Detail", iter1.second.detail);
}
for(auto const &iter1 : home.nameToAge) {
setParameter(std::string("Home") + ".NameToAge." + iter1.first, std::to_string(iter1.second));
}
for(int dep1 = 0; dep1 != home.locations.size(); dep1++) {
setParameter(std::string("Home") + ".Locations." + std::to_string(dep1 + 1) + ".Late", std::to_string(home.locations[dep1].late));
setParameter(std::string("Home") + ".Locations." + std::to_string(dep1 + 1) + ".Lon", std::to_string(home.locations[dep1].lon));
}
}

View File

@@ -1,58 +0,0 @@
/*
* 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/amptest/model/HuichengTestGrayThirdResult.h>
#include <json/json.h>
using namespace AlibabaCloud::AmpTest;
using namespace AlibabaCloud::AmpTest::Model;
HuichengTestGrayThirdResult::HuichengTestGrayThirdResult() :
ServiceResult()
{}
HuichengTestGrayThirdResult::HuichengTestGrayThirdResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
HuichengTestGrayThirdResult::~HuichengTestGrayThirdResult()
{}
void HuichengTestGrayThirdResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Size"].isNull())
size_ = std::stoi(value["Size"].asString());
if(!value["Value"].isNull())
value_ = value["Value"].asString();
}
int HuichengTestGrayThirdResult::getSize()const
{
return size_;
}
std::string HuichengTestGrayThirdResult::getValue()const
{
return value_;
}

View File

@@ -1,27 +0,0 @@
/*
* 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/amptest/model/HuichengTestResourceOwnerIdRequest.h>
using AlibabaCloud::AmpTest::Model::HuichengTestResourceOwnerIdRequest;
HuichengTestResourceOwnerIdRequest::HuichengTestResourceOwnerIdRequest()
: RpcServiceRequest("amptest", "2020-12-30", "HuichengTestResourceOwnerId") {
setMethod(HttpRequest::Method::Get);
}
HuichengTestResourceOwnerIdRequest::~HuichengTestResourceOwnerIdRequest() {}

View File

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

View File

@@ -1,189 +0,0 @@
/*
* 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/amptest/model/HuichengetRequest.h>
using AlibabaCloud::AmpTest::Model::HuichengetRequest;
HuichengetRequest::HuichengetRequest()
: RpcServiceRequest("amptest", "2020-12-30", "Huichenget") {
setMethod(HttpRequest::Method::Post);
}
HuichengetRequest::~HuichengetRequest() {}
std::string HuichengetRequest::getAdd() const {
return add_;
}
void HuichengetRequest::setAdd(const std::string &add) {
add_ = add;
setParameter(std::string("Add"), add);
}
std::string HuichengetRequest::getAddress() const {
return address_;
}
void HuichengetRequest::setAddress(const std::string &address) {
address_ = address;
setParameter(std::string("Address"), address);
}
std::string HuichengetRequest::getSix() const {
return six_;
}
void HuichengetRequest::setSix(const std::string &six) {
six_ = six;
setParameter(std::string("Six"), six);
}
std::string HuichengetRequest::getEnight() const {
return enight_;
}
void HuichengetRequest::setEnight(const std::string &enight) {
enight_ = enight;
setParameter(std::string("Enight"), enight);
}
std::string HuichengetRequest::getNewName() const {
return newName_;
}
void HuichengetRequest::setNewName(const std::string &newName) {
newName_ = newName;
setParameter(std::string("NewName"), newName);
}
std::string HuichengetRequest::getList() const {
return list_;
}
void HuichengetRequest::setList(const std::string &list) {
list_ = list;
setParameter(std::string("List"), list);
}
std::string HuichengetRequest::getTwo() const {
return two_;
}
void HuichengetRequest::setTwo(const std::string &two) {
two_ = two;
setParameter(std::string("Two"), two);
}
std::string HuichengetRequest::getThree() const {
return three_;
}
void HuichengetRequest::setThree(const std::string &three) {
three_ = three;
setParameter(std::string("Three"), three);
}
std::string HuichengetRequest::getNigh() const {
return nigh_;
}
void HuichengetRequest::setNigh(const std::string &nigh) {
nigh_ = nigh;
setParameter(std::string("Nigh"), nigh);
}
std::string HuichengetRequest::getRed() const {
return red_;
}
void HuichengetRequest::setRed(const std::string &red) {
red_ = red;
setParameter(std::string("Red"), red);
}
std::string HuichengetRequest::getApple() const {
return apple_;
}
void HuichengetRequest::setApple(const std::string &apple) {
apple_ = apple;
setParameter(std::string("Apple"), apple);
}
std::string HuichengetRequest::getTea() const {
return tea_;
}
void HuichengetRequest::setTea(const std::string &tea) {
tea_ = tea;
setParameter(std::string("Tea"), tea);
}
std::string HuichengetRequest::getBlue() const {
return blue_;
}
void HuichengetRequest::setBlue(const std::string &blue) {
blue_ = blue;
setParameter(std::string("Blue"), blue);
}
std::string HuichengetRequest::getWhite() const {
return white_;
}
void HuichengetRequest::setWhite(const std::string &white) {
white_ = white;
setParameter(std::string("White"), white);
}
std::string HuichengetRequest::getFour() const {
return four_;
}
void HuichengetRequest::setFour(const std::string &four) {
four_ = four;
setParameter(std::string("Four"), four);
}
std::string HuichengetRequest::getNow() const {
return now_;
}
void HuichengetRequest::setNow(const std::string &now) {
now_ = now;
setParameter(std::string("Now"), now);
}
std::string HuichengetRequest::getTen() const {
return ten_;
}
void HuichengetRequest::setTen(const std::string &ten) {
ten_ = ten;
setParameter(std::string("Ten"), ten);
}
std::string HuichengetRequest::getFive() const {
return five_;
}
void HuichengetRequest::setFive(const std::string &five) {
five_ = five;
setParameter(std::string("Five"), five);
}

View File

@@ -1,100 +0,0 @@
/*
* 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/amptest/model/HuichengetResult.h>
#include <json/json.h>
using namespace AlibabaCloud::AmpTest;
using namespace AlibabaCloud::AmpTest::Model;
HuichengetResult::HuichengetResult() :
ServiceResult()
{}
HuichengetResult::HuichengetResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
HuichengetResult::~HuichengetResult()
{}
void HuichengetResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["InstanceId4"].isNull())
instanceId4_ = value["InstanceId4"].asString();
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["Age"].isNull())
age_ = value["Age"].asString();
if(!value["Apple"].isNull())
apple_ = value["Apple"].asString();
if(!value["Five"].isNull())
five_ = value["Five"].asString();
if(!value["Six"].isNull())
six_ = value["Six"].asString();
if(!value["Seven"].isNull())
seven_ = value["Seven"].asString();
}
std::string HuichengetResult::getApple()const
{
return apple_;
}
std::string HuichengetResult::getFive()const
{
return five_;
}
std::string HuichengetResult::getSix()const
{
return six_;
}
std::string HuichengetResult::getMessage()const
{
return message_;
}
std::string HuichengetResult::getInstanceId4()const
{
return instanceId4_;
}
std::string HuichengetResult::getSeven()const
{
return seven_;
}
std::string HuichengetResult::getCode()const
{
return code_;
}
std::string HuichengetResult::getAge()const
{
return age_;
}

View File

@@ -1,27 +0,0 @@
/*
* 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/amptest/model/HuichengetestRequest.h>
using AlibabaCloud::AmpTest::Model::HuichengetestRequest;
HuichengetestRequest::HuichengetestRequest()
: RpcServiceRequest("amptest", "2020-12-30", "Huichengetest") {
setMethod(HttpRequest::Method::Post);
}
HuichengetestRequest::~HuichengetestRequest() {}

View File

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

View File

@@ -1,158 +0,0 @@
#
# 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(lmztest_public_header
include/alibabacloud/lmztest/LmzTestClient.h
include/alibabacloud/lmztest/LmzTestExport.h )
set(lmztest_public_header_model
include/alibabacloud/lmztest/model/AAbckRequest.h
include/alibabacloud/lmztest/model/AAbckResult.h
include/alibabacloud/lmztest/model/AndBackRequest.h
include/alibabacloud/lmztest/model/AndBackResult.h
include/alibabacloud/lmztest/model/DataRateLimitTestRequest.h
include/alibabacloud/lmztest/model/DataRateLimitTestResult.h
include/alibabacloud/lmztest/model/DemoGrayReleaseTestRequest.h
include/alibabacloud/lmztest/model/DemoGrayReleaseTestResult.h
include/alibabacloud/lmztest/model/DemoGrayReleaseTestTwoRequest.h
include/alibabacloud/lmztest/model/DemoGrayReleaseTestTwoResult.h
include/alibabacloud/lmztest/model/DemoGreyReleaseTestRequest.h
include/alibabacloud/lmztest/model/DemoGreyReleaseTestResult.h
include/alibabacloud/lmztest/model/DemoHsfNineResponseRequest.h
include/alibabacloud/lmztest/model/DemoHsfNineResponseResult.h
include/alibabacloud/lmztest/model/DemoHsfSixTestRequest.h
include/alibabacloud/lmztest/model/DemoHsfSixTestResult.h
include/alibabacloud/lmztest/model/DemoHttpComplexResponseRequest.h
include/alibabacloud/lmztest/model/DemoHttpComplexResponseResult.h
include/alibabacloud/lmztest/model/DescribeDisksRequest.h
include/alibabacloud/lmztest/model/DescribeDisksResult.h
include/alibabacloud/lmztest/model/GetPackageStorageCredentialRequest.h
include/alibabacloud/lmztest/model/GetPackageStorageCredentialResult.h
include/alibabacloud/lmztest/model/GrayReleaseDemoRequest.h
include/alibabacloud/lmztest/model/GrayReleaseDemoResult.h
include/alibabacloud/lmztest/model/ListProductsByPopCodeRequest.h
include/alibabacloud/lmztest/model/ListProductsByPopCodeResult.h
include/alibabacloud/lmztest/model/LjxTestRequest.h
include/alibabacloud/lmztest/model/LjxTestResult.h
include/alibabacloud/lmztest/model/ReqBeanTestRequest.h
include/alibabacloud/lmztest/model/ReqBeanTestResult.h
include/alibabacloud/lmztest/model/RomeGetExecutionResultRequest.h
include/alibabacloud/lmztest/model/RomeGetExecutionResultResult.h
include/alibabacloud/lmztest/model/RpcHttpRequest.h
include/alibabacloud/lmztest/model/RpcHttpResult.h
include/alibabacloud/lmztest/model/TestPutApiAndGetApiRequest.h
include/alibabacloud/lmztest/model/TestPutApiAndGetApiResult.h
include/alibabacloud/lmztest/model/UpdateListenerRequest.h
include/alibabacloud/lmztest/model/UpdateListenerResult.h )
set(lmztest_src
src/LmzTestClient.cc
src/model/AAbckRequest.cc
src/model/AAbckResult.cc
src/model/AndBackRequest.cc
src/model/AndBackResult.cc
src/model/DataRateLimitTestRequest.cc
src/model/DataRateLimitTestResult.cc
src/model/DemoGrayReleaseTestRequest.cc
src/model/DemoGrayReleaseTestResult.cc
src/model/DemoGrayReleaseTestTwoRequest.cc
src/model/DemoGrayReleaseTestTwoResult.cc
src/model/DemoGreyReleaseTestRequest.cc
src/model/DemoGreyReleaseTestResult.cc
src/model/DemoHsfNineResponseRequest.cc
src/model/DemoHsfNineResponseResult.cc
src/model/DemoHsfSixTestRequest.cc
src/model/DemoHsfSixTestResult.cc
src/model/DemoHttpComplexResponseRequest.cc
src/model/DemoHttpComplexResponseResult.cc
src/model/DescribeDisksRequest.cc
src/model/DescribeDisksResult.cc
src/model/GetPackageStorageCredentialRequest.cc
src/model/GetPackageStorageCredentialResult.cc
src/model/GrayReleaseDemoRequest.cc
src/model/GrayReleaseDemoResult.cc
src/model/ListProductsByPopCodeRequest.cc
src/model/ListProductsByPopCodeResult.cc
src/model/LjxTestRequest.cc
src/model/LjxTestResult.cc
src/model/ReqBeanTestRequest.cc
src/model/ReqBeanTestResult.cc
src/model/RomeGetExecutionResultRequest.cc
src/model/RomeGetExecutionResultResult.cc
src/model/RpcHttpRequest.cc
src/model/RpcHttpResult.cc
src/model/TestPutApiAndGetApiRequest.cc
src/model/TestPutApiAndGetApiResult.cc
src/model/UpdateListenerRequest.cc
src/model/UpdateListenerResult.cc )
add_library(lmztest ${LIB_TYPE}
${lmztest_public_header}
${lmztest_public_header_model}
${lmztest_src})
set_target_properties(lmztest
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}lmztest
)
if(${LIB_TYPE} STREQUAL "SHARED")
set_target_properties(lmztest
PROPERTIES
DEFINE_SYMBOL ALIBABACLOUD_LMZTEST_LIBRARY)
endif()
target_include_directories(lmztest
PRIVATE include
${CMAKE_SOURCE_DIR}/core/include
)
target_link_libraries(lmztest
core)
if(CMAKE_HOST_WIN32)
ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
set(jsoncpp_install_dir ${INSTALL_DIR})
add_dependencies(lmztest
jsoncpp)
target_include_directories(lmztest
PRIVATE ${jsoncpp_install_dir}/include)
target_link_libraries(lmztest
${jsoncpp_install_dir}/lib/jsoncpp.lib)
set_target_properties(lmztest
PROPERTIES
COMPILE_OPTIONS "/bigobj")
else()
target_include_directories(lmztest
PRIVATE /usr/include/jsoncpp)
target_link_libraries(lmztest
jsoncpp)
endif()
install(FILES ${lmztest_public_header}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/lmztest)
install(FILES ${lmztest_public_header_model}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/lmztest/model)
install(TARGETS lmztest
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)

View File

@@ -1,198 +0,0 @@
/*
* 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_LMZTEST_LMZTESTCLIENT_H_
#define ALIBABACLOUD_LMZTEST_LMZTESTCLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "LmzTestExport.h"
#include "model/AAbckRequest.h"
#include "model/AAbckResult.h"
#include "model/AndBackRequest.h"
#include "model/AndBackResult.h"
#include "model/DataRateLimitTestRequest.h"
#include "model/DataRateLimitTestResult.h"
#include "model/DemoGrayReleaseTestRequest.h"
#include "model/DemoGrayReleaseTestResult.h"
#include "model/DemoGrayReleaseTestTwoRequest.h"
#include "model/DemoGrayReleaseTestTwoResult.h"
#include "model/DemoGreyReleaseTestRequest.h"
#include "model/DemoGreyReleaseTestResult.h"
#include "model/DemoHsfNineResponseRequest.h"
#include "model/DemoHsfNineResponseResult.h"
#include "model/DemoHsfSixTestRequest.h"
#include "model/DemoHsfSixTestResult.h"
#include "model/DemoHttpComplexResponseRequest.h"
#include "model/DemoHttpComplexResponseResult.h"
#include "model/DescribeDisksRequest.h"
#include "model/DescribeDisksResult.h"
#include "model/GetPackageStorageCredentialRequest.h"
#include "model/GetPackageStorageCredentialResult.h"
#include "model/GrayReleaseDemoRequest.h"
#include "model/GrayReleaseDemoResult.h"
#include "model/ListProductsByPopCodeRequest.h"
#include "model/ListProductsByPopCodeResult.h"
#include "model/LjxTestRequest.h"
#include "model/LjxTestResult.h"
#include "model/ReqBeanTestRequest.h"
#include "model/ReqBeanTestResult.h"
#include "model/RomeGetExecutionResultRequest.h"
#include "model/RomeGetExecutionResultResult.h"
#include "model/RpcHttpRequest.h"
#include "model/RpcHttpResult.h"
#include "model/TestPutApiAndGetApiRequest.h"
#include "model/TestPutApiAndGetApiResult.h"
#include "model/UpdateListenerRequest.h"
#include "model/UpdateListenerResult.h"
namespace AlibabaCloud
{
namespace LmzTest
{
class ALIBABACLOUD_LMZTEST_EXPORT LmzTestClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::AAbckResult> AAbckOutcome;
typedef std::future<AAbckOutcome> AAbckOutcomeCallable;
typedef std::function<void(const LmzTestClient*, const Model::AAbckRequest&, const AAbckOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AAbckAsyncHandler;
typedef Outcome<Error, Model::AndBackResult> AndBackOutcome;
typedef std::future<AndBackOutcome> AndBackOutcomeCallable;
typedef std::function<void(const LmzTestClient*, const Model::AndBackRequest&, const AndBackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AndBackAsyncHandler;
typedef Outcome<Error, Model::DataRateLimitTestResult> DataRateLimitTestOutcome;
typedef std::future<DataRateLimitTestOutcome> DataRateLimitTestOutcomeCallable;
typedef std::function<void(const LmzTestClient*, const Model::DataRateLimitTestRequest&, const DataRateLimitTestOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DataRateLimitTestAsyncHandler;
typedef Outcome<Error, Model::DemoGrayReleaseTestResult> DemoGrayReleaseTestOutcome;
typedef std::future<DemoGrayReleaseTestOutcome> DemoGrayReleaseTestOutcomeCallable;
typedef std::function<void(const LmzTestClient*, const Model::DemoGrayReleaseTestRequest&, const DemoGrayReleaseTestOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DemoGrayReleaseTestAsyncHandler;
typedef Outcome<Error, Model::DemoGrayReleaseTestTwoResult> DemoGrayReleaseTestTwoOutcome;
typedef std::future<DemoGrayReleaseTestTwoOutcome> DemoGrayReleaseTestTwoOutcomeCallable;
typedef std::function<void(const LmzTestClient*, const Model::DemoGrayReleaseTestTwoRequest&, const DemoGrayReleaseTestTwoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DemoGrayReleaseTestTwoAsyncHandler;
typedef Outcome<Error, Model::DemoGreyReleaseTestResult> DemoGreyReleaseTestOutcome;
typedef std::future<DemoGreyReleaseTestOutcome> DemoGreyReleaseTestOutcomeCallable;
typedef std::function<void(const LmzTestClient*, const Model::DemoGreyReleaseTestRequest&, const DemoGreyReleaseTestOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DemoGreyReleaseTestAsyncHandler;
typedef Outcome<Error, Model::DemoHsfNineResponseResult> DemoHsfNineResponseOutcome;
typedef std::future<DemoHsfNineResponseOutcome> DemoHsfNineResponseOutcomeCallable;
typedef std::function<void(const LmzTestClient*, const Model::DemoHsfNineResponseRequest&, const DemoHsfNineResponseOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DemoHsfNineResponseAsyncHandler;
typedef Outcome<Error, Model::DemoHsfSixTestResult> DemoHsfSixTestOutcome;
typedef std::future<DemoHsfSixTestOutcome> DemoHsfSixTestOutcomeCallable;
typedef std::function<void(const LmzTestClient*, const Model::DemoHsfSixTestRequest&, const DemoHsfSixTestOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DemoHsfSixTestAsyncHandler;
typedef Outcome<Error, Model::DemoHttpComplexResponseResult> DemoHttpComplexResponseOutcome;
typedef std::future<DemoHttpComplexResponseOutcome> DemoHttpComplexResponseOutcomeCallable;
typedef std::function<void(const LmzTestClient*, const Model::DemoHttpComplexResponseRequest&, const DemoHttpComplexResponseOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DemoHttpComplexResponseAsyncHandler;
typedef Outcome<Error, Model::DescribeDisksResult> DescribeDisksOutcome;
typedef std::future<DescribeDisksOutcome> DescribeDisksOutcomeCallable;
typedef std::function<void(const LmzTestClient*, const Model::DescribeDisksRequest&, const DescribeDisksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDisksAsyncHandler;
typedef Outcome<Error, Model::GetPackageStorageCredentialResult> GetPackageStorageCredentialOutcome;
typedef std::future<GetPackageStorageCredentialOutcome> GetPackageStorageCredentialOutcomeCallable;
typedef std::function<void(const LmzTestClient*, const Model::GetPackageStorageCredentialRequest&, const GetPackageStorageCredentialOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetPackageStorageCredentialAsyncHandler;
typedef Outcome<Error, Model::GrayReleaseDemoResult> GrayReleaseDemoOutcome;
typedef std::future<GrayReleaseDemoOutcome> GrayReleaseDemoOutcomeCallable;
typedef std::function<void(const LmzTestClient*, const Model::GrayReleaseDemoRequest&, const GrayReleaseDemoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GrayReleaseDemoAsyncHandler;
typedef Outcome<Error, Model::ListProductsByPopCodeResult> ListProductsByPopCodeOutcome;
typedef std::future<ListProductsByPopCodeOutcome> ListProductsByPopCodeOutcomeCallable;
typedef std::function<void(const LmzTestClient*, const Model::ListProductsByPopCodeRequest&, const ListProductsByPopCodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListProductsByPopCodeAsyncHandler;
typedef Outcome<Error, Model::LjxTestResult> LjxTestOutcome;
typedef std::future<LjxTestOutcome> LjxTestOutcomeCallable;
typedef std::function<void(const LmzTestClient*, const Model::LjxTestRequest&, const LjxTestOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> LjxTestAsyncHandler;
typedef Outcome<Error, Model::ReqBeanTestResult> ReqBeanTestOutcome;
typedef std::future<ReqBeanTestOutcome> ReqBeanTestOutcomeCallable;
typedef std::function<void(const LmzTestClient*, const Model::ReqBeanTestRequest&, const ReqBeanTestOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReqBeanTestAsyncHandler;
typedef Outcome<Error, Model::RomeGetExecutionResultResult> RomeGetExecutionResultOutcome;
typedef std::future<RomeGetExecutionResultOutcome> RomeGetExecutionResultOutcomeCallable;
typedef std::function<void(const LmzTestClient*, const Model::RomeGetExecutionResultRequest&, const RomeGetExecutionResultOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RomeGetExecutionResultAsyncHandler;
typedef Outcome<Error, Model::RpcHttpResult> RpcHttpOutcome;
typedef std::future<RpcHttpOutcome> RpcHttpOutcomeCallable;
typedef std::function<void(const LmzTestClient*, const Model::RpcHttpRequest&, const RpcHttpOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RpcHttpAsyncHandler;
typedef Outcome<Error, Model::TestPutApiAndGetApiResult> TestPutApiAndGetApiOutcome;
typedef std::future<TestPutApiAndGetApiOutcome> TestPutApiAndGetApiOutcomeCallable;
typedef std::function<void(const LmzTestClient*, const Model::TestPutApiAndGetApiRequest&, const TestPutApiAndGetApiOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TestPutApiAndGetApiAsyncHandler;
typedef Outcome<Error, Model::UpdateListenerResult> UpdateListenerOutcome;
typedef std::future<UpdateListenerOutcome> UpdateListenerOutcomeCallable;
typedef std::function<void(const LmzTestClient*, const Model::UpdateListenerRequest&, const UpdateListenerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateListenerAsyncHandler;
LmzTestClient(const Credentials &credentials, const ClientConfiguration &configuration);
LmzTestClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
LmzTestClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~LmzTestClient();
AAbckOutcome aAbck(const Model::AAbckRequest &request)const;
void aAbckAsync(const Model::AAbckRequest& request, const AAbckAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AAbckOutcomeCallable aAbckCallable(const Model::AAbckRequest& request) const;
AndBackOutcome andBack(const Model::AndBackRequest &request)const;
void andBackAsync(const Model::AndBackRequest& request, const AndBackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AndBackOutcomeCallable andBackCallable(const Model::AndBackRequest& request) const;
DataRateLimitTestOutcome dataRateLimitTest(const Model::DataRateLimitTestRequest &request)const;
void dataRateLimitTestAsync(const Model::DataRateLimitTestRequest& request, const DataRateLimitTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DataRateLimitTestOutcomeCallable dataRateLimitTestCallable(const Model::DataRateLimitTestRequest& request) const;
DemoGrayReleaseTestOutcome demoGrayReleaseTest(const Model::DemoGrayReleaseTestRequest &request)const;
void demoGrayReleaseTestAsync(const Model::DemoGrayReleaseTestRequest& request, const DemoGrayReleaseTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DemoGrayReleaseTestOutcomeCallable demoGrayReleaseTestCallable(const Model::DemoGrayReleaseTestRequest& request) const;
DemoGrayReleaseTestTwoOutcome demoGrayReleaseTestTwo(const Model::DemoGrayReleaseTestTwoRequest &request)const;
void demoGrayReleaseTestTwoAsync(const Model::DemoGrayReleaseTestTwoRequest& request, const DemoGrayReleaseTestTwoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DemoGrayReleaseTestTwoOutcomeCallable demoGrayReleaseTestTwoCallable(const Model::DemoGrayReleaseTestTwoRequest& request) const;
DemoGreyReleaseTestOutcome demoGreyReleaseTest(const Model::DemoGreyReleaseTestRequest &request)const;
void demoGreyReleaseTestAsync(const Model::DemoGreyReleaseTestRequest& request, const DemoGreyReleaseTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DemoGreyReleaseTestOutcomeCallable demoGreyReleaseTestCallable(const Model::DemoGreyReleaseTestRequest& request) const;
DemoHsfNineResponseOutcome demoHsfNineResponse(const Model::DemoHsfNineResponseRequest &request)const;
void demoHsfNineResponseAsync(const Model::DemoHsfNineResponseRequest& request, const DemoHsfNineResponseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DemoHsfNineResponseOutcomeCallable demoHsfNineResponseCallable(const Model::DemoHsfNineResponseRequest& request) const;
DemoHsfSixTestOutcome demoHsfSixTest(const Model::DemoHsfSixTestRequest &request)const;
void demoHsfSixTestAsync(const Model::DemoHsfSixTestRequest& request, const DemoHsfSixTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DemoHsfSixTestOutcomeCallable demoHsfSixTestCallable(const Model::DemoHsfSixTestRequest& request) const;
DemoHttpComplexResponseOutcome demoHttpComplexResponse(const Model::DemoHttpComplexResponseRequest &request)const;
void demoHttpComplexResponseAsync(const Model::DemoHttpComplexResponseRequest& request, const DemoHttpComplexResponseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DemoHttpComplexResponseOutcomeCallable demoHttpComplexResponseCallable(const Model::DemoHttpComplexResponseRequest& request) const;
DescribeDisksOutcome describeDisks(const Model::DescribeDisksRequest &request)const;
void describeDisksAsync(const Model::DescribeDisksRequest& request, const DescribeDisksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDisksOutcomeCallable describeDisksCallable(const Model::DescribeDisksRequest& request) const;
GetPackageStorageCredentialOutcome getPackageStorageCredential(const Model::GetPackageStorageCredentialRequest &request)const;
void getPackageStorageCredentialAsync(const Model::GetPackageStorageCredentialRequest& request, const GetPackageStorageCredentialAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetPackageStorageCredentialOutcomeCallable getPackageStorageCredentialCallable(const Model::GetPackageStorageCredentialRequest& request) const;
GrayReleaseDemoOutcome grayReleaseDemo(const Model::GrayReleaseDemoRequest &request)const;
void grayReleaseDemoAsync(const Model::GrayReleaseDemoRequest& request, const GrayReleaseDemoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GrayReleaseDemoOutcomeCallable grayReleaseDemoCallable(const Model::GrayReleaseDemoRequest& request) const;
ListProductsByPopCodeOutcome listProductsByPopCode(const Model::ListProductsByPopCodeRequest &request)const;
void listProductsByPopCodeAsync(const Model::ListProductsByPopCodeRequest& request, const ListProductsByPopCodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListProductsByPopCodeOutcomeCallable listProductsByPopCodeCallable(const Model::ListProductsByPopCodeRequest& request) const;
LjxTestOutcome ljxTest(const Model::LjxTestRequest &request)const;
void ljxTestAsync(const Model::LjxTestRequest& request, const LjxTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
LjxTestOutcomeCallable ljxTestCallable(const Model::LjxTestRequest& request) const;
ReqBeanTestOutcome reqBeanTest(const Model::ReqBeanTestRequest &request)const;
void reqBeanTestAsync(const Model::ReqBeanTestRequest& request, const ReqBeanTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ReqBeanTestOutcomeCallable reqBeanTestCallable(const Model::ReqBeanTestRequest& request) const;
RomeGetExecutionResultOutcome romeGetExecutionResult(const Model::RomeGetExecutionResultRequest &request)const;
void romeGetExecutionResultAsync(const Model::RomeGetExecutionResultRequest& request, const RomeGetExecutionResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RomeGetExecutionResultOutcomeCallable romeGetExecutionResultCallable(const Model::RomeGetExecutionResultRequest& request) const;
RpcHttpOutcome rpcHttp(const Model::RpcHttpRequest &request)const;
void rpcHttpAsync(const Model::RpcHttpRequest& request, const RpcHttpAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RpcHttpOutcomeCallable rpcHttpCallable(const Model::RpcHttpRequest& request) const;
TestPutApiAndGetApiOutcome testPutApiAndGetApi(const Model::TestPutApiAndGetApiRequest &request)const;
void testPutApiAndGetApiAsync(const Model::TestPutApiAndGetApiRequest& request, const TestPutApiAndGetApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
TestPutApiAndGetApiOutcomeCallable testPutApiAndGetApiCallable(const Model::TestPutApiAndGetApiRequest& request) const;
UpdateListenerOutcome updateListener(const Model::UpdateListenerRequest &request)const;
void updateListenerAsync(const Model::UpdateListenerRequest& request, const UpdateListenerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateListenerOutcomeCallable updateListenerCallable(const Model::UpdateListenerRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_LMZTEST_LMZTESTCLIENT_H_

View File

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

View File

@@ -1,45 +0,0 @@
/*
* 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_LMZTEST_MODEL_AABCKREQUEST_H_
#define ALIBABACLOUD_LMZTEST_MODEL_AABCKREQUEST_H_
#include <alibabacloud/lmztest/LmzTestExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace LmzTest {
namespace Model {
class ALIBABACLOUD_LMZTEST_EXPORT AAbckRequest : public RpcServiceRequest {
public:
AAbckRequest();
~AAbckRequest();
std::string getClientToken3() const;
void setClientToken3(const std::string &clientToken3);
std::string getTestDemo() const;
void setTestDemo(const std::string &testDemo);
private:
std::string clientToken3_;
std::string testDemo_;
};
} // namespace Model
} // namespace LmzTest
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_LMZTEST_MODEL_AABCKREQUEST_H_

View File

@@ -1,51 +0,0 @@
/*
* 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_LMZTEST_MODEL_AABCKRESULT_H_
#define ALIBABACLOUD_LMZTEST_MODEL_AABCKRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/lmztest/LmzTestExport.h>
namespace AlibabaCloud
{
namespace LmzTest
{
namespace Model
{
class ALIBABACLOUD_LMZTEST_EXPORT AAbckResult : public ServiceResult
{
public:
AAbckResult();
explicit AAbckResult(const std::string &payload);
~AAbckResult();
std::string getId()const;
protected:
void parse(const std::string &payload);
private:
std::string id_;
};
}
}
}
#endif // !ALIBABACLOUD_LMZTEST_MODEL_AABCKRESULT_H_

View File

@@ -1,45 +0,0 @@
/*
* 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_LMZTEST_MODEL_ANDBACKREQUEST_H_
#define ALIBABACLOUD_LMZTEST_MODEL_ANDBACKREQUEST_H_
#include <alibabacloud/lmztest/LmzTestExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace LmzTest {
namespace Model {
class ALIBABACLOUD_LMZTEST_EXPORT AndBackRequest : public RpcServiceRequest {
public:
AndBackRequest();
~AndBackRequest();
std::string getClientToken2() const;
void setClientToken2(const std::string &clientToken2);
std::string getTestDemo() const;
void setTestDemo(const std::string &testDemo);
private:
std::string clientToken2_;
std::string testDemo_;
};
} // namespace Model
} // namespace LmzTest
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_LMZTEST_MODEL_ANDBACKREQUEST_H_

View File

@@ -1,49 +0,0 @@
/*
* 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_LMZTEST_MODEL_ANDBACKRESULT_H_
#define ALIBABACLOUD_LMZTEST_MODEL_ANDBACKRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/lmztest/LmzTestExport.h>
namespace AlibabaCloud
{
namespace LmzTest
{
namespace Model
{
class ALIBABACLOUD_LMZTEST_EXPORT AndBackResult : public ServiceResult
{
public:
AndBackResult();
explicit AndBackResult(const std::string &payload);
~AndBackResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LMZTEST_MODEL_ANDBACKRESULT_H_

View File

@@ -1,39 +0,0 @@
/*
* 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_LMZTEST_MODEL_DATARATELIMITTESTREQUEST_H_
#define ALIBABACLOUD_LMZTEST_MODEL_DATARATELIMITTESTREQUEST_H_
#include <alibabacloud/lmztest/LmzTestExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace LmzTest {
namespace Model {
class ALIBABACLOUD_LMZTEST_EXPORT DataRateLimitTestRequest : public RpcServiceRequest {
public:
DataRateLimitTestRequest();
~DataRateLimitTestRequest();
private:
};
} // namespace Model
} // namespace LmzTest
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_LMZTEST_MODEL_DATARATELIMITTESTREQUEST_H_

View File

@@ -1,49 +0,0 @@
/*
* 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_LMZTEST_MODEL_DATARATELIMITTESTRESULT_H_
#define ALIBABACLOUD_LMZTEST_MODEL_DATARATELIMITTESTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/lmztest/LmzTestExport.h>
namespace AlibabaCloud
{
namespace LmzTest
{
namespace Model
{
class ALIBABACLOUD_LMZTEST_EXPORT DataRateLimitTestResult : public ServiceResult
{
public:
DataRateLimitTestResult();
explicit DataRateLimitTestResult(const std::string &payload);
~DataRateLimitTestResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LMZTEST_MODEL_DATARATELIMITTESTRESULT_H_

View File

@@ -1,45 +0,0 @@
/*
* 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_LMZTEST_MODEL_DEMOGRAYRELEASETESTREQUEST_H_
#define ALIBABACLOUD_LMZTEST_MODEL_DEMOGRAYRELEASETESTREQUEST_H_
#include <alibabacloud/lmztest/LmzTestExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace LmzTest {
namespace Model {
class ALIBABACLOUD_LMZTEST_EXPORT DemoGrayReleaseTestRequest : public RpcServiceRequest {
public:
DemoGrayReleaseTestRequest();
~DemoGrayReleaseTestRequest();
int getNumberCode() const;
void setNumberCode(int numberCode);
std::string getId() const;
void setId(const std::string &id);
private:
int numberCode_;
std::string id_;
};
} // namespace Model
} // namespace LmzTest
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_LMZTEST_MODEL_DEMOGRAYRELEASETESTREQUEST_H_

View File

@@ -1,53 +0,0 @@
/*
* 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_LMZTEST_MODEL_DEMOGRAYRELEASETESTRESULT_H_
#define ALIBABACLOUD_LMZTEST_MODEL_DEMOGRAYRELEASETESTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/lmztest/LmzTestExport.h>
namespace AlibabaCloud
{
namespace LmzTest
{
namespace Model
{
class ALIBABACLOUD_LMZTEST_EXPORT DemoGrayReleaseTestResult : public ServiceResult
{
public:
DemoGrayReleaseTestResult();
explicit DemoGrayReleaseTestResult(const std::string &payload);
~DemoGrayReleaseTestResult();
std::string getCode()const;
std::string getName()const;
protected:
void parse(const std::string &payload);
private:
std::string code_;
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_LMZTEST_MODEL_DEMOGRAYRELEASETESTRESULT_H_

View File

@@ -1,45 +0,0 @@
/*
* 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_LMZTEST_MODEL_DEMOGRAYRELEASETESTTWOREQUEST_H_
#define ALIBABACLOUD_LMZTEST_MODEL_DEMOGRAYRELEASETESTTWOREQUEST_H_
#include <alibabacloud/lmztest/LmzTestExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace LmzTest {
namespace Model {
class ALIBABACLOUD_LMZTEST_EXPORT DemoGrayReleaseTestTwoRequest : public RpcServiceRequest {
public:
DemoGrayReleaseTestTwoRequest();
~DemoGrayReleaseTestTwoRequest();
std::string getNumberCode() const;
void setNumberCode(const std::string &numberCode);
long getCode() const;
void setCode(long code);
private:
std::string numberCode_;
long code_;
};
} // namespace Model
} // namespace LmzTest
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_LMZTEST_MODEL_DEMOGRAYRELEASETESTTWOREQUEST_H_

View File

@@ -1,49 +0,0 @@
/*
* 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_LMZTEST_MODEL_DEMOGRAYRELEASETESTTWORESULT_H_
#define ALIBABACLOUD_LMZTEST_MODEL_DEMOGRAYRELEASETESTTWORESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/lmztest/LmzTestExport.h>
namespace AlibabaCloud
{
namespace LmzTest
{
namespace Model
{
class ALIBABACLOUD_LMZTEST_EXPORT DemoGrayReleaseTestTwoResult : public ServiceResult
{
public:
DemoGrayReleaseTestTwoResult();
explicit DemoGrayReleaseTestTwoResult(const std::string &payload);
~DemoGrayReleaseTestTwoResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LMZTEST_MODEL_DEMOGRAYRELEASETESTTWORESULT_H_

View File

@@ -1,42 +0,0 @@
/*
* 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_LMZTEST_MODEL_DEMOGREYRELEASETESTREQUEST_H_
#define ALIBABACLOUD_LMZTEST_MODEL_DEMOGREYRELEASETESTREQUEST_H_
#include <alibabacloud/lmztest/LmzTestExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace LmzTest {
namespace Model {
class ALIBABACLOUD_LMZTEST_EXPORT DemoGreyReleaseTestRequest : public RpcServiceRequest {
public:
DemoGreyReleaseTestRequest();
~DemoGreyReleaseTestRequest();
long getNumber() const;
void setNumber(long number);
private:
long number_;
};
} // namespace Model
} // namespace LmzTest
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_LMZTEST_MODEL_DEMOGREYRELEASETESTREQUEST_H_

View File

@@ -1,51 +0,0 @@
/*
* 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_LMZTEST_MODEL_DEMOGREYRELEASETESTRESULT_H_
#define ALIBABACLOUD_LMZTEST_MODEL_DEMOGREYRELEASETESTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/lmztest/LmzTestExport.h>
namespace AlibabaCloud
{
namespace LmzTest
{
namespace Model
{
class ALIBABACLOUD_LMZTEST_EXPORT DemoGreyReleaseTestResult : public ServiceResult
{
public:
DemoGreyReleaseTestResult();
explicit DemoGreyReleaseTestResult(const std::string &payload);
~DemoGreyReleaseTestResult();
std::string getId()const;
protected:
void parse(const std::string &payload);
private:
std::string id_;
};
}
}
}
#endif // !ALIBABACLOUD_LMZTEST_MODEL_DEMOGREYRELEASETESTRESULT_H_

View File

@@ -1,54 +0,0 @@
/*
* 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_LMZTEST_MODEL_DEMOHSFNINERESPONSEREQUEST_H_
#define ALIBABACLOUD_LMZTEST_MODEL_DEMOHSFNINERESPONSEREQUEST_H_
#include <alibabacloud/lmztest/LmzTestExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace LmzTest {
namespace Model {
class ALIBABACLOUD_LMZTEST_EXPORT DemoHsfNineResponseRequest : public RpcServiceRequest {
public:
struct UserMap {
std::string uaa;
std::string uas;
std::string name;
std::string id;
};
DemoHsfNineResponseRequest();
~DemoHsfNineResponseRequest();
std::string getName() const;
void setName(const std::string &name);
std::string getTestF1() const;
void setTestF1(const std::string &testF1);
std::map<std::string, userMap> getUserMap() const;
void setUserMap(const std::map<std::string, userMap> &userMap);
private:
std::string name_;
std::string testF1_;
std::map<std::string, userMap> userMap_;
};
} // namespace Model
} // namespace LmzTest
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_LMZTEST_MODEL_DEMOHSFNINERESPONSEREQUEST_H_

View File

@@ -1,55 +0,0 @@
/*
* 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_LMZTEST_MODEL_DEMOHSFNINERESPONSERESULT_H_
#define ALIBABACLOUD_LMZTEST_MODEL_DEMOHSFNINERESPONSERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/lmztest/LmzTestExport.h>
namespace AlibabaCloud
{
namespace LmzTest
{
namespace Model
{
class ALIBABACLOUD_LMZTEST_EXPORT DemoHsfNineResponseResult : public ServiceResult
{
public:
DemoHsfNineResponseResult();
explicit DemoHsfNineResponseResult(const std::string &payload);
~DemoHsfNineResponseResult();
std::string getId()const;
std::vector<std::string> getInfos()const;
std::string getName()const;
protected:
void parse(const std::string &payload);
private:
std::string id_;
std::vector<std::string> infos_;
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_LMZTEST_MODEL_DEMOHSFNINERESPONSERESULT_H_

View File

@@ -1,55 +0,0 @@
/*
* 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_LMZTEST_MODEL_DEMOHSFSIXTESTREQUEST_H_
#define ALIBABACLOUD_LMZTEST_MODEL_DEMOHSFSIXTESTREQUEST_H_
#include <alibabacloud/lmztest/LmzTestExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace LmzTest {
namespace Model {
class ALIBABACLOUD_LMZTEST_EXPORT DemoHsfSixTestRequest : public RpcServiceRequest {
public:
struct CodeMap {
std::string name;
std::string id;
};
DemoHsfSixTestRequest();
~DemoHsfSixTestRequest();
std::vector<std::map<std::string, std::map<std::string, ObjectOfAny>>> getStrListMap() const;
void setStrListMap(const std::vector<std::map<std::string, std::map<std::string, ObjectOfAny>>> &strListMap);
std::string getData() const;
void setData(const std::string &data);
std::string getMap() const;
void setMap(const std::string &map);
std::map<std::string, codeMap> getCodeMap() const;
void setCodeMap(const std::map<std::string, codeMap> &codeMap);
private:
std::vector<std::map<std::string, std::map<std::string, ObjectOfAny>>> strListMap_;
std::string data_;
std::string map_;
std::map<std::string, codeMap> codeMap_;
};
} // namespace Model
} // namespace LmzTest
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_LMZTEST_MODEL_DEMOHSFSIXTESTREQUEST_H_

View File

@@ -1,57 +0,0 @@
/*
* 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_LMZTEST_MODEL_DEMOHSFSIXTESTRESULT_H_
#define ALIBABACLOUD_LMZTEST_MODEL_DEMOHSFSIXTESTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/lmztest/LmzTestExport.h>
namespace AlibabaCloud
{
namespace LmzTest
{
namespace Model
{
class ALIBABACLOUD_LMZTEST_EXPORT DemoHsfSixTestResult : public ServiceResult
{
public:
DemoHsfSixTestResult();
explicit DemoHsfSixTestResult(const std::string &payload);
~DemoHsfSixTestResult();
std::vector<std::string> getData()const;
std::string getId()const;
std::string getCode()const;
std::string getName()const;
protected:
void parse(const std::string &payload);
private:
std::vector<std::string> data_;
std::string id_;
std::string code_;
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_LMZTEST_MODEL_DEMOHSFSIXTESTRESULT_H_

View File

@@ -1,42 +0,0 @@
/*
* 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_LMZTEST_MODEL_DEMOHTTPCOMPLEXRESPONSEREQUEST_H_
#define ALIBABACLOUD_LMZTEST_MODEL_DEMOHTTPCOMPLEXRESPONSEREQUEST_H_
#include <alibabacloud/lmztest/LmzTestExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace LmzTest {
namespace Model {
class ALIBABACLOUD_LMZTEST_EXPORT DemoHttpComplexResponseRequest : public RpcServiceRequest {
public:
DemoHttpComplexResponseRequest();
~DemoHttpComplexResponseRequest();
std::string getReqInfo() const;
void setReqInfo(const std::string &reqInfo);
private:
std::string reqInfo_;
};
} // namespace Model
} // namespace LmzTest
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_LMZTEST_MODEL_DEMOHTTPCOMPLEXRESPONSEREQUEST_H_

View File

@@ -1,55 +0,0 @@
/*
* 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_LMZTEST_MODEL_DEMOHTTPCOMPLEXRESPONSERESULT_H_
#define ALIBABACLOUD_LMZTEST_MODEL_DEMOHTTPCOMPLEXRESPONSERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/lmztest/LmzTestExport.h>
namespace AlibabaCloud
{
namespace LmzTest
{
namespace Model
{
class ALIBABACLOUD_LMZTEST_EXPORT DemoHttpComplexResponseResult : public ServiceResult
{
public:
DemoHttpComplexResponseResult();
explicit DemoHttpComplexResponseResult(const std::string &payload);
~DemoHttpComplexResponseResult();
std::string getId()const;
std::vector<std::string> getInfos()const;
std::string getName()const;
protected:
void parse(const std::string &payload);
private:
std::string id_;
std::vector<std::string> infos_;
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_LMZTEST_MODEL_DEMOHTTPCOMPLEXRESPONSERESULT_H_

View File

@@ -1,154 +0,0 @@
/*
* 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_LMZTEST_MODEL_DESCRIBEDISKSREQUEST_H_
#define ALIBABACLOUD_LMZTEST_MODEL_DESCRIBEDISKSREQUEST_H_
#include <alibabacloud/lmztest/LmzTestExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace LmzTest {
namespace Model {
class ALIBABACLOUD_LMZTEST_EXPORT DescribeDisksRequest : public RpcServiceRequest {
public:
struct Tag {
std::string value;
std::string key;
};
DescribeDisksRequest();
~DescribeDisksRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getFilter2Value() const;
void setFilter2Value(const std::string &filter2Value);
std::string getAutoSnapshotPolicyId() const;
void setAutoSnapshotPolicyId(const std::string &autoSnapshotPolicyId);
std::string getDiskName() const;
void setDiskName(const std::string &diskName);
bool getDeleteAutoSnapshot() const;
void setDeleteAutoSnapshot(bool deleteAutoSnapshot);
std::string getResourceGroupId() const;
void setResourceGroupId(const std::string &resourceGroupId);
std::string getDiskChargeType() const;
void setDiskChargeType(const std::string &diskChargeType);
std::string getLockReason() const;
void setLockReason(const std::string &lockReason);
std::string getFilter1Key() const;
void setFilter1Key(const std::string &filter1Key);
std::vector<Tag> getTag() const;
void setTag(const std::vector<Tag> &tag);
bool getEnableAutoSnapshot() const;
void setEnableAutoSnapshot(bool enableAutoSnapshot);
bool getDryRun() const;
void setDryRun(bool dryRun);
std::string getFilter1Value() const;
void setFilter1Value(const std::string &filter1Value);
bool getPortable() const;
void setPortable(bool portable);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::vector<std::string> getAdditionalAttributes() const;
void setAdditionalAttributes(const std::vector<std::string> &additionalAttributes);
std::string getInstanceId() const;
void setInstanceId(const std::string &instanceId);
std::string getZoneId() const;
void setZoneId(const std::string &zoneId);
int getMaxResults() const;
void setMaxResults(int maxResults);
std::string getStatus() const;
void setStatus(const std::string &status);
std::string getSnapshotId() const;
void setSnapshotId(const std::string &snapshotId);
int getPageNumber() const;
void setPageNumber(int pageNumber);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getNextToken() const;
void setNextToken(const std::string &nextToken);
int getPageSize() const;
void setPageSize(int pageSize);
std::string getDiskIds() const;
void setDiskIds(const std::string &diskIds);
std::string getMultiAttach() const;
void setMultiAttach(const std::string &multiAttach);
bool getDeleteWithInstance() const;
void setDeleteWithInstance(bool deleteWithInstance);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
bool getEnableAutomatedSnapshotPolicy() const;
void setEnableAutomatedSnapshotPolicy(bool enableAutomatedSnapshotPolicy);
std::string getFilter2Key() const;
void setFilter2Key(const std::string &filter2Key);
std::string getDiskType() const;
void setDiskType(const std::string &diskType);
bool getEnableShared() const;
void setEnableShared(bool enableShared);
bool getEncrypted() const;
void setEncrypted(bool encrypted);
std::string getCategory() const;
void setCategory(const std::string &category);
std::string getKMSKeyId() const;
void setKMSKeyId(const std::string &kMSKeyId);
private:
long resourceOwnerId_;
std::string filter2Value_;
std::string autoSnapshotPolicyId_;
std::string diskName_;
bool deleteAutoSnapshot_;
std::string resourceGroupId_;
std::string diskChargeType_;
std::string lockReason_;
std::string filter1Key_;
std::vector<Tag> tag_;
bool enableAutoSnapshot_;
bool dryRun_;
std::string filter1Value_;
bool portable_;
long ownerId_;
std::vector<std::string> additionalAttributes_;
std::string instanceId_;
std::string zoneId_;
int maxResults_;
std::string status_;
std::string snapshotId_;
int pageNumber_;
std::string regionId_;
std::string nextToken_;
int pageSize_;
std::string diskIds_;
std::string multiAttach_;
bool deleteWithInstance_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
bool enableAutomatedSnapshotPolicy_;
std::string filter2Key_;
std::string diskType_;
bool enableShared_;
bool encrypted_;
std::string category_;
std::string kMSKeyId_;
};
} // namespace Model
} // namespace LmzTest
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_LMZTEST_MODEL_DESCRIBEDISKSREQUEST_H_

View File

@@ -1,126 +0,0 @@
/*
* 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_LMZTEST_MODEL_DESCRIBEDISKSRESULT_H_
#define ALIBABACLOUD_LMZTEST_MODEL_DESCRIBEDISKSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/lmztest/LmzTestExport.h>
namespace AlibabaCloud
{
namespace LmzTest
{
namespace Model
{
class ALIBABACLOUD_LMZTEST_EXPORT DescribeDisksResult : public ServiceResult
{
public:
struct Disk
{
struct OperationLock
{
std::string lockReason;
};
struct MountInstance
{
std::string attachedTime;
std::string instanceId;
std::string device;
};
struct Tag
{
std::string tagKey;
std::string tagValue;
};
struct Attachment
{
std::string attachedTime;
std::string instanceId;
std::string device;
};
std::string detachedTime;
std::string description;
std::string kMSKeyId;
std::string category;
std::string resourceGroupId;
std::string dedicatedBlockStorageClusterId;
bool encrypted;
int size;
bool deleteAutoSnapshot;
std::string diskChargeType;
int storageSetPartitionNumber;
int iOPS;
std::vector<Disk::Attachment> attachments;
std::string multiAttach;
std::string expiredTime;
std::string imageId;
std::string storageSetId;
std::vector<Disk::Tag> tags;
std::string status;
int iOPSRead;
std::string attachedTime;
int iOPSWrite;
std::string zoneId;
std::string sourceSnapshotId;
std::string instanceId;
std::string productCode;
std::string performanceLevel;
std::string device;
bool deleteWithInstance;
bool enableAutomatedSnapshotPolicy;
bool enableAutoSnapshot;
std::string autoSnapshotPolicyId;
std::string diskName;
std::vector<Disk::OperationLock> operationLocks;
std::string bdfId;
bool portable;
std::string type;
int mountInstanceNum;
std::string serialNumber;
std::vector<Disk::MountInstance> mountInstances;
std::string creationTime;
std::string regionId;
std::string diskId;
};
DescribeDisksResult();
explicit DescribeDisksResult(const std::string &payload);
~DescribeDisksResult();
int getTotalCount()const;
std::string getNextToken()const;
int getPageSize()const;
int getPageNumber()const;
std::vector<Disk> getDisks()const;
protected:
void parse(const std::string &payload);
private:
int totalCount_;
std::string nextToken_;
int pageSize_;
int pageNumber_;
std::vector<Disk> disks_;
};
}
}
}
#endif // !ALIBABACLOUD_LMZTEST_MODEL_DESCRIBEDISKSRESULT_H_

View File

@@ -1,39 +0,0 @@
/*
* 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_LMZTEST_MODEL_GETPACKAGESTORAGECREDENTIALREQUEST_H_
#define ALIBABACLOUD_LMZTEST_MODEL_GETPACKAGESTORAGECREDENTIALREQUEST_H_
#include <alibabacloud/lmztest/LmzTestExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace LmzTest {
namespace Model {
class ALIBABACLOUD_LMZTEST_EXPORT GetPackageStorageCredentialRequest : public RpcServiceRequest {
public:
GetPackageStorageCredentialRequest();
~GetPackageStorageCredentialRequest();
private:
};
} // namespace Model
} // namespace LmzTest
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_LMZTEST_MODEL_GETPACKAGESTORAGECREDENTIALREQUEST_H_

View File

@@ -1,68 +0,0 @@
/*
* 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_LMZTEST_MODEL_GETPACKAGESTORAGECREDENTIALRESULT_H_
#define ALIBABACLOUD_LMZTEST_MODEL_GETPACKAGESTORAGECREDENTIALRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/lmztest/LmzTestExport.h>
namespace AlibabaCloud
{
namespace LmzTest
{
namespace Model
{
class ALIBABACLOUD_LMZTEST_EXPORT GetPackageStorageCredentialResult : public ServiceResult
{
public:
struct Credential
{
std::string securityToken;
std::string ossInternalEndpoint;
std::string bucket;
std::string ossPublicEndpoint;
std::string accessKeyId;
std::string accessKeySecret;
std::string ossVpcEndpoint;
std::string expiration;
std::string regionId;
std::string keyPrefix;
};
GetPackageStorageCredentialResult();
explicit GetPackageStorageCredentialResult(const std::string &payload);
~GetPackageStorageCredentialResult();
Credential getCredential()const;
std::string getMessage()const;
int getCode()const;
protected:
void parse(const std::string &payload);
private:
Credential credential_;
std::string message_;
int code_;
};
}
}
}
#endif // !ALIBABACLOUD_LMZTEST_MODEL_GETPACKAGESTORAGECREDENTIALRESULT_H_

View File

@@ -1,42 +0,0 @@
/*
* 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_LMZTEST_MODEL_GRAYRELEASEDEMOREQUEST_H_
#define ALIBABACLOUD_LMZTEST_MODEL_GRAYRELEASEDEMOREQUEST_H_
#include <alibabacloud/lmztest/LmzTestExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace LmzTest {
namespace Model {
class ALIBABACLOUD_LMZTEST_EXPORT GrayReleaseDemoRequest : public RpcServiceRequest {
public:
GrayReleaseDemoRequest();
~GrayReleaseDemoRequest();
std::string getId() const;
void setId(const std::string &id);
private:
std::string id_;
};
} // namespace Model
} // namespace LmzTest
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_LMZTEST_MODEL_GRAYRELEASEDEMOREQUEST_H_

View File

@@ -1,53 +0,0 @@
/*
* 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_LMZTEST_MODEL_GRAYRELEASEDEMORESULT_H_
#define ALIBABACLOUD_LMZTEST_MODEL_GRAYRELEASEDEMORESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/lmztest/LmzTestExport.h>
namespace AlibabaCloud
{
namespace LmzTest
{
namespace Model
{
class ALIBABACLOUD_LMZTEST_EXPORT GrayReleaseDemoResult : public ServiceResult
{
public:
GrayReleaseDemoResult();
explicit GrayReleaseDemoResult(const std::string &payload);
~GrayReleaseDemoResult();
std::string getYear()const;
std::string getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string year_;
std::string code_;
};
}
}
}
#endif // !ALIBABACLOUD_LMZTEST_MODEL_GRAYRELEASEDEMORESULT_H_

View File

@@ -1,63 +0,0 @@
/*
* 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_LMZTEST_MODEL_LISTPRODUCTSBYPOPCODEREQUEST_H_
#define ALIBABACLOUD_LMZTEST_MODEL_LISTPRODUCTSBYPOPCODEREQUEST_H_
#include <alibabacloud/lmztest/LmzTestExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace LmzTest {
namespace Model {
class ALIBABACLOUD_LMZTEST_EXPORT ListProductsByPopCodeRequest : public RpcServiceRequest {
public:
ListProductsByPopCodeRequest();
~ListProductsByPopCodeRequest();
std::string getAuthKey() const;
void setAuthKey(const std::string &authKey);
std::string getExtraParams() const;
void setExtraParams(const std::string &extraParams);
std::string getServerClientIp() const;
void setServerClientIp(const std::string &serverClientIp);
std::string getRequestId() const;
void setRequestId(const std::string &requestId);
std::string getClientIp() const;
void setClientIp(const std::string &clientIp);
std::string getIdentityDTO() const;
void setIdentityDTO(const std::string &identityDTO);
std::string getEnv() const;
void setEnv(const std::string &env);
std::string getPopCode() const;
void setPopCode(const std::string &popCode);
private:
std::string authKey_;
std::string extraParams_;
std::string serverClientIp_;
std::string requestId_;
std::string clientIp_;
std::string identityDTO_;
std::string env_;
std::string popCode_;
};
} // namespace Model
} // namespace LmzTest
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_LMZTEST_MODEL_LISTPRODUCTSBYPOPCODEREQUEST_H_

View File

@@ -1,87 +0,0 @@
/*
* 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_LMZTEST_MODEL_LISTPRODUCTSBYPOPCODERESULT_H_
#define ALIBABACLOUD_LMZTEST_MODEL_LISTPRODUCTSBYPOPCODERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/lmztest/LmzTestExport.h>
namespace AlibabaCloud
{
namespace LmzTest
{
namespace Model
{
class ALIBABACLOUD_LMZTEST_EXPORT ListProductsByPopCodeResult : public ServiceResult
{
public:
struct ResultItem
{
struct UniqueKeyDTO
{
std::string namespaceCode;
};
struct NameSpaceExtDTO
{
struct BusinessOwnerListItem
{
std::string bucId;
std::string id;
std::string name;
};
struct TechniqueOwnerListItem
{
std::string bucId;
std::string id;
std::string name;
};
std::vector<BusinessOwnerListItem> businessOwnerList;
std::vector<TechniqueOwnerListItem> techniqueOwnerList;
};
UniqueKeyDTO uniqueKeyDTO;
NameSpaceExtDTO nameSpaceExtDTO;
};
ListProductsByPopCodeResult();
explicit ListProductsByPopCodeResult(const std::string &payload);
~ListProductsByPopCodeResult();
std::string getErrorDetailMessage()const;
std::string getTraceId()const;
std::string getErrorCode()const;
std::string getErrorMessage()const;
bool getSuccess()const;
std::vector<ResultItem> getResult()const;
protected:
void parse(const std::string &payload);
private:
std::string errorDetailMessage_;
std::string traceId_;
std::string errorCode_;
std::string errorMessage_;
bool success_;
std::vector<ResultItem> result_;
};
}
}
}
#endif // !ALIBABACLOUD_LMZTEST_MODEL_LISTPRODUCTSBYPOPCODERESULT_H_

View File

@@ -1,54 +0,0 @@
/*
* 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_LMZTEST_MODEL_LJXTESTREQUEST_H_
#define ALIBABACLOUD_LMZTEST_MODEL_LJXTESTREQUEST_H_
#include <alibabacloud/lmztest/LmzTestExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace LmzTest {
namespace Model {
class ALIBABACLOUD_LMZTEST_EXPORT LjxTestRequest : public RpcServiceRequest {
public:
LjxTestRequest();
~LjxTestRequest();
std::string getNewparam2() const;
void setNewparam2(const std::string &newparam2);
std::vector<std::string> getNewparam1() const;
void setNewparam1(const std::vector<std::string> &newparam1);
std::map<std::string, std::string> getCode() const;
void setCode(const std::map<std::string, std::string> &code);
std::string getId() const;
void setId(const std::string &id);
std::string getBody() const;
void setBody(const std::string &body);
private:
std::string newparam2_;
std::vector<std::string> newparam1_;
std::map<std::string, std::string> code_;
std::string id_;
std::string body_;
};
} // namespace Model
} // namespace LmzTest
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_LMZTEST_MODEL_LJXTESTREQUEST_H_

View File

@@ -1,71 +0,0 @@
/*
* 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_LMZTEST_MODEL_LJXTESTRESULT_H_
#define ALIBABACLOUD_LMZTEST_MODEL_LJXTESTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/lmztest/LmzTestExport.h>
namespace AlibabaCloud
{
namespace LmzTest
{
namespace Model
{
class ALIBABACLOUD_LMZTEST_EXPORT LjxTestResult : public ServiceResult
{
public:
struct Testtest
{
std::string id;
};
struct MapsItem
{
std::string param0;
};
LjxTestResult();
explicit LjxTestResult(const std::string &payload);
~LjxTestResult();
std::vector<MapsItem> getMaps()const;
std::vector<std::string> getStringList()const;
Testtest getTesttest()const;
std::vector<std::string> getLongList()const;
std::string getId()const;
int getCode()const;
std::string getName()const;
protected:
void parse(const std::string &payload);
private:
std::vector<MapsItem> maps_;
std::vector<std::string> stringList_;
Testtest testtest_;
std::vector<std::string> longList_;
std::string id_;
int code_;
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_LMZTEST_MODEL_LJXTESTRESULT_H_

View File

@@ -1,58 +0,0 @@
/*
* 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_LMZTEST_MODEL_REQBEANTESTREQUEST_H_
#define ALIBABACLOUD_LMZTEST_MODEL_REQBEANTESTREQUEST_H_
#include <alibabacloud/lmztest/LmzTestExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace LmzTest {
namespace Model {
class ALIBABACLOUD_LMZTEST_EXPORT ReqBeanTestRequest : public RpcServiceRequest {
public:
struct Users {
std::string name;
std::string id;
};
ReqBeanTestRequest();
~ReqBeanTestRequest();
std::vector<std::string> getCodes() const;
void setCodes(const std::vector<std::string> &codes);
std::string getXhostheadertest() const;
void setXhostheadertest(const std::string &xhostheadertest);
std::string getId() const;
void setId(const std::string &id);
std::vector<long> getNums() const;
void setNums(const std::vector<long> &nums);
std::vector<users> getUsers() const;
void setUsers(const std::vector<users> &users);
private:
std::vector<std::string> codes_;
std::string xhostheadertest_;
std::string id_;
std::vector<long> nums_;
std::vector<users> users_;
};
} // namespace Model
} // namespace LmzTest
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_LMZTEST_MODEL_REQBEANTESTREQUEST_H_

View File

@@ -1,53 +0,0 @@
/*
* 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_LMZTEST_MODEL_REQBEANTESTRESULT_H_
#define ALIBABACLOUD_LMZTEST_MODEL_REQBEANTESTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/lmztest/LmzTestExport.h>
namespace AlibabaCloud
{
namespace LmzTest
{
namespace Model
{
class ALIBABACLOUD_LMZTEST_EXPORT ReqBeanTestResult : public ServiceResult
{
public:
ReqBeanTestResult();
explicit ReqBeanTestResult(const std::string &payload);
~ReqBeanTestResult();
std::string getId()const;
std::string getName()const;
protected:
void parse(const std::string &payload);
private:
std::string id_;
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_LMZTEST_MODEL_REQBEANTESTRESULT_H_

View File

@@ -1,42 +0,0 @@
/*
* 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_LMZTEST_MODEL_ROMEGETEXECUTIONRESULTREQUEST_H_
#define ALIBABACLOUD_LMZTEST_MODEL_ROMEGETEXECUTIONRESULTREQUEST_H_
#include <alibabacloud/lmztest/LmzTestExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace LmzTest {
namespace Model {
class ALIBABACLOUD_LMZTEST_EXPORT RomeGetExecutionResultRequest : public RpcServiceRequest {
public:
RomeGetExecutionResultRequest();
~RomeGetExecutionResultRequest();
std::string getFlowRequestId() const;
void setFlowRequestId(const std::string &flowRequestId);
private:
std::string flowRequestId_;
};
} // namespace Model
} // namespace LmzTest
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_LMZTEST_MODEL_ROMEGETEXECUTIONRESULTREQUEST_H_

View File

@@ -1,49 +0,0 @@
/*
* 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_LMZTEST_MODEL_ROMEGETEXECUTIONRESULTRESULT_H_
#define ALIBABACLOUD_LMZTEST_MODEL_ROMEGETEXECUTIONRESULTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/lmztest/LmzTestExport.h>
namespace AlibabaCloud
{
namespace LmzTest
{
namespace Model
{
class ALIBABACLOUD_LMZTEST_EXPORT RomeGetExecutionResultResult : public ServiceResult
{
public:
RomeGetExecutionResultResult();
explicit RomeGetExecutionResultResult(const std::string &payload);
~RomeGetExecutionResultResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LMZTEST_MODEL_ROMEGETEXECUTIONRESULTRESULT_H_

View File

@@ -1,69 +0,0 @@
/*
* 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_LMZTEST_MODEL_RPCHTTPREQUEST_H_
#define ALIBABACLOUD_LMZTEST_MODEL_RPCHTTPREQUEST_H_
#include <alibabacloud/lmztest/LmzTestExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace LmzTest {
namespace Model {
class ALIBABACLOUD_LMZTEST_EXPORT RpcHttpRequest : public RpcServiceRequest {
public:
RpcHttpRequest();
~RpcHttpRequest();
std::string getNews() const;
void setNews(const std::string &news);
std::string getCodes() const;
void setCodes(const std::string &codes);
std::string getNumber() const;
void setNumber(const std::string &number);
std::string getMonkey() const;
void setMonkey(const std::string &monkey);
std::string getWorld() const;
void setWorld(const std::string &world);
std::string getParam() const;
void setParam(const std::string &param);
std::string getOld() const;
void setOld(const std::string &old);
std::string getName() const;
void setName(const std::string &name);
std::string getId() const;
void setId(const std::string &id);
std::string getNone() const;
void setNone(const std::string &none);
private:
std::string news_;
std::string codes_;
std::string number_;
std::string monkey_;
std::string world_;
std::string param_;
std::string old_;
std::string name_;
std::string id_;
std::string none_;
};
} // namespace Model
} // namespace LmzTest
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_LMZTEST_MODEL_RPCHTTPREQUEST_H_

View File

@@ -1,53 +0,0 @@
/*
* 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_LMZTEST_MODEL_RPCHTTPRESULT_H_
#define ALIBABACLOUD_LMZTEST_MODEL_RPCHTTPRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/lmztest/LmzTestExport.h>
namespace AlibabaCloud
{
namespace LmzTest
{
namespace Model
{
class ALIBABACLOUD_LMZTEST_EXPORT RpcHttpResult : public ServiceResult
{
public:
RpcHttpResult();
explicit RpcHttpResult(const std::string &payload);
~RpcHttpResult();
std::string getId()const;
std::string getName()const;
protected:
void parse(const std::string &payload);
private:
std::string id_;
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_LMZTEST_MODEL_RPCHTTPRESULT_H_

View File

@@ -1,39 +0,0 @@
/*
* 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_LMZTEST_MODEL_TESTPUTAPIANDGETAPIREQUEST_H_
#define ALIBABACLOUD_LMZTEST_MODEL_TESTPUTAPIANDGETAPIREQUEST_H_
#include <alibabacloud/lmztest/LmzTestExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace LmzTest {
namespace Model {
class ALIBABACLOUD_LMZTEST_EXPORT TestPutApiAndGetApiRequest : public RpcServiceRequest {
public:
TestPutApiAndGetApiRequest();
~TestPutApiAndGetApiRequest();
private:
};
} // namespace Model
} // namespace LmzTest
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_LMZTEST_MODEL_TESTPUTAPIANDGETAPIREQUEST_H_

View File

@@ -1,49 +0,0 @@
/*
* 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_LMZTEST_MODEL_TESTPUTAPIANDGETAPIRESULT_H_
#define ALIBABACLOUD_LMZTEST_MODEL_TESTPUTAPIANDGETAPIRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/lmztest/LmzTestExport.h>
namespace AlibabaCloud
{
namespace LmzTest
{
namespace Model
{
class ALIBABACLOUD_LMZTEST_EXPORT TestPutApiAndGetApiResult : public ServiceResult
{
public:
TestPutApiAndGetApiResult();
explicit TestPutApiAndGetApiResult(const std::string &payload);
~TestPutApiAndGetApiResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LMZTEST_MODEL_TESTPUTAPIANDGETAPIRESULT_H_

View File

@@ -1,83 +0,0 @@
/*
* 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_LMZTEST_MODEL_UPDATELISTENERREQUEST_H_
#define ALIBABACLOUD_LMZTEST_MODEL_UPDATELISTENERREQUEST_H_
#include <alibabacloud/lmztest/LmzTestExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace LmzTest {
namespace Model {
class ALIBABACLOUD_LMZTEST_EXPORT UpdateListenerRequest : public RpcServiceRequest {
public:
struct BackendPorts {
int fromPort;
int toPort;
};
struct PortRanges {
int fromPort;
int toPort;
};
struct Certificates {
std::string id;
};
UpdateListenerRequest();
~UpdateListenerRequest();
std::string getClientToken() const;
void setClientToken(const std::string &clientToken);
std::string getDescription() const;
void setDescription(const std::string &description);
std::vector<BackendPorts> getBackendPorts() const;
void setBackendPorts(const std::vector<BackendPorts> &backendPorts);
std::string getListenerId() const;
void setListenerId(const std::string &listenerId);
std::string getProtocol() const;
void setProtocol(const std::string &protocol);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getProxyProtocol() const;
void setProxyProtocol(const std::string &proxyProtocol);
std::vector<PortRanges> getPortRanges() const;
void setPortRanges(const std::vector<PortRanges> &portRanges);
std::vector<Certificates> getCertificates() const;
void setCertificates(const std::vector<Certificates> &certificates);
std::string getName() const;
void setName(const std::string &name);
std::string getClientAffinity() const;
void setClientAffinity(const std::string &clientAffinity);
private:
std::string clientToken_;
std::string description_;
std::vector<BackendPorts> backendPorts_;
std::string listenerId_;
std::string protocol_;
std::string regionId_;
std::string proxyProtocol_;
std::vector<PortRanges> portRanges_;
std::vector<Certificates> certificates_;
std::string name_;
std::string clientAffinity_;
};
} // namespace Model
} // namespace LmzTest
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_LMZTEST_MODEL_UPDATELISTENERREQUEST_H_

View File

@@ -1,49 +0,0 @@
/*
* 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_LMZTEST_MODEL_UPDATELISTENERRESULT_H_
#define ALIBABACLOUD_LMZTEST_MODEL_UPDATELISTENERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/lmztest/LmzTestExport.h>
namespace AlibabaCloud
{
namespace LmzTest
{
namespace Model
{
class ALIBABACLOUD_LMZTEST_EXPORT UpdateListenerResult : public ServiceResult
{
public:
UpdateListenerResult();
explicit UpdateListenerResult(const std::string &payload);
~UpdateListenerResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LMZTEST_MODEL_UPDATELISTENERRESULT_H_

View File

@@ -1,737 +0,0 @@
/*
* 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/lmztest/LmzTestClient.h>
#include <alibabacloud/core/SimpleCredentialsProvider.h>
using namespace AlibabaCloud;
using namespace AlibabaCloud::Location;
using namespace AlibabaCloud::LmzTest;
using namespace AlibabaCloud::LmzTest::Model;
namespace
{
const std::string SERVICE_NAME = "LmzTest";
}
LmzTestClient::LmzTestClient(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, "");
}
LmzTestClient::LmzTestClient(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, "");
}
LmzTestClient::LmzTestClient(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, "");
}
LmzTestClient::~LmzTestClient()
{}
LmzTestClient::AAbckOutcome LmzTestClient::aAbck(const AAbckRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return AAbckOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return AAbckOutcome(AAbckResult(outcome.result()));
else
return AAbckOutcome(outcome.error());
}
void LmzTestClient::aAbckAsync(const AAbckRequest& request, const AAbckAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, aAbck(request), context);
};
asyncExecute(new Runnable(fn));
}
LmzTestClient::AAbckOutcomeCallable LmzTestClient::aAbckCallable(const AAbckRequest &request) const
{
auto task = std::make_shared<std::packaged_task<AAbckOutcome()>>(
[this, request]()
{
return this->aAbck(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LmzTestClient::AndBackOutcome LmzTestClient::andBack(const AndBackRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return AndBackOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return AndBackOutcome(AndBackResult(outcome.result()));
else
return AndBackOutcome(outcome.error());
}
void LmzTestClient::andBackAsync(const AndBackRequest& request, const AndBackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, andBack(request), context);
};
asyncExecute(new Runnable(fn));
}
LmzTestClient::AndBackOutcomeCallable LmzTestClient::andBackCallable(const AndBackRequest &request) const
{
auto task = std::make_shared<std::packaged_task<AndBackOutcome()>>(
[this, request]()
{
return this->andBack(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LmzTestClient::DataRateLimitTestOutcome LmzTestClient::dataRateLimitTest(const DataRateLimitTestRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DataRateLimitTestOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DataRateLimitTestOutcome(DataRateLimitTestResult(outcome.result()));
else
return DataRateLimitTestOutcome(outcome.error());
}
void LmzTestClient::dataRateLimitTestAsync(const DataRateLimitTestRequest& request, const DataRateLimitTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, dataRateLimitTest(request), context);
};
asyncExecute(new Runnable(fn));
}
LmzTestClient::DataRateLimitTestOutcomeCallable LmzTestClient::dataRateLimitTestCallable(const DataRateLimitTestRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DataRateLimitTestOutcome()>>(
[this, request]()
{
return this->dataRateLimitTest(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LmzTestClient::DemoGrayReleaseTestOutcome LmzTestClient::demoGrayReleaseTest(const DemoGrayReleaseTestRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DemoGrayReleaseTestOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DemoGrayReleaseTestOutcome(DemoGrayReleaseTestResult(outcome.result()));
else
return DemoGrayReleaseTestOutcome(outcome.error());
}
void LmzTestClient::demoGrayReleaseTestAsync(const DemoGrayReleaseTestRequest& request, const DemoGrayReleaseTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, demoGrayReleaseTest(request), context);
};
asyncExecute(new Runnable(fn));
}
LmzTestClient::DemoGrayReleaseTestOutcomeCallable LmzTestClient::demoGrayReleaseTestCallable(const DemoGrayReleaseTestRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DemoGrayReleaseTestOutcome()>>(
[this, request]()
{
return this->demoGrayReleaseTest(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LmzTestClient::DemoGrayReleaseTestTwoOutcome LmzTestClient::demoGrayReleaseTestTwo(const DemoGrayReleaseTestTwoRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DemoGrayReleaseTestTwoOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DemoGrayReleaseTestTwoOutcome(DemoGrayReleaseTestTwoResult(outcome.result()));
else
return DemoGrayReleaseTestTwoOutcome(outcome.error());
}
void LmzTestClient::demoGrayReleaseTestTwoAsync(const DemoGrayReleaseTestTwoRequest& request, const DemoGrayReleaseTestTwoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, demoGrayReleaseTestTwo(request), context);
};
asyncExecute(new Runnable(fn));
}
LmzTestClient::DemoGrayReleaseTestTwoOutcomeCallable LmzTestClient::demoGrayReleaseTestTwoCallable(const DemoGrayReleaseTestTwoRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DemoGrayReleaseTestTwoOutcome()>>(
[this, request]()
{
return this->demoGrayReleaseTestTwo(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LmzTestClient::DemoGreyReleaseTestOutcome LmzTestClient::demoGreyReleaseTest(const DemoGreyReleaseTestRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DemoGreyReleaseTestOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DemoGreyReleaseTestOutcome(DemoGreyReleaseTestResult(outcome.result()));
else
return DemoGreyReleaseTestOutcome(outcome.error());
}
void LmzTestClient::demoGreyReleaseTestAsync(const DemoGreyReleaseTestRequest& request, const DemoGreyReleaseTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, demoGreyReleaseTest(request), context);
};
asyncExecute(new Runnable(fn));
}
LmzTestClient::DemoGreyReleaseTestOutcomeCallable LmzTestClient::demoGreyReleaseTestCallable(const DemoGreyReleaseTestRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DemoGreyReleaseTestOutcome()>>(
[this, request]()
{
return this->demoGreyReleaseTest(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LmzTestClient::DemoHsfNineResponseOutcome LmzTestClient::demoHsfNineResponse(const DemoHsfNineResponseRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DemoHsfNineResponseOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DemoHsfNineResponseOutcome(DemoHsfNineResponseResult(outcome.result()));
else
return DemoHsfNineResponseOutcome(outcome.error());
}
void LmzTestClient::demoHsfNineResponseAsync(const DemoHsfNineResponseRequest& request, const DemoHsfNineResponseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, demoHsfNineResponse(request), context);
};
asyncExecute(new Runnable(fn));
}
LmzTestClient::DemoHsfNineResponseOutcomeCallable LmzTestClient::demoHsfNineResponseCallable(const DemoHsfNineResponseRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DemoHsfNineResponseOutcome()>>(
[this, request]()
{
return this->demoHsfNineResponse(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LmzTestClient::DemoHsfSixTestOutcome LmzTestClient::demoHsfSixTest(const DemoHsfSixTestRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DemoHsfSixTestOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DemoHsfSixTestOutcome(DemoHsfSixTestResult(outcome.result()));
else
return DemoHsfSixTestOutcome(outcome.error());
}
void LmzTestClient::demoHsfSixTestAsync(const DemoHsfSixTestRequest& request, const DemoHsfSixTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, demoHsfSixTest(request), context);
};
asyncExecute(new Runnable(fn));
}
LmzTestClient::DemoHsfSixTestOutcomeCallable LmzTestClient::demoHsfSixTestCallable(const DemoHsfSixTestRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DemoHsfSixTestOutcome()>>(
[this, request]()
{
return this->demoHsfSixTest(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LmzTestClient::DemoHttpComplexResponseOutcome LmzTestClient::demoHttpComplexResponse(const DemoHttpComplexResponseRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DemoHttpComplexResponseOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DemoHttpComplexResponseOutcome(DemoHttpComplexResponseResult(outcome.result()));
else
return DemoHttpComplexResponseOutcome(outcome.error());
}
void LmzTestClient::demoHttpComplexResponseAsync(const DemoHttpComplexResponseRequest& request, const DemoHttpComplexResponseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, demoHttpComplexResponse(request), context);
};
asyncExecute(new Runnable(fn));
}
LmzTestClient::DemoHttpComplexResponseOutcomeCallable LmzTestClient::demoHttpComplexResponseCallable(const DemoHttpComplexResponseRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DemoHttpComplexResponseOutcome()>>(
[this, request]()
{
return this->demoHttpComplexResponse(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LmzTestClient::DescribeDisksOutcome LmzTestClient::describeDisks(const DescribeDisksRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeDisksOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeDisksOutcome(DescribeDisksResult(outcome.result()));
else
return DescribeDisksOutcome(outcome.error());
}
void LmzTestClient::describeDisksAsync(const DescribeDisksRequest& request, const DescribeDisksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeDisks(request), context);
};
asyncExecute(new Runnable(fn));
}
LmzTestClient::DescribeDisksOutcomeCallable LmzTestClient::describeDisksCallable(const DescribeDisksRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeDisksOutcome()>>(
[this, request]()
{
return this->describeDisks(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LmzTestClient::GetPackageStorageCredentialOutcome LmzTestClient::getPackageStorageCredential(const GetPackageStorageCredentialRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetPackageStorageCredentialOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetPackageStorageCredentialOutcome(GetPackageStorageCredentialResult(outcome.result()));
else
return GetPackageStorageCredentialOutcome(outcome.error());
}
void LmzTestClient::getPackageStorageCredentialAsync(const GetPackageStorageCredentialRequest& request, const GetPackageStorageCredentialAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getPackageStorageCredential(request), context);
};
asyncExecute(new Runnable(fn));
}
LmzTestClient::GetPackageStorageCredentialOutcomeCallable LmzTestClient::getPackageStorageCredentialCallable(const GetPackageStorageCredentialRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetPackageStorageCredentialOutcome()>>(
[this, request]()
{
return this->getPackageStorageCredential(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LmzTestClient::GrayReleaseDemoOutcome LmzTestClient::grayReleaseDemo(const GrayReleaseDemoRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GrayReleaseDemoOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GrayReleaseDemoOutcome(GrayReleaseDemoResult(outcome.result()));
else
return GrayReleaseDemoOutcome(outcome.error());
}
void LmzTestClient::grayReleaseDemoAsync(const GrayReleaseDemoRequest& request, const GrayReleaseDemoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, grayReleaseDemo(request), context);
};
asyncExecute(new Runnable(fn));
}
LmzTestClient::GrayReleaseDemoOutcomeCallable LmzTestClient::grayReleaseDemoCallable(const GrayReleaseDemoRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GrayReleaseDemoOutcome()>>(
[this, request]()
{
return this->grayReleaseDemo(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LmzTestClient::ListProductsByPopCodeOutcome LmzTestClient::listProductsByPopCode(const ListProductsByPopCodeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListProductsByPopCodeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListProductsByPopCodeOutcome(ListProductsByPopCodeResult(outcome.result()));
else
return ListProductsByPopCodeOutcome(outcome.error());
}
void LmzTestClient::listProductsByPopCodeAsync(const ListProductsByPopCodeRequest& request, const ListProductsByPopCodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listProductsByPopCode(request), context);
};
asyncExecute(new Runnable(fn));
}
LmzTestClient::ListProductsByPopCodeOutcomeCallable LmzTestClient::listProductsByPopCodeCallable(const ListProductsByPopCodeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListProductsByPopCodeOutcome()>>(
[this, request]()
{
return this->listProductsByPopCode(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LmzTestClient::LjxTestOutcome LmzTestClient::ljxTest(const LjxTestRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return LjxTestOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return LjxTestOutcome(LjxTestResult(outcome.result()));
else
return LjxTestOutcome(outcome.error());
}
void LmzTestClient::ljxTestAsync(const LjxTestRequest& request, const LjxTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, ljxTest(request), context);
};
asyncExecute(new Runnable(fn));
}
LmzTestClient::LjxTestOutcomeCallable LmzTestClient::ljxTestCallable(const LjxTestRequest &request) const
{
auto task = std::make_shared<std::packaged_task<LjxTestOutcome()>>(
[this, request]()
{
return this->ljxTest(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LmzTestClient::ReqBeanTestOutcome LmzTestClient::reqBeanTest(const ReqBeanTestRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ReqBeanTestOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ReqBeanTestOutcome(ReqBeanTestResult(outcome.result()));
else
return ReqBeanTestOutcome(outcome.error());
}
void LmzTestClient::reqBeanTestAsync(const ReqBeanTestRequest& request, const ReqBeanTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, reqBeanTest(request), context);
};
asyncExecute(new Runnable(fn));
}
LmzTestClient::ReqBeanTestOutcomeCallable LmzTestClient::reqBeanTestCallable(const ReqBeanTestRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ReqBeanTestOutcome()>>(
[this, request]()
{
return this->reqBeanTest(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LmzTestClient::RomeGetExecutionResultOutcome LmzTestClient::romeGetExecutionResult(const RomeGetExecutionResultRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RomeGetExecutionResultOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RomeGetExecutionResultOutcome(RomeGetExecutionResultResult(outcome.result()));
else
return RomeGetExecutionResultOutcome(outcome.error());
}
void LmzTestClient::romeGetExecutionResultAsync(const RomeGetExecutionResultRequest& request, const RomeGetExecutionResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, romeGetExecutionResult(request), context);
};
asyncExecute(new Runnable(fn));
}
LmzTestClient::RomeGetExecutionResultOutcomeCallable LmzTestClient::romeGetExecutionResultCallable(const RomeGetExecutionResultRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RomeGetExecutionResultOutcome()>>(
[this, request]()
{
return this->romeGetExecutionResult(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LmzTestClient::RpcHttpOutcome LmzTestClient::rpcHttp(const RpcHttpRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RpcHttpOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RpcHttpOutcome(RpcHttpResult(outcome.result()));
else
return RpcHttpOutcome(outcome.error());
}
void LmzTestClient::rpcHttpAsync(const RpcHttpRequest& request, const RpcHttpAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, rpcHttp(request), context);
};
asyncExecute(new Runnable(fn));
}
LmzTestClient::RpcHttpOutcomeCallable LmzTestClient::rpcHttpCallable(const RpcHttpRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RpcHttpOutcome()>>(
[this, request]()
{
return this->rpcHttp(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LmzTestClient::TestPutApiAndGetApiOutcome LmzTestClient::testPutApiAndGetApi(const TestPutApiAndGetApiRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return TestPutApiAndGetApiOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return TestPutApiAndGetApiOutcome(TestPutApiAndGetApiResult(outcome.result()));
else
return TestPutApiAndGetApiOutcome(outcome.error());
}
void LmzTestClient::testPutApiAndGetApiAsync(const TestPutApiAndGetApiRequest& request, const TestPutApiAndGetApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, testPutApiAndGetApi(request), context);
};
asyncExecute(new Runnable(fn));
}
LmzTestClient::TestPutApiAndGetApiOutcomeCallable LmzTestClient::testPutApiAndGetApiCallable(const TestPutApiAndGetApiRequest &request) const
{
auto task = std::make_shared<std::packaged_task<TestPutApiAndGetApiOutcome()>>(
[this, request]()
{
return this->testPutApiAndGetApi(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
LmzTestClient::UpdateListenerOutcome LmzTestClient::updateListener(const UpdateListenerRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpdateListenerOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpdateListenerOutcome(UpdateListenerResult(outcome.result()));
else
return UpdateListenerOutcome(outcome.error());
}
void LmzTestClient::updateListenerAsync(const UpdateListenerRequest& request, const UpdateListenerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, updateListener(request), context);
};
asyncExecute(new Runnable(fn));
}
LmzTestClient::UpdateListenerOutcomeCallable LmzTestClient::updateListenerCallable(const UpdateListenerRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpdateListenerOutcome()>>(
[this, request]()
{
return this->updateListener(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}

View File

@@ -1,45 +0,0 @@
/*
* 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/lmztest/model/AAbckRequest.h>
using AlibabaCloud::LmzTest::Model::AAbckRequest;
AAbckRequest::AAbckRequest()
: RpcServiceRequest("lmztest", "2010-10-11", "AAbck") {
setMethod(HttpRequest::Method::Get);
}
AAbckRequest::~AAbckRequest() {}
std::string AAbckRequest::getClientToken3() const {
return clientToken3_;
}
void AAbckRequest::setClientToken3(const std::string &clientToken3) {
clientToken3_ = clientToken3;
setParameter(std::string("ClientToken3"), clientToken3);
}
std::string AAbckRequest::getTestDemo() const {
return testDemo_;
}
void AAbckRequest::setTestDemo(const std::string &testDemo) {
testDemo_ = testDemo;
setParameter(std::string("TestDemo"), testDemo);
}

View File

@@ -1,51 +0,0 @@
/*
* 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/lmztest/model/AAbckResult.h>
#include <json/json.h>
using namespace AlibabaCloud::LmzTest;
using namespace AlibabaCloud::LmzTest::Model;
AAbckResult::AAbckResult() :
ServiceResult()
{}
AAbckResult::AAbckResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
AAbckResult::~AAbckResult()
{}
void AAbckResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["id"].isNull())
id_ = value["id"].asString();
}
std::string AAbckResult::getId()const
{
return id_;
}

Some files were not shown because too many files have changed in this diff Show More