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

Generated 2021-01-01 for Ft.

Browse Source
This commit is contained in:
sdk-team
2023-08-14 04:21:44 +00:00
parent 76afd2bcdc
commit 50bb4d85aa
59 changed files with 738 additions and 2433 deletions
Download Patch File Download Diff File Expand all files Collapse all files

72
ft/CMakeLists.txt
View File

@@ -21,57 +21,33 @@ set(ft_public_header
include/alibabacloud/ft/FtExport.h )
set(ft_public_header_model
include/alibabacloud/ft/model/BatchAuditTest01Request.h
include/alibabacloud/ft/model/BatchAuditTest01Result.h
include/alibabacloud/ft/model/FTApiAliasApiRequest.h
include/alibabacloud/ft/model/FTApiAliasApiResult.h
include/alibabacloud/ft/model/FtDynamicAddressDubboRequest.h
include/alibabacloud/ft/model/FtDynamicAddressDubboResult.h
include/alibabacloud/ft/model/FtDynamicAddressHsfRequest.h
include/alibabacloud/ft/model/FtDynamicAddressHsfResult.h
include/alibabacloud/ft/model/FtDynamicAddressHttpVpcRequest.h
include/alibabacloud/ft/model/FtDynamicAddressHttpVpcResult.h
include/alibabacloud/ft/model/FtEagleEyeRequest.h
include/alibabacloud/ft/model/FtEagleEyeResult.h
include/alibabacloud/ft/model/FtFlowSpecialRequest.h
include/alibabacloud/ft/model/FtFlowSpecialResult.h
include/alibabacloud/ft/model/FtGatedLaunchPolicy4Request.h
include/alibabacloud/ft/model/FtGatedLaunchPolicy4Result.h
include/alibabacloud/ft/model/FtIpFlowControlRequest.h
include/alibabacloud/ft/model/FtIpFlowControlResult.h
include/alibabacloud/ft/model/FtParamListRequest.h
include/alibabacloud/ft/model/FtParamListResult.h
include/alibabacloud/ft/model/TestFlowStrategy01Request.h
include/alibabacloud/ft/model/TestFlowStrategy01Result.h
include/alibabacloud/ft/model/TestHttpApiRequest.h
include/alibabacloud/ft/model/TestHttpApiResult.h )
include/alibabacloud/ft/model/DataRateLimitTestRequest.h
include/alibabacloud/ft/model/DataRateLimitTestResult.h
include/alibabacloud/ft/model/NormalRpcHsfApiRequest.h
include/alibabacloud/ft/model/NormalRpcHsfApiResult.h
include/alibabacloud/ft/model/NormalRpcHttpApiRequest.h
include/alibabacloud/ft/model/NormalRpcHttpApiResult.h
include/alibabacloud/ft/model/RpcDataUploadRequest.h
include/alibabacloud/ft/model/RpcDataUploadResult.h
include/alibabacloud/ft/model/RpcDataUploadAndDownloadRequest.h
include/alibabacloud/ft/model/RpcDataUploadAndDownloadResult.h
include/alibabacloud/ft/model/RpcDataUploadTestRequest.h
include/alibabacloud/ft/model/RpcDataUploadTestResult.h )
set(ft_src
src/FtClient.cc
src/model/BatchAuditTest01Request.cc
src/model/BatchAuditTest01Result.cc
src/model/FTApiAliasApiRequest.cc
src/model/FTApiAliasApiResult.cc
src/model/FtDynamicAddressDubboRequest.cc
src/model/FtDynamicAddressDubboResult.cc
src/model/FtDynamicAddressHsfRequest.cc
src/model/FtDynamicAddressHsfResult.cc
src/model/FtDynamicAddressHttpVpcRequest.cc
src/model/FtDynamicAddressHttpVpcResult.cc
src/model/FtEagleEyeRequest.cc
src/model/FtEagleEyeResult.cc
src/model/FtFlowSpecialRequest.cc
src/model/FtFlowSpecialResult.cc
src/model/FtGatedLaunchPolicy4Request.cc
src/model/FtGatedLaunchPolicy4Result.cc
src/model/FtIpFlowControlRequest.cc
src/model/FtIpFlowControlResult.cc
src/model/FtParamListRequest.cc
src/model/FtParamListResult.cc
src/model/TestFlowStrategy01Request.cc
src/model/TestFlowStrategy01Result.cc
src/model/TestHttpApiRequest.cc
src/model/TestHttpApiResult.cc )
src/model/DataRateLimitTestRequest.cc
src/model/DataRateLimitTestResult.cc
src/model/NormalRpcHsfApiRequest.cc
src/model/NormalRpcHsfApiResult.cc
src/model/NormalRpcHttpApiRequest.cc
src/model/NormalRpcHttpApiResult.cc
src/model/RpcDataUploadRequest.cc
src/model/RpcDataUploadResult.cc
src/model/RpcDataUploadAndDownloadRequest.cc
src/model/RpcDataUploadAndDownloadResult.cc
src/model/RpcDataUploadTestRequest.cc
src/model/RpcDataUploadTestResult.cc )
add_library(ft ${LIB_TYPE}
${ft_public_header}

144
ft/include/alibabacloud/ft/FtClient.h
View File

@@ -22,30 +22,18 @@
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "FtExport.h"
#include "model/BatchAuditTest01Request.h"
#include "model/BatchAuditTest01Result.h"
#include "model/FTApiAliasApiRequest.h"
#include "model/FTApiAliasApiResult.h"
#include "model/FtDynamicAddressDubboRequest.h"
#include "model/FtDynamicAddressDubboResult.h"
#include "model/FtDynamicAddressHsfRequest.h"
#include "model/FtDynamicAddressHsfResult.h"
#include "model/FtDynamicAddressHttpVpcRequest.h"
#include "model/FtDynamicAddressHttpVpcResult.h"
#include "model/FtEagleEyeRequest.h"
#include "model/FtEagleEyeResult.h"
#include "model/FtFlowSpecialRequest.h"
#include "model/FtFlowSpecialResult.h"
#include "model/FtGatedLaunchPolicy4Request.h"
#include "model/FtGatedLaunchPolicy4Result.h"
#include "model/FtIpFlowControlRequest.h"
#include "model/FtIpFlowControlResult.h"
#include "model/FtParamListRequest.h"
#include "model/FtParamListResult.h"
#include "model/TestFlowStrategy01Request.h"
#include "model/TestFlowStrategy01Result.h"
#include "model/TestHttpApiRequest.h"
#include "model/TestHttpApiResult.h"
#include "model/DataRateLimitTestRequest.h"
#include "model/DataRateLimitTestResult.h"
#include "model/NormalRpcHsfApiRequest.h"
#include "model/NormalRpcHsfApiResult.h"
#include "model/NormalRpcHttpApiRequest.h"
#include "model/NormalRpcHttpApiResult.h"
#include "model/RpcDataUploadRequest.h"
#include "model/RpcDataUploadResult.h"
#include "model/RpcDataUploadAndDownloadRequest.h"
#include "model/RpcDataUploadAndDownloadResult.h"
#include "model/RpcDataUploadTestRequest.h"
#include "model/RpcDataUploadTestResult.h"
namespace AlibabaCloud
@@ -55,83 +43,47 @@ namespace AlibabaCloud
class ALIBABACLOUD_FT_EXPORT FtClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::BatchAuditTest01Result> BatchAuditTest01Outcome;
typedef std::future<BatchAuditTest01Outcome> BatchAuditTest01OutcomeCallable;
typedef std::function<void(const FtClient*, const Model::BatchAuditTest01Request&, const BatchAuditTest01Outcome&, const std::shared_ptr<const AsyncCallerContext>&)> BatchAuditTest01AsyncHandler;
typedef Outcome<Error, Model::FTApiAliasApiResult> FTApiAliasApiOutcome;
typedef std::future<FTApiAliasApiOutcome> FTApiAliasApiOutcomeCallable;
typedef std::function<void(const FtClient*, const Model::FTApiAliasApiRequest&, const FTApiAliasApiOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> FTApiAliasApiAsyncHandler;
typedef Outcome<Error, Model::FtDynamicAddressDubboResult> FtDynamicAddressDubboOutcome;
typedef std::future<FtDynamicAddressDubboOutcome> FtDynamicAddressDubboOutcomeCallable;
typedef std::function<void(const FtClient*, const Model::FtDynamicAddressDubboRequest&, const FtDynamicAddressDubboOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> FtDynamicAddressDubboAsyncHandler;
typedef Outcome<Error, Model::FtDynamicAddressHsfResult> FtDynamicAddressHsfOutcome;
typedef std::future<FtDynamicAddressHsfOutcome> FtDynamicAddressHsfOutcomeCallable;
typedef std::function<void(const FtClient*, const Model::FtDynamicAddressHsfRequest&, const FtDynamicAddressHsfOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> FtDynamicAddressHsfAsyncHandler;
typedef Outcome<Error, Model::FtDynamicAddressHttpVpcResult> FtDynamicAddressHttpVpcOutcome;
typedef std::future<FtDynamicAddressHttpVpcOutcome> FtDynamicAddressHttpVpcOutcomeCallable;
typedef std::function<void(const FtClient*, const Model::FtDynamicAddressHttpVpcRequest&, const FtDynamicAddressHttpVpcOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> FtDynamicAddressHttpVpcAsyncHandler;
typedef Outcome<Error, Model::FtEagleEyeResult> FtEagleEyeOutcome;
typedef std::future<FtEagleEyeOutcome> FtEagleEyeOutcomeCallable;
typedef std::function<void(const FtClient*, const Model::FtEagleEyeRequest&, const FtEagleEyeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> FtEagleEyeAsyncHandler;
typedef Outcome<Error, Model::FtFlowSpecialResult> FtFlowSpecialOutcome;
typedef std::future<FtFlowSpecialOutcome> FtFlowSpecialOutcomeCallable;
typedef std::function<void(const FtClient*, const Model::FtFlowSpecialRequest&, const FtFlowSpecialOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> FtFlowSpecialAsyncHandler;
typedef Outcome<Error, Model::FtGatedLaunchPolicy4Result> FtGatedLaunchPolicy4Outcome;
typedef std::future<FtGatedLaunchPolicy4Outcome> FtGatedLaunchPolicy4OutcomeCallable;
typedef std::function<void(const FtClient*, const Model::FtGatedLaunchPolicy4Request&, const FtGatedLaunchPolicy4Outcome&, const std::shared_ptr<const AsyncCallerContext>&)> FtGatedLaunchPolicy4AsyncHandler;
typedef Outcome<Error, Model::FtIpFlowControlResult> FtIpFlowControlOutcome;
typedef std::future<FtIpFlowControlOutcome> FtIpFlowControlOutcomeCallable;
typedef std::function<void(const FtClient*, const Model::FtIpFlowControlRequest&, const FtIpFlowControlOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> FtIpFlowControlAsyncHandler;
typedef Outcome<Error, Model::FtParamListResult> FtParamListOutcome;
typedef std::future<FtParamListOutcome> FtParamListOutcomeCallable;
typedef std::function<void(const FtClient*, const Model::FtParamListRequest&, const FtParamListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> FtParamListAsyncHandler;
typedef Outcome<Error, Model::TestFlowStrategy01Result> TestFlowStrategy01Outcome;
typedef std::future<TestFlowStrategy01Outcome> TestFlowStrategy01OutcomeCallable;
typedef std::function<void(const FtClient*, const Model::TestFlowStrategy01Request&, const TestFlowStrategy01Outcome&, const std::shared_ptr<const AsyncCallerContext>&)> TestFlowStrategy01AsyncHandler;
typedef Outcome<Error, Model::TestHttpApiResult> TestHttpApiOutcome;
typedef std::future<TestHttpApiOutcome> TestHttpApiOutcomeCallable;
typedef std::function<void(const FtClient*, const Model::TestHttpApiRequest&, const TestHttpApiOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TestHttpApiAsyncHandler;
typedef Outcome<Error, Model::DataRateLimitTestResult> DataRateLimitTestOutcome;
typedef std::future<DataRateLimitTestOutcome> DataRateLimitTestOutcomeCallable;
typedef std::function<void(const FtClient*, const Model::DataRateLimitTestRequest&, const DataRateLimitTestOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DataRateLimitTestAsyncHandler;
typedef Outcome<Error, Model::NormalRpcHsfApiResult> NormalRpcHsfApiOutcome;
typedef std::future<NormalRpcHsfApiOutcome> NormalRpcHsfApiOutcomeCallable;
typedef std::function<void(const FtClient*, const Model::NormalRpcHsfApiRequest&, const NormalRpcHsfApiOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> NormalRpcHsfApiAsyncHandler;
typedef Outcome<Error, Model::NormalRpcHttpApiResult> NormalRpcHttpApiOutcome;
typedef std::future<NormalRpcHttpApiOutcome> NormalRpcHttpApiOutcomeCallable;
typedef std::function<void(const FtClient*, const Model::NormalRpcHttpApiRequest&, const NormalRpcHttpApiOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> NormalRpcHttpApiAsyncHandler;
typedef Outcome<Error, Model::RpcDataUploadResult> RpcDataUploadOutcome;
typedef std::future<RpcDataUploadOutcome> RpcDataUploadOutcomeCallable;
typedef std::function<void(const FtClient*, const Model::RpcDataUploadRequest&, const RpcDataUploadOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RpcDataUploadAsyncHandler;
typedef Outcome<Error, Model::RpcDataUploadAndDownloadResult> RpcDataUploadAndDownloadOutcome;
typedef std::future<RpcDataUploadAndDownloadOutcome> RpcDataUploadAndDownloadOutcomeCallable;
typedef std::function<void(const FtClient*, const Model::RpcDataUploadAndDownloadRequest&, const RpcDataUploadAndDownloadOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RpcDataUploadAndDownloadAsyncHandler;
typedef Outcome<Error, Model::RpcDataUploadTestResult> RpcDataUploadTestOutcome;
typedef std::future<RpcDataUploadTestOutcome> RpcDataUploadTestOutcomeCallable;
typedef std::function<void(const FtClient*, const Model::RpcDataUploadTestRequest&, const RpcDataUploadTestOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RpcDataUploadTestAsyncHandler;
FtClient(const Credentials &credentials, const ClientConfiguration &configuration);
FtClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
FtClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~FtClient();
BatchAuditTest01Outcome batchAuditTest01(const Model::BatchAuditTest01Request &request)const;
void batchAuditTest01Async(const Model::BatchAuditTest01Request& request, const BatchAuditTest01AsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
BatchAuditTest01OutcomeCallable batchAuditTest01Callable(const Model::BatchAuditTest01Request& request) const;
FTApiAliasApiOutcome fTApiAliasApi(const Model::FTApiAliasApiRequest &request)const;
void fTApiAliasApiAsync(const Model::FTApiAliasApiRequest& request, const FTApiAliasApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
FTApiAliasApiOutcomeCallable fTApiAliasApiCallable(const Model::FTApiAliasApiRequest& request) const;
FtDynamicAddressDubboOutcome ftDynamicAddressDubbo(const Model::FtDynamicAddressDubboRequest &request)const;
void ftDynamicAddressDubboAsync(const Model::FtDynamicAddressDubboRequest& request, const FtDynamicAddressDubboAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
FtDynamicAddressDubboOutcomeCallable ftDynamicAddressDubboCallable(const Model::FtDynamicAddressDubboRequest& request) const;
FtDynamicAddressHsfOutcome ftDynamicAddressHsf(const Model::FtDynamicAddressHsfRequest &request)const;
void ftDynamicAddressHsfAsync(const Model::FtDynamicAddressHsfRequest& request, const FtDynamicAddressHsfAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
FtDynamicAddressHsfOutcomeCallable ftDynamicAddressHsfCallable(const Model::FtDynamicAddressHsfRequest& request) const;
FtDynamicAddressHttpVpcOutcome ftDynamicAddressHttpVpc(const Model::FtDynamicAddressHttpVpcRequest &request)const;
void ftDynamicAddressHttpVpcAsync(const Model::FtDynamicAddressHttpVpcRequest& request, const FtDynamicAddressHttpVpcAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
FtDynamicAddressHttpVpcOutcomeCallable ftDynamicAddressHttpVpcCallable(const Model::FtDynamicAddressHttpVpcRequest& request) const;
FtEagleEyeOutcome ftEagleEye(const Model::FtEagleEyeRequest &request)const;
void ftEagleEyeAsync(const Model::FtEagleEyeRequest& request, const FtEagleEyeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
FtEagleEyeOutcomeCallable ftEagleEyeCallable(const Model::FtEagleEyeRequest& request) const;
FtFlowSpecialOutcome ftFlowSpecial(const Model::FtFlowSpecialRequest &request)const;
void ftFlowSpecialAsync(const Model::FtFlowSpecialRequest& request, const FtFlowSpecialAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
FtFlowSpecialOutcomeCallable ftFlowSpecialCallable(const Model::FtFlowSpecialRequest& request) const;
FtGatedLaunchPolicy4Outcome ftGatedLaunchPolicy4(const Model::FtGatedLaunchPolicy4Request &request)const;
void ftGatedLaunchPolicy4Async(const Model::FtGatedLaunchPolicy4Request& request, const FtGatedLaunchPolicy4AsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
FtGatedLaunchPolicy4OutcomeCallable ftGatedLaunchPolicy4Callable(const Model::FtGatedLaunchPolicy4Request& request) const;
FtIpFlowControlOutcome ftIpFlowControl(const Model::FtIpFlowControlRequest &request)const;
void ftIpFlowControlAsync(const Model::FtIpFlowControlRequest& request, const FtIpFlowControlAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
FtIpFlowControlOutcomeCallable ftIpFlowControlCallable(const Model::FtIpFlowControlRequest& request) const;
FtParamListOutcome ftParamList(const Model::FtParamListRequest &request)const;
void ftParamListAsync(const Model::FtParamListRequest& request, const FtParamListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
FtParamListOutcomeCallable ftParamListCallable(const Model::FtParamListRequest& request) const;
TestFlowStrategy01Outcome testFlowStrategy01(const Model::TestFlowStrategy01Request &request)const;
void testFlowStrategy01Async(const Model::TestFlowStrategy01Request& request, const TestFlowStrategy01AsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
TestFlowStrategy01OutcomeCallable testFlowStrategy01Callable(const Model::TestFlowStrategy01Request& request) const;
TestHttpApiOutcome testHttpApi(const Model::TestHttpApiRequest &request)const;
void testHttpApiAsync(const Model::TestHttpApiRequest& request, const TestHttpApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
TestHttpApiOutcomeCallable testHttpApiCallable(const Model::TestHttpApiRequest& 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;
NormalRpcHsfApiOutcome normalRpcHsfApi(const Model::NormalRpcHsfApiRequest &request)const;
void normalRpcHsfApiAsync(const Model::NormalRpcHsfApiRequest& request, const NormalRpcHsfApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
NormalRpcHsfApiOutcomeCallable normalRpcHsfApiCallable(const Model::NormalRpcHsfApiRequest& request) const;
NormalRpcHttpApiOutcome normalRpcHttpApi(const Model::NormalRpcHttpApiRequest &request)const;
void normalRpcHttpApiAsync(const Model::NormalRpcHttpApiRequest& request, const NormalRpcHttpApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
NormalRpcHttpApiOutcomeCallable normalRpcHttpApiCallable(const Model::NormalRpcHttpApiRequest& request) const;
RpcDataUploadOutcome rpcDataUpload(const Model::RpcDataUploadRequest &request)const;
void rpcDataUploadAsync(const Model::RpcDataUploadRequest& request, const RpcDataUploadAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RpcDataUploadOutcomeCallable rpcDataUploadCallable(const Model::RpcDataUploadRequest& request) const;
RpcDataUploadAndDownloadOutcome rpcDataUploadAndDownload(const Model::RpcDataUploadAndDownloadRequest &request)const;
void rpcDataUploadAndDownloadAsync(const Model::RpcDataUploadAndDownloadRequest& request, const RpcDataUploadAndDownloadAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RpcDataUploadAndDownloadOutcomeCallable rpcDataUploadAndDownloadCallable(const Model::RpcDataUploadAndDownloadRequest& request) const;
RpcDataUploadTestOutcome rpcDataUploadTest(const Model::RpcDataUploadTestRequest &request)const;
void rpcDataUploadTestAsync(const Model::RpcDataUploadTestRequest& request, const RpcDataUploadTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RpcDataUploadTestOutcomeCallable rpcDataUploadTestCallable(const Model::RpcDataUploadTestRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;

57
ft/include/alibabacloud/ft/model/BatchAuditTest01Request.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_FT_MODEL_BATCHAUDITTEST01REQUEST_H_
#define ALIBABACLOUD_FT_MODEL_BATCHAUDITTEST01REQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ft/FtExport.h>
namespace AlibabaCloud
{
namespace Ft
{
namespace Model
{
class ALIBABACLOUD_FT_EXPORT BatchAuditTest01Request : public RpcServiceRequest
{
public:
BatchAuditTest01Request();
~BatchAuditTest01Request();
std::string getDemo01()const;
void setDemo01(const std::string& demo01);
bool getTest010101()const;
void setTest010101(bool test010101);
std::string getName()const;
void setName(const std::string& name);
std::string getBatchAuditTest01()const;
void setBatchAuditTest01(const std::string& batchAuditTest01);
private:
std::string demo01_;
bool test010101_;
std::string name_;
std::string batchAuditTest01_;
};
}
}
}
#endif // !ALIBABACLOUD_FT_MODEL_BATCHAUDITTEST01REQUEST_H_

61
ft/include/alibabacloud/ft/model/BatchAuditTest01Result.h
View File

@@ -1,61 +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_FT_MODEL_BATCHAUDITTEST01RESULT_H_
#define ALIBABACLOUD_FT_MODEL_BATCHAUDITTEST01RESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ft/FtExport.h>
namespace AlibabaCloud
{
namespace Ft
{
namespace Model
{
class ALIBABACLOUD_FT_EXPORT BatchAuditTest01Result : public ServiceResult
{
public:
struct Demo01
{
struct Demo011Item
{
std::string demo0111;
};
std::vector<Demo011Item> demo011;
};
BatchAuditTest01Result();
explicit BatchAuditTest01Result(const std::string &payload);
~BatchAuditTest01Result();
Demo01 getDemo01()const;
std::string getName()const;
protected:
void parse(const std::string &payload);
private:
Demo01 demo01_;
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_FT_MODEL_BATCHAUDITTEST01RESULT_H_

51
ft/include/alibabacloud/ft/model/DataRateLimitTestRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FT_MODEL_DATARATELIMITTESTREQUEST_H_
#define ALIBABACLOUD_FT_MODEL_DATARATELIMITTESTREQUEST_H_
#include <alibabacloud/ft/FtExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ft {
namespace Model {
class ALIBABACLOUD_FT_EXPORT DataRateLimitTestRequest : public RpcServiceRequest {
public:
DataRateLimitTestRequest();
~DataRateLimitTestRequest();
std::string getNewparam2() const;
void setNewparam2(const std::string &newparam2);
std::string getNewparam1() const;
void setNewparam1(const std::string &newparam1);
std::string getData() const;
void setData(const std::string &data);
std::string getMap() const;
void setMap(const std::string &map);
private:
std::string newparam2_;
std::string newparam1_;
std::string data_;
std::string map_;
};
} // namespace Model
} // namespace Ft
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_FT_MODEL_DATARATELIMITTESTREQUEST_H_

16
ft/include/alibabacloud/ft/model/FtParamListResult.h → ft/include/alibabacloud/ft/model/DataRateLimitTestResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FT_MODEL_FTPARAMLISTRESULT_H_
#define ALIBABACLOUD_FT_MODEL_FTPARAMLISTRESULT_H_
#ifndef ALIBABACLOUD_FT_MODEL_DATARATELIMITTESTRESULT_H_
#define ALIBABACLOUD_FT_MODEL_DATARATELIMITTESTRESULT_H_
#include <string>
#include <vector>
@@ -29,23 +29,21 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_FT_EXPORT FtParamListResult : public ServiceResult
class ALIBABACLOUD_FT_EXPORT DataRateLimitTestResult : public ServiceResult
{
public:
FtParamListResult();
explicit FtParamListResult(const std::string &payload);
~FtParamListResult();
std::string getName()const;
DataRateLimitTestResult();
explicit DataRateLimitTestResult(const std::string &payload);
~DataRateLimitTestResult();
protected:
void parse(const std::string &payload);
private:
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_FT_MODEL_FTPARAMLISTRESULT_H_
#endif // !ALIBABACLOUD_FT_MODEL_DATARATELIMITTESTRESULT_H_

51
ft/include/alibabacloud/ft/model/FtDynamicAddressDubboRequest.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_FT_MODEL_FTDYNAMICADDRESSDUBBOREQUEST_H_
#define ALIBABACLOUD_FT_MODEL_FTDYNAMICADDRESSDUBBOREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ft/FtExport.h>
namespace AlibabaCloud
{
namespace Ft
{
namespace Model
{
class ALIBABACLOUD_FT_EXPORT FtDynamicAddressDubboRequest : public RpcServiceRequest
{
public:
FtDynamicAddressDubboRequest();
~FtDynamicAddressDubboRequest();
int getIntValue()const;
void setIntValue(int intValue);
std::string getStringValue()const;
void setStringValue(const std::string& stringValue);
private:
int intValue_;
std::string stringValue_;
};
}
}
}
#endif // !ALIBABACLOUD_FT_MODEL_FTDYNAMICADDRESSDUBBOREQUEST_H_

53
ft/include/alibabacloud/ft/model/FtDynamicAddressDubboResult.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_FT_MODEL_FTDYNAMICADDRESSDUBBORESULT_H_
#define ALIBABACLOUD_FT_MODEL_FTDYNAMICADDRESSDUBBORESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ft/FtExport.h>
namespace AlibabaCloud
{
namespace Ft
{
namespace Model
{
class ALIBABACLOUD_FT_EXPORT FtDynamicAddressDubboResult : public ServiceResult
{
public:
FtDynamicAddressDubboResult();
explicit FtDynamicAddressDubboResult(const std::string &payload);
~FtDynamicAddressDubboResult();
std::string getStringValue()const;
int getIntValue()const;
protected:
void parse(const std::string &payload);
private:
std::string stringValue_;
int intValue_;
};
}
}
}
#endif // !ALIBABACLOUD_FT_MODEL_FTDYNAMICADDRESSDUBBORESULT_H_

60
ft/include/alibabacloud/ft/model/FtDynamicAddressHttpVpcRequest.h
View File

@@ -1,60 +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_FT_MODEL_FTDYNAMICADDRESSHTTPVPCREQUEST_H_
#define ALIBABACLOUD_FT_MODEL_FTDYNAMICADDRESSHTTPVPCREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ft/FtExport.h>
namespace AlibabaCloud
{
namespace Ft
{
namespace Model
{
class ALIBABACLOUD_FT_EXPORT FtDynamicAddressHttpVpcRequest : public RpcServiceRequest
{
public:
FtDynamicAddressHttpVpcRequest();
~FtDynamicAddressHttpVpcRequest();
std::string getP1()const;
void setP1(const std::string& p1);
std::string getStringValue()const;
void setStringValue(const std::string& stringValue);
std::string getOtherParam()const;
void setOtherParam(const std::string& otherParam);
bool getBooleanParam()const;
void setBooleanParam(bool booleanParam);
std::string getDefaultValue()const;
void setDefaultValue(const std::string& defaultValue);
private:
std::string p1_;
std::string stringValue_;
std::string otherParam_;
bool booleanParam_;
std::string defaultValue_;
};
}
}
}
#endif // !ALIBABACLOUD_FT_MODEL_FTDYNAMICADDRESSHTTPVPCREQUEST_H_

53
ft/include/alibabacloud/ft/model/FtEagleEyeResult.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_FT_MODEL_FTEAGLEEYERESULT_H_
#define ALIBABACLOUD_FT_MODEL_FTEAGLEEYERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ft/FtExport.h>
namespace AlibabaCloud
{
namespace Ft
{
namespace Model
{
class ALIBABACLOUD_FT_EXPORT FtEagleEyeResult : public ServiceResult
{
public:
FtEagleEyeResult();
explicit FtEagleEyeResult(const std::string &payload);
~FtEagleEyeResult();
std::string getEagleEyeTraceId()const;
std::string getName()const;
protected:
void parse(const std::string &payload);
private:
std::string eagleEyeTraceId_;
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_FT_MODEL_FTEAGLEEYERESULT_H_

48
ft/include/alibabacloud/ft/model/FtGatedLaunchPolicy4Request.h
View File

@@ -1,48 +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_FT_MODEL_FTGATEDLAUNCHPOLICY4REQUEST_H_
#define ALIBABACLOUD_FT_MODEL_FTGATEDLAUNCHPOLICY4REQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ft/FtExport.h>
namespace AlibabaCloud
{
namespace Ft
{
namespace Model
{
class ALIBABACLOUD_FT_EXPORT FtGatedLaunchPolicy4Request : public RpcServiceRequest
{
public:
FtGatedLaunchPolicy4Request();
~FtGatedLaunchPolicy4Request();
std::string getIsGatedLaunch()const;
void setIsGatedLaunch(const std::string& isGatedLaunch);
private:
std::string isGatedLaunch_;
};
}
}
}
#endif // !ALIBABACLOUD_FT_MODEL_FTGATEDLAUNCHPOLICY4REQUEST_H_

51
ft/include/alibabacloud/ft/model/FtGatedLaunchPolicy4Result.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_FT_MODEL_FTGATEDLAUNCHPOLICY4RESULT_H_
#define ALIBABACLOUD_FT_MODEL_FTGATEDLAUNCHPOLICY4RESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ft/FtExport.h>
namespace AlibabaCloud
{
namespace Ft
{
namespace Model
{
class ALIBABACLOUD_FT_EXPORT FtGatedLaunchPolicy4Result : public ServiceResult
{
public:
FtGatedLaunchPolicy4Result();
explicit FtGatedLaunchPolicy4Result(const std::string &payload);
~FtGatedLaunchPolicy4Result();
std::string getIsGatedLaunch()const;
protected:
void parse(const std::string &payload);
private:
std::string isGatedLaunch_;
};
}
}
}
#endif // !ALIBABACLOUD_FT_MODEL_FTGATEDLAUNCHPOLICY4RESULT_H_

48
ft/include/alibabacloud/ft/model/FtIpFlowControlRequest.h
View File

@@ -1,48 +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_FT_MODEL_FTIPFLOWCONTROLREQUEST_H_
#define ALIBABACLOUD_FT_MODEL_FTIPFLOWCONTROLREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ft/FtExport.h>
namespace AlibabaCloud
{
namespace Ft
{
namespace Model
{
class ALIBABACLOUD_FT_EXPORT FtIpFlowControlRequest : public RpcServiceRequest
{
public:
FtIpFlowControlRequest();
~FtIpFlowControlRequest();
std::string getName()const;
void setName(const std::string& name);
private:
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_FT_MODEL_FTIPFLOWCONTROLREQUEST_H_

57
ft/include/alibabacloud/ft/model/FtParamListRequest.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_FT_MODEL_FTPARAMLISTREQUEST_H_
#define ALIBABACLOUD_FT_MODEL_FTPARAMLISTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ft/FtExport.h>
namespace AlibabaCloud
{
namespace Ft
{
namespace Model
{
class ALIBABACLOUD_FT_EXPORT FtParamListRequest : public RpcServiceRequest
{
public:
struct Disk
{
std::vector<std::string> size;
std::vector<std::string> type;
};
public:
FtParamListRequest();
~FtParamListRequest();
std::vector<Disk> getDisk()const;
void setDisk(const std::vector<Disk>& disk);
std::string getName()const;
void setName(const std::string& name);
private:
std::vector<Disk> disk_;
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_FT_MODEL_FTPARAMLISTREQUEST_H_

62
ft/include/alibabacloud/ft/model/FtDynamicAddressHsfRequest.h → ft/include/alibabacloud/ft/model/NormalRpcHsfApiRequest.h
View File

@@ -1,45 +1,39 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FT_MODEL_FTDYNAMICADDRESSHSFREQUEST_H_
#define ALIBABACLOUD_FT_MODEL_FTDYNAMICADDRESSHSFREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ft/FtExport.h>
namespace AlibabaCloud
{
namespace Ft
{
namespace Model
{
class ALIBABACLOUD_FT_EXPORT FtDynamicAddressHsfRequest : public RpcServiceRequest
{
public:
FtDynamicAddressHsfRequest();
~FtDynamicAddressHsfRequest();
private:
};
}
}
}
#endif // !ALIBABACLOUD_FT_MODEL_FTDYNAMICADDRESSHSFREQUEST_H_
*/
#ifndef ALIBABACLOUD_FT_MODEL_NORMALRPCHSFAPIREQUEST_H_
#define ALIBABACLOUD_FT_MODEL_NORMALRPCHSFAPIREQUEST_H_
#include <alibabacloud/ft/FtExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ft {
namespace Model {
class ALIBABACLOUD_FT_EXPORT NormalRpcHsfApiRequest : public RpcServiceRequest {
public:
NormalRpcHsfApiRequest();
~NormalRpcHsfApiRequest();
private:
};
} // namespace Model
} // namespace Ft
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_FT_MODEL_NORMALRPCHSFAPIREQUEST_H_

14
ft/include/alibabacloud/ft/model/FtDynamicAddressHsfResult.h → ft/include/alibabacloud/ft/model/NormalRpcHsfApiResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FT_MODEL_FTDYNAMICADDRESSHSFRESULT_H_
#define ALIBABACLOUD_FT_MODEL_FTDYNAMICADDRESSHSFRESULT_H_
#ifndef ALIBABACLOUD_FT_MODEL_NORMALRPCHSFAPIRESULT_H_
#define ALIBABACLOUD_FT_MODEL_NORMALRPCHSFAPIRESULT_H_
#include <string>
#include <vector>
@@ -29,14 +29,14 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_FT_EXPORT FtDynamicAddressHsfResult : public ServiceResult
class ALIBABACLOUD_FT_EXPORT NormalRpcHsfApiResult : public ServiceResult
{
public:
FtDynamicAddressHsfResult();
explicit FtDynamicAddressHsfResult(const std::string &payload);
~FtDynamicAddressHsfResult();
NormalRpcHsfApiResult();
explicit NormalRpcHsfApiResult(const std::string &payload);
~NormalRpcHsfApiResult();
protected:
void parse(const std::string &payload);
@@ -46,4 +46,4 @@ namespace AlibabaCloud
}
}
}
#endif // !ALIBABACLOUD_FT_MODEL_FTDYNAMICADDRESSHSFRESULT_H_
#endif // !ALIBABACLOUD_FT_MODEL_NORMALRPCHSFAPIRESULT_H_

65
ft/include/alibabacloud/ft/model/FtEagleEyeRequest.h → ft/include/alibabacloud/ft/model/NormalRpcHttpApiRequest.h
View File

@@ -1,48 +1,39 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FT_MODEL_FTEAGLEEYEREQUEST_H_
#define ALIBABACLOUD_FT_MODEL_FTEAGLEEYEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ft/FtExport.h>
namespace AlibabaCloud
{
namespace Ft
{
namespace Model
{
class ALIBABACLOUD_FT_EXPORT FtEagleEyeRequest : public RpcServiceRequest
{
public:
FtEagleEyeRequest();
~FtEagleEyeRequest();
std::string getName()const;
void setName(const std::string& name);
private:
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_FT_MODEL_FTEAGLEEYEREQUEST_H_
*/
#ifndef ALIBABACLOUD_FT_MODEL_NORMALRPCHTTPAPIREQUEST_H_
#define ALIBABACLOUD_FT_MODEL_NORMALRPCHTTPAPIREQUEST_H_
#include <alibabacloud/ft/FtExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ft {
namespace Model {
class ALIBABACLOUD_FT_EXPORT NormalRpcHttpApiRequest : public RpcServiceRequest {
public:
NormalRpcHttpApiRequest();
~NormalRpcHttpApiRequest();
private:
};
} // namespace Model
} // namespace Ft
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_FT_MODEL_NORMALRPCHTTPAPIREQUEST_H_

16
ft/include/alibabacloud/ft/model/FtFlowSpecialResult.h → ft/include/alibabacloud/ft/model/NormalRpcHttpApiResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FT_MODEL_FTFLOWSPECIALRESULT_H_
#define ALIBABACLOUD_FT_MODEL_FTFLOWSPECIALRESULT_H_
#ifndef ALIBABACLOUD_FT_MODEL_NORMALRPCHTTPAPIRESULT_H_
#define ALIBABACLOUD_FT_MODEL_NORMALRPCHTTPAPIRESULT_H_
#include <string>
#include <vector>
@@ -29,23 +29,21 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_FT_EXPORT FtFlowSpecialResult : public ServiceResult
class ALIBABACLOUD_FT_EXPORT NormalRpcHttpApiResult : public ServiceResult
{
public:
FtFlowSpecialResult();
explicit FtFlowSpecialResult(const std::string &payload);
~FtFlowSpecialResult();
std::string getName()const;
NormalRpcHttpApiResult();
explicit NormalRpcHttpApiResult(const std::string &payload);
~NormalRpcHttpApiResult();
protected:
void parse(const std::string &payload);
private:
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_FT_MODEL_FTFLOWSPECIALRESULT_H_
#endif // !ALIBABACLOUD_FT_MODEL_NORMALRPCHTTPAPIRESULT_H_

68
ft/include/alibabacloud/ft/model/FtFlowSpecialRequest.h → ft/include/alibabacloud/ft/model/RpcDataUploadAndDownloadRequest.h
View File

@@ -1,48 +1,42 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FT_MODEL_FTFLOWSPECIALREQUEST_H_
#define ALIBABACLOUD_FT_MODEL_FTFLOWSPECIALREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ft/FtExport.h>
namespace AlibabaCloud
{
namespace Ft
{
namespace Model
{
class ALIBABACLOUD_FT_EXPORT FtFlowSpecialRequest : public RpcServiceRequest
{
public:
FtFlowSpecialRequest();
~FtFlowSpecialRequest();
std::string getName()const;
void setName(const std::string& name);
private:
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_FT_MODEL_FTFLOWSPECIALREQUEST_H_
*/
#ifndef ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADANDDOWNLOADREQUEST_H_
#define ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADANDDOWNLOADREQUEST_H_
#include <alibabacloud/ft/FtExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ft {
namespace Model {
class ALIBABACLOUD_FT_EXPORT RpcDataUploadAndDownloadRequest : public RpcServiceRequest {
public:
RpcDataUploadAndDownloadRequest();
~RpcDataUploadAndDownloadRequest();
std::string getQuery1() const;
void setQuery1(const std::string &query1);
private:
std::string query1_;
};
} // namespace Model
} // namespace Ft
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADANDDOWNLOADREQUEST_H_

16
ft/include/alibabacloud/ft/model/FtIpFlowControlResult.h → ft/include/alibabacloud/ft/model/RpcDataUploadAndDownloadResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FT_MODEL_FTIPFLOWCONTROLRESULT_H_
#define ALIBABACLOUD_FT_MODEL_FTIPFLOWCONTROLRESULT_H_
#ifndef ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADANDDOWNLOADRESULT_H_
#define ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADANDDOWNLOADRESULT_H_
#include <string>
#include <vector>
@@ -29,23 +29,21 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_FT_EXPORT FtIpFlowControlResult : public ServiceResult
class ALIBABACLOUD_FT_EXPORT RpcDataUploadAndDownloadResult : public ServiceResult
{
public:
FtIpFlowControlResult();
explicit FtIpFlowControlResult(const std::string &payload);
~FtIpFlowControlResult();
std::string getName()const;
RpcDataUploadAndDownloadResult();
explicit RpcDataUploadAndDownloadResult(const std::string &payload);
~RpcDataUploadAndDownloadResult();
protected:
void parse(const std::string &payload);
private:
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_FT_MODEL_FTIPFLOWCONTROLRESULT_H_
#endif // !ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADANDDOWNLOADRESULT_H_

48
ft/include/alibabacloud/ft/model/RpcDataUploadRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADREQUEST_H_
#define ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADREQUEST_H_
#include <alibabacloud/ft/FtExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ft {
namespace Model {
class ALIBABACLOUD_FT_EXPORT RpcDataUploadRequest : public RpcServiceRequest {
public:
RpcDataUploadRequest();
~RpcDataUploadRequest();
std::string getQuery1() const;
void setQuery1(const std::string &query1);
long getQuery2() const;
void setQuery2(long query2);
std::string getLargeParam() const;
void setLargeParam(const std::string &largeParam);
private:
std::string query1_;
long query2_;
std::string largeParam_;
};
} // namespace Model
} // namespace Ft
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADREQUEST_H_

26
ft/include/alibabacloud/ft/model/FtDynamicAddressHttpVpcResult.h → ft/include/alibabacloud/ft/model/RpcDataUploadResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FT_MODEL_FTDYNAMICADDRESSHTTPVPCRESULT_H_
#define ALIBABACLOUD_FT_MODEL_FTDYNAMICADDRESSHTTPVPCRESULT_H_
#ifndef ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADRESULT_H_
#define ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADRESULT_H_
#include <string>
#include <vector>
@@ -29,25 +29,33 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_FT_EXPORT FtDynamicAddressHttpVpcResult : public ServiceResult
class ALIBABACLOUD_FT_EXPORT RpcDataUploadResult : public ServiceResult
{
public:
FtDynamicAddressHttpVpcResult();
explicit FtDynamicAddressHttpVpcResult(const std::string &payload);
~FtDynamicAddressHttpVpcResult();
std::string getServiceRpcSign()const;
RpcDataUploadResult();
explicit RpcDataUploadResult(const std::string &payload);
~RpcDataUploadResult();
std::string getSpeed()const;
std::string getHeaders()const;
long getTotalBytes()const;
long getTotalTime()const;
std::string getParams()const;
std::string getUrl()const;
protected:
void parse(const std::string &payload);
private:
std::string serviceRpcSign_;
std::string speed_;
std::string headers_;
long totalBytes_;
long totalTime_;
std::string params_;
std::string url_;
};
}
}
}
#endif // !ALIBABACLOUD_FT_MODEL_FTDYNAMICADDRESSHTTPVPCRESULT_H_
#endif // !ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADRESULT_H_

65
ft/include/alibabacloud/ft/model/FTApiAliasApiRequest.h → ft/include/alibabacloud/ft/model/RpcDataUploadTestRequest.h
View File

@@ -1,48 +1,39 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FT_MODEL_FTAPIALIASAPIREQUEST_H_
#define ALIBABACLOUD_FT_MODEL_FTAPIALIASAPIREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ft/FtExport.h>
namespace AlibabaCloud
{
namespace Ft
{
namespace Model
{
class ALIBABACLOUD_FT_EXPORT FTApiAliasApiRequest : public RpcServiceRequest
{
public:
FTApiAliasApiRequest();
~FTApiAliasApiRequest();
std::string getName()const;
void setName(const std::string& name);
private:
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_FT_MODEL_FTAPIALIASAPIREQUEST_H_
*/
#ifndef ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADTESTREQUEST_H_
#define ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADTESTREQUEST_H_
#include <alibabacloud/ft/FtExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ft {
namespace Model {
class ALIBABACLOUD_FT_EXPORT RpcDataUploadTestRequest : public RpcServiceRequest {
public:
RpcDataUploadTestRequest();
~RpcDataUploadTestRequest();
private:
};
} // namespace Model
} // namespace Ft
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADTESTREQUEST_H_

16
ft/include/alibabacloud/ft/model/FTApiAliasApiResult.h → ft/include/alibabacloud/ft/model/RpcDataUploadTestResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FT_MODEL_FTAPIALIASAPIRESULT_H_
#define ALIBABACLOUD_FT_MODEL_FTAPIALIASAPIRESULT_H_
#ifndef ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADTESTRESULT_H_
#define ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADTESTRESULT_H_
#include <string>
#include <vector>
@@ -29,23 +29,21 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_FT_EXPORT FTApiAliasApiResult : public ServiceResult
class ALIBABACLOUD_FT_EXPORT RpcDataUploadTestResult : public ServiceResult
{
public:
FTApiAliasApiResult();
explicit FTApiAliasApiResult(const std::string &payload);
~FTApiAliasApiResult();
std::string getName()const;
RpcDataUploadTestResult();
explicit RpcDataUploadTestResult(const std::string &payload);
~RpcDataUploadTestResult();
protected:
void parse(const std::string &payload);
private:
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_FT_MODEL_FTAPIALIASAPIRESULT_H_
#endif // !ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADTESTRESULT_H_

48
ft/include/alibabacloud/ft/model/TestFlowStrategy01Request.h
View File

@@ -1,48 +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_FT_MODEL_TESTFLOWSTRATEGY01REQUEST_H_
#define ALIBABACLOUD_FT_MODEL_TESTFLOWSTRATEGY01REQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ft/FtExport.h>
namespace AlibabaCloud
{
namespace Ft
{
namespace Model
{
class ALIBABACLOUD_FT_EXPORT TestFlowStrategy01Request : public RpcServiceRequest
{
public:
TestFlowStrategy01Request();
~TestFlowStrategy01Request();
std::map<std::string, std::string> getNames()const;
void setNames(const std::map<std::string, std::string>& names);
private:
std::map<std::string, std::string> names_;
};
}
}
}
#endif // !ALIBABACLOUD_FT_MODEL_TESTFLOWSTRATEGY01REQUEST_H_

53
ft/include/alibabacloud/ft/model/TestFlowStrategy01Result.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_FT_MODEL_TESTFLOWSTRATEGY01RESULT_H_
#define ALIBABACLOUD_FT_MODEL_TESTFLOWSTRATEGY01RESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ft/FtExport.h>
namespace AlibabaCloud
{
namespace Ft
{
namespace Model
{
class ALIBABACLOUD_FT_EXPORT TestFlowStrategy01Result : public ServiceResult
{
public:
TestFlowStrategy01Result();
explicit TestFlowStrategy01Result(const std::string &payload);
~TestFlowStrategy01Result();
std::vector<std::string> getNames()const;
std::vector<std::string> getList()const;
protected:
void parse(const std::string &payload);
private:
std::vector<std::string> names_;
std::vector<std::string> list_;
};
}
}
}
#endif // !ALIBABACLOUD_FT_MODEL_TESTFLOWSTRATEGY01RESULT_H_

57
ft/include/alibabacloud/ft/model/TestHttpApiRequest.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_FT_MODEL_TESTHTTPAPIREQUEST_H_
#define ALIBABACLOUD_FT_MODEL_TESTHTTPAPIREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ft/FtExport.h>
namespace AlibabaCloud
{
namespace Ft
{
namespace Model
{
class ALIBABACLOUD_FT_EXPORT TestHttpApiRequest : public RpcServiceRequest
{
public:
TestHttpApiRequest();
~TestHttpApiRequest();
std::string getStringValue()const;
void setStringValue(const std::string& stringValue);
std::string getOtherParam()const;
void setOtherParam(const std::string& otherParam);
bool getBooleanParam()const;
void setBooleanParam(bool booleanParam);
std::string getDefaultValue()const;
void setDefaultValue(const std::string& defaultValue);
private:
std::string stringValue_;
std::string otherParam_;
bool booleanParam_;
std::string defaultValue_;
};
}
}
}
#endif // !ALIBABACLOUD_FT_MODEL_TESTHTTPAPIREQUEST_H_

53
ft/include/alibabacloud/ft/model/TestHttpApiResult.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_FT_MODEL_TESTHTTPAPIRESULT_H_
#define ALIBABACLOUD_FT_MODEL_TESTHTTPAPIRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ft/FtExport.h>
namespace AlibabaCloud
{
namespace Ft
{
namespace Model
{
class ALIBABACLOUD_FT_EXPORT TestHttpApiResult : public ServiceResult
{
public:
TestHttpApiResult();
explicit TestHttpApiResult(const std::string &payload);
~TestHttpApiResult();
std::string getServiceRpcSign()const;
std::string getParams()const;
protected:
void parse(const std::string &payload);
private:
std::string serviceRpcSign_;
std::string params_;
};
}
}
}
#endif // !ALIBABACLOUD_FT_MODEL_TESTHTTPAPIRESULT_H_

324
ft/src/FtClient.cc
View File

@@ -51,432 +51,216 @@ FtClient::FtClient(const std::string & accessKeyId, const std::string & accessKe
FtClient::~FtClient()
{}
FtClient::BatchAuditTest01Outcome FtClient::batchAuditTest01(const BatchAuditTest01Request &request) const
FtClient::DataRateLimitTestOutcome FtClient::dataRateLimitTest(const DataRateLimitTestRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return BatchAuditTest01Outcome(endpointOutcome.error());
return DataRateLimitTestOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return BatchAuditTest01Outcome(BatchAuditTest01Result(outcome.result()));
return DataRateLimitTestOutcome(DataRateLimitTestResult(outcome.result()));
else
return BatchAuditTest01Outcome(outcome.error());
return DataRateLimitTestOutcome(outcome.error());
}
void FtClient::batchAuditTest01Async(const BatchAuditTest01Request& request, const BatchAuditTest01AsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void FtClient::dataRateLimitTestAsync(const DataRateLimitTestRequest& request, const DataRateLimitTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, batchAuditTest01(request), context);
handler(this, request, dataRateLimitTest(request), context);
};
asyncExecute(new Runnable(fn));
}
FtClient::BatchAuditTest01OutcomeCallable FtClient::batchAuditTest01Callable(const BatchAuditTest01Request &request) const
FtClient::DataRateLimitTestOutcomeCallable FtClient::dataRateLimitTestCallable(const DataRateLimitTestRequest &request) const
{
auto task = std::make_shared<std::packaged_task<BatchAuditTest01Outcome()>>(
auto task = std::make_shared<std::packaged_task<DataRateLimitTestOutcome()>>(
[this, request]()
{
return this->batchAuditTest01(request);
return this->dataRateLimitTest(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FtClient::FTApiAliasApiOutcome FtClient::fTApiAliasApi(const FTApiAliasApiRequest &request) const
FtClient::NormalRpcHsfApiOutcome FtClient::normalRpcHsfApi(const NormalRpcHsfApiRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return FTApiAliasApiOutcome(endpointOutcome.error());
return NormalRpcHsfApiOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return FTApiAliasApiOutcome(FTApiAliasApiResult(outcome.result()));
return NormalRpcHsfApiOutcome(NormalRpcHsfApiResult(outcome.result()));
else
return FTApiAliasApiOutcome(outcome.error());
return NormalRpcHsfApiOutcome(outcome.error());
}
void FtClient::fTApiAliasApiAsync(const FTApiAliasApiRequest& request, const FTApiAliasApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void FtClient::normalRpcHsfApiAsync(const NormalRpcHsfApiRequest& request, const NormalRpcHsfApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, fTApiAliasApi(request), context);
handler(this, request, normalRpcHsfApi(request), context);
};
asyncExecute(new Runnable(fn));
}
FtClient::FTApiAliasApiOutcomeCallable FtClient::fTApiAliasApiCallable(const FTApiAliasApiRequest &request) const
FtClient::NormalRpcHsfApiOutcomeCallable FtClient::normalRpcHsfApiCallable(const NormalRpcHsfApiRequest &request) const
{
auto task = std::make_shared<std::packaged_task<FTApiAliasApiOutcome()>>(
auto task = std::make_shared<std::packaged_task<NormalRpcHsfApiOutcome()>>(
[this, request]()
{
return this->fTApiAliasApi(request);
return this->normalRpcHsfApi(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FtClient::FtDynamicAddressDubboOutcome FtClient::ftDynamicAddressDubbo(const FtDynamicAddressDubboRequest &request) const
FtClient::NormalRpcHttpApiOutcome FtClient::normalRpcHttpApi(const NormalRpcHttpApiRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return FtDynamicAddressDubboOutcome(endpointOutcome.error());
return NormalRpcHttpApiOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return FtDynamicAddressDubboOutcome(FtDynamicAddressDubboResult(outcome.result()));
return NormalRpcHttpApiOutcome(NormalRpcHttpApiResult(outcome.result()));
else
return FtDynamicAddressDubboOutcome(outcome.error());
return NormalRpcHttpApiOutcome(outcome.error());
}
void FtClient::ftDynamicAddressDubboAsync(const FtDynamicAddressDubboRequest& request, const FtDynamicAddressDubboAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void FtClient::normalRpcHttpApiAsync(const NormalRpcHttpApiRequest& request, const NormalRpcHttpApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, ftDynamicAddressDubbo(request), context);
handler(this, request, normalRpcHttpApi(request), context);
};
asyncExecute(new Runnable(fn));
}
FtClient::FtDynamicAddressDubboOutcomeCallable FtClient::ftDynamicAddressDubboCallable(const FtDynamicAddressDubboRequest &request) const
FtClient::NormalRpcHttpApiOutcomeCallable FtClient::normalRpcHttpApiCallable(const NormalRpcHttpApiRequest &request) const
{
auto task = std::make_shared<std::packaged_task<FtDynamicAddressDubboOutcome()>>(
auto task = std::make_shared<std::packaged_task<NormalRpcHttpApiOutcome()>>(
[this, request]()
{
return this->ftDynamicAddressDubbo(request);
return this->normalRpcHttpApi(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FtClient::FtDynamicAddressHsfOutcome FtClient::ftDynamicAddressHsf(const FtDynamicAddressHsfRequest &request) const
FtClient::RpcDataUploadOutcome FtClient::rpcDataUpload(const RpcDataUploadRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return FtDynamicAddressHsfOutcome(endpointOutcome.error());
return RpcDataUploadOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return FtDynamicAddressHsfOutcome(FtDynamicAddressHsfResult(outcome.result()));
return RpcDataUploadOutcome(RpcDataUploadResult(outcome.result()));
else
return FtDynamicAddressHsfOutcome(outcome.error());
return RpcDataUploadOutcome(outcome.error());
}
void FtClient::ftDynamicAddressHsfAsync(const FtDynamicAddressHsfRequest& request, const FtDynamicAddressHsfAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void FtClient::rpcDataUploadAsync(const RpcDataUploadRequest& request, const RpcDataUploadAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, ftDynamicAddressHsf(request), context);
handler(this, request, rpcDataUpload(request), context);
};
asyncExecute(new Runnable(fn));
}
FtClient::FtDynamicAddressHsfOutcomeCallable FtClient::ftDynamicAddressHsfCallable(const FtDynamicAddressHsfRequest &request) const
FtClient::RpcDataUploadOutcomeCallable FtClient::rpcDataUploadCallable(const RpcDataUploadRequest &request) const
{
auto task = std::make_shared<std::packaged_task<FtDynamicAddressHsfOutcome()>>(
auto task = std::make_shared<std::packaged_task<RpcDataUploadOutcome()>>(
[this, request]()
{
return this->ftDynamicAddressHsf(request);
return this->rpcDataUpload(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FtClient::FtDynamicAddressHttpVpcOutcome FtClient::ftDynamicAddressHttpVpc(const FtDynamicAddressHttpVpcRequest &request) const
FtClient::RpcDataUploadAndDownloadOutcome FtClient::rpcDataUploadAndDownload(const RpcDataUploadAndDownloadRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return FtDynamicAddressHttpVpcOutcome(endpointOutcome.error());
return RpcDataUploadAndDownloadOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return FtDynamicAddressHttpVpcOutcome(FtDynamicAddressHttpVpcResult(outcome.result()));
return RpcDataUploadAndDownloadOutcome(RpcDataUploadAndDownloadResult(outcome.result()));
else
return FtDynamicAddressHttpVpcOutcome(outcome.error());
return RpcDataUploadAndDownloadOutcome(outcome.error());
}
void FtClient::ftDynamicAddressHttpVpcAsync(const FtDynamicAddressHttpVpcRequest& request, const FtDynamicAddressHttpVpcAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void FtClient::rpcDataUploadAndDownloadAsync(const RpcDataUploadAndDownloadRequest& request, const RpcDataUploadAndDownloadAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, ftDynamicAddressHttpVpc(request), context);
handler(this, request, rpcDataUploadAndDownload(request), context);
};
asyncExecute(new Runnable(fn));
}
FtClient::FtDynamicAddressHttpVpcOutcomeCallable FtClient::ftDynamicAddressHttpVpcCallable(const FtDynamicAddressHttpVpcRequest &request) const
FtClient::RpcDataUploadAndDownloadOutcomeCallable FtClient::rpcDataUploadAndDownloadCallable(const RpcDataUploadAndDownloadRequest &request) const
{
auto task = std::make_shared<std::packaged_task<FtDynamicAddressHttpVpcOutcome()>>(
auto task = std::make_shared<std::packaged_task<RpcDataUploadAndDownloadOutcome()>>(
[this, request]()
{
return this->ftDynamicAddressHttpVpc(request);
return this->rpcDataUploadAndDownload(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FtClient::FtEagleEyeOutcome FtClient::ftEagleEye(const FtEagleEyeRequest &request) const
FtClient::RpcDataUploadTestOutcome FtClient::rpcDataUploadTest(const RpcDataUploadTestRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return FtEagleEyeOutcome(endpointOutcome.error());
return RpcDataUploadTestOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return FtEagleEyeOutcome(FtEagleEyeResult(outcome.result()));
return RpcDataUploadTestOutcome(RpcDataUploadTestResult(outcome.result()));
else
return FtEagleEyeOutcome(outcome.error());
return RpcDataUploadTestOutcome(outcome.error());
}
void FtClient::ftEagleEyeAsync(const FtEagleEyeRequest& request, const FtEagleEyeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void FtClient::rpcDataUploadTestAsync(const RpcDataUploadTestRequest& request, const RpcDataUploadTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, ftEagleEye(request), context);
handler(this, request, rpcDataUploadTest(request), context);
};
asyncExecute(new Runnable(fn));
}
FtClient::FtEagleEyeOutcomeCallable FtClient::ftEagleEyeCallable(const FtEagleEyeRequest &request) const
FtClient::RpcDataUploadTestOutcomeCallable FtClient::rpcDataUploadTestCallable(const RpcDataUploadTestRequest &request) const
{
auto task = std::make_shared<std::packaged_task<FtEagleEyeOutcome()>>(
auto task = std::make_shared<std::packaged_task<RpcDataUploadTestOutcome()>>(
[this, request]()
{
return this->ftEagleEye(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FtClient::FtFlowSpecialOutcome FtClient::ftFlowSpecial(const FtFlowSpecialRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return FtFlowSpecialOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return FtFlowSpecialOutcome(FtFlowSpecialResult(outcome.result()));
else
return FtFlowSpecialOutcome(outcome.error());
}
void FtClient::ftFlowSpecialAsync(const FtFlowSpecialRequest& request, const FtFlowSpecialAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, ftFlowSpecial(request), context);
};
asyncExecute(new Runnable(fn));
}
FtClient::FtFlowSpecialOutcomeCallable FtClient::ftFlowSpecialCallable(const FtFlowSpecialRequest &request) const
{
auto task = std::make_shared<std::packaged_task<FtFlowSpecialOutcome()>>(
[this, request]()
{
return this->ftFlowSpecial(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FtClient::FtGatedLaunchPolicy4Outcome FtClient::ftGatedLaunchPolicy4(const FtGatedLaunchPolicy4Request &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return FtGatedLaunchPolicy4Outcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return FtGatedLaunchPolicy4Outcome(FtGatedLaunchPolicy4Result(outcome.result()));
else
return FtGatedLaunchPolicy4Outcome(outcome.error());
}
void FtClient::ftGatedLaunchPolicy4Async(const FtGatedLaunchPolicy4Request& request, const FtGatedLaunchPolicy4AsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, ftGatedLaunchPolicy4(request), context);
};
asyncExecute(new Runnable(fn));
}
FtClient::FtGatedLaunchPolicy4OutcomeCallable FtClient::ftGatedLaunchPolicy4Callable(const FtGatedLaunchPolicy4Request &request) const
{
auto task = std::make_shared<std::packaged_task<FtGatedLaunchPolicy4Outcome()>>(
[this, request]()
{
return this->ftGatedLaunchPolicy4(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FtClient::FtIpFlowControlOutcome FtClient::ftIpFlowControl(const FtIpFlowControlRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return FtIpFlowControlOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return FtIpFlowControlOutcome(FtIpFlowControlResult(outcome.result()));
else
return FtIpFlowControlOutcome(outcome.error());
}
void FtClient::ftIpFlowControlAsync(const FtIpFlowControlRequest& request, const FtIpFlowControlAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, ftIpFlowControl(request), context);
};
asyncExecute(new Runnable(fn));
}
FtClient::FtIpFlowControlOutcomeCallable FtClient::ftIpFlowControlCallable(const FtIpFlowControlRequest &request) const
{
auto task = std::make_shared<std::packaged_task<FtIpFlowControlOutcome()>>(
[this, request]()
{
return this->ftIpFlowControl(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FtClient::FtParamListOutcome FtClient::ftParamList(const FtParamListRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return FtParamListOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return FtParamListOutcome(FtParamListResult(outcome.result()));
else
return FtParamListOutcome(outcome.error());
}
void FtClient::ftParamListAsync(const FtParamListRequest& request, const FtParamListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, ftParamList(request), context);
};
asyncExecute(new Runnable(fn));
}
FtClient::FtParamListOutcomeCallable FtClient::ftParamListCallable(const FtParamListRequest &request) const
{
auto task = std::make_shared<std::packaged_task<FtParamListOutcome()>>(
[this, request]()
{
return this->ftParamList(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FtClient::TestFlowStrategy01Outcome FtClient::testFlowStrategy01(const TestFlowStrategy01Request &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return TestFlowStrategy01Outcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return TestFlowStrategy01Outcome(TestFlowStrategy01Result(outcome.result()));
else
return TestFlowStrategy01Outcome(outcome.error());
}
void FtClient::testFlowStrategy01Async(const TestFlowStrategy01Request& request, const TestFlowStrategy01AsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, testFlowStrategy01(request), context);
};
asyncExecute(new Runnable(fn));
}
FtClient::TestFlowStrategy01OutcomeCallable FtClient::testFlowStrategy01Callable(const TestFlowStrategy01Request &request) const
{
auto task = std::make_shared<std::packaged_task<TestFlowStrategy01Outcome()>>(
[this, request]()
{
return this->testFlowStrategy01(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FtClient::TestHttpApiOutcome FtClient::testHttpApi(const TestHttpApiRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return TestHttpApiOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return TestHttpApiOutcome(TestHttpApiResult(outcome.result()));
else
return TestHttpApiOutcome(outcome.error());
}
void FtClient::testHttpApiAsync(const TestHttpApiRequest& request, const TestHttpApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, testHttpApi(request), context);
};
asyncExecute(new Runnable(fn));
}
FtClient::TestHttpApiOutcomeCallable FtClient::testHttpApiCallable(const TestHttpApiRequest &request) const
{
auto task = std::make_shared<std::packaged_task<TestHttpApiOutcome()>>(
[this, request]()
{
return this->testHttpApi(request);
return this->rpcDataUploadTest(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));

73
ft/src/model/BatchAuditTest01Request.cc
View File

@@ -1,73 +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/ft/model/BatchAuditTest01Request.h>
using AlibabaCloud::Ft::Model::BatchAuditTest01Request;
BatchAuditTest01Request::BatchAuditTest01Request() :
RpcServiceRequest("ft", "2018-07-13", "BatchAuditTest01")
{
setMethod(HttpRequest::Method::Post);
}
BatchAuditTest01Request::~BatchAuditTest01Request()
{}
std::string BatchAuditTest01Request::getDemo01()const
{
return demo01_;
}
void BatchAuditTest01Request::setDemo01(const std::string& demo01)
{
demo01_ = demo01;
setParameter("Demo01", demo01);
}
bool BatchAuditTest01Request::getTest010101()const
{
return test010101_;
}
void BatchAuditTest01Request::setTest010101(bool test010101)
{
test010101_ = test010101;
setBodyParameter("Test010101", test010101 ? "true" : "false");
}
std::string BatchAuditTest01Request::getName()const
{
return name_;
}
void BatchAuditTest01Request::setName(const std::string& name)
{
name_ = name;
setParameter("Name", name);
}
std::string BatchAuditTest01Request::getBatchAuditTest01()const
{
return batchAuditTest01_;
}
void BatchAuditTest01Request::setBatchAuditTest01(const std::string& batchAuditTest01)
{
batchAuditTest01_ = batchAuditTest01;
setParameter("BatchAuditTest01", batchAuditTest01);
}

65
ft/src/model/BatchAuditTest01Result.cc
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.
*/
#include <alibabacloud/ft/model/BatchAuditTest01Result.h>
#include <json/json.h>
using namespace AlibabaCloud::Ft;
using namespace AlibabaCloud::Ft::Model;
BatchAuditTest01Result::BatchAuditTest01Result() :
ServiceResult()
{}
BatchAuditTest01Result::BatchAuditTest01Result(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
BatchAuditTest01Result::~BatchAuditTest01Result()
{}
void BatchAuditTest01Result::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto demo01Node = value["Demo01"];
auto allDemo011Node = demo01Node["Demo011"]["Demo011Item"];
for (auto demo01NodeDemo011Demo011Item : allDemo011Node)
{
Demo01::Demo011Item demo011ItemObject;
if(!demo01NodeDemo011Demo011Item["Demo0111"].isNull())
demo011ItemObject.demo0111 = demo01NodeDemo011Demo011Item["Demo0111"].asString();
demo01_.demo011.push_back(demo011ItemObject);
}
if(!value["Name"].isNull())
name_ = value["Name"].asString();
}
BatchAuditTest01Result::Demo01 BatchAuditTest01Result::getDemo01()const
{
return demo01_;
}
std::string BatchAuditTest01Result::getName()const
{
return name_;
}

63
ft/src/model/DataRateLimitTestRequest.cc Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ft/model/DataRateLimitTestRequest.h>
using AlibabaCloud::Ft::Model::DataRateLimitTestRequest;
DataRateLimitTestRequest::DataRateLimitTestRequest()
: RpcServiceRequest("ft", "2021-01-01", "DataRateLimitTest") {
setMethod(HttpRequest::Method::Post);
}
DataRateLimitTestRequest::~DataRateLimitTestRequest() {}
std::string DataRateLimitTestRequest::getNewparam2() const {
return newparam2_;
}
void DataRateLimitTestRequest::setNewparam2(const std::string &newparam2) {
newparam2_ = newparam2;
setParameter(std::string("new-param-2"), newparam2);
}
std::string DataRateLimitTestRequest::getNewparam1() const {
return newparam1_;
}
void DataRateLimitTestRequest::setNewparam1(const std::string &newparam1) {
newparam1_ = newparam1;
setParameter(std::string("new-param-1"), newparam1);
}
std::string DataRateLimitTestRequest::getData() const {
return data_;
}
void DataRateLimitTestRequest::setData(const std::string &data) {
data_ = data;
setParameter(std::string("Data"), data);
}
std::string DataRateLimitTestRequest::getMap() const {
return map_;
}
void DataRateLimitTestRequest::setMap(const std::string &map) {
map_ = map;
setParameter(std::string("Map"), map);
}

10
ft/src/model/FtDynamicAddressHsfResult.cc → ft/src/model/DataRateLimitTestResult.cc
View File

@@ -14,26 +14,26 @@
* limitations under the License.
*/
#include <alibabacloud/ft/model/FtDynamicAddressHsfResult.h>
#include <alibabacloud/ft/model/DataRateLimitTestResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ft;
using namespace AlibabaCloud::Ft::Model;
FtDynamicAddressHsfResult::FtDynamicAddressHsfResult() :
DataRateLimitTestResult::DataRateLimitTestResult() :
ServiceResult()
{}
FtDynamicAddressHsfResult::FtDynamicAddressHsfResult(const std::string &payload) :
DataRateLimitTestResult::DataRateLimitTestResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
FtDynamicAddressHsfResult::~FtDynamicAddressHsfResult()
DataRateLimitTestResult::~DataRateLimitTestResult()
{}
void FtDynamicAddressHsfResult::parse(const std::string &payload)
void DataRateLimitTestResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;

51
ft/src/model/FtDynamicAddressDubboRequest.cc
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/ft/model/FtDynamicAddressDubboRequest.h>
using AlibabaCloud::Ft::Model::FtDynamicAddressDubboRequest;
FtDynamicAddressDubboRequest::FtDynamicAddressDubboRequest() :
RpcServiceRequest("ft", "2018-07-13", "FtDynamicAddressDubbo")
{
setMethod(HttpRequest::Method::Post);
}
FtDynamicAddressDubboRequest::~FtDynamicAddressDubboRequest()
{}
int FtDynamicAddressDubboRequest::getIntValue()const
{
return intValue_;
}
void FtDynamicAddressDubboRequest::setIntValue(int intValue)
{
intValue_ = intValue;
setParameter("IntValue", std::to_string(intValue));
}
std::string FtDynamicAddressDubboRequest::getStringValue()const
{
return stringValue_;
}
void FtDynamicAddressDubboRequest::setStringValue(const std::string& stringValue)
{
stringValue_ = stringValue;
setParameter("StringValue", stringValue);
}

58
ft/src/model/FtDynamicAddressDubboResult.cc
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/ft/model/FtDynamicAddressDubboResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ft;
using namespace AlibabaCloud::Ft::Model;
FtDynamicAddressDubboResult::FtDynamicAddressDubboResult() :
ServiceResult()
{}
FtDynamicAddressDubboResult::FtDynamicAddressDubboResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
FtDynamicAddressDubboResult::~FtDynamicAddressDubboResult()
{}
void FtDynamicAddressDubboResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["StringValue"].isNull())
stringValue_ = value["StringValue"].asString();
if(!value["IntValue"].isNull())
intValue_ = std::stoi(value["IntValue"].asString());
}
std::string FtDynamicAddressDubboResult::getStringValue()const
{
return stringValue_;
}
int FtDynamicAddressDubboResult::getIntValue()const
{
return intValue_;
}

84
ft/src/model/FtDynamicAddressHttpVpcRequest.cc
View File

@@ -1,84 +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/ft/model/FtDynamicAddressHttpVpcRequest.h>
using AlibabaCloud::Ft::Model::FtDynamicAddressHttpVpcRequest;
FtDynamicAddressHttpVpcRequest::FtDynamicAddressHttpVpcRequest() :
RpcServiceRequest("ft", "2018-07-13", "FtDynamicAddressHttpVpc")
{
setMethod(HttpRequest::Method::Post);
}
FtDynamicAddressHttpVpcRequest::~FtDynamicAddressHttpVpcRequest()
{}
std::string FtDynamicAddressHttpVpcRequest::getP1()const
{
return p1_;
}
void FtDynamicAddressHttpVpcRequest::setP1(const std::string& p1)
{
p1_ = p1;
setParameter("P1", p1);
}
std::string FtDynamicAddressHttpVpcRequest::getStringValue()const
{
return stringValue_;
}
void FtDynamicAddressHttpVpcRequest::setStringValue(const std::string& stringValue)
{
stringValue_ = stringValue;
setParameter("StringValue", stringValue);
}
std::string FtDynamicAddressHttpVpcRequest::getOtherParam()const
{
return otherParam_;
}
void FtDynamicAddressHttpVpcRequest::setOtherParam(const std::string& otherParam)
{
otherParam_ = otherParam;
setParameter("OtherParam", otherParam);
}
bool FtDynamicAddressHttpVpcRequest::getBooleanParam()const
{
return booleanParam_;
}
void FtDynamicAddressHttpVpcRequest::setBooleanParam(bool booleanParam)
{
booleanParam_ = booleanParam;
setParameter("BooleanParam", booleanParam ? "true" : "false");
}
std::string FtDynamicAddressHttpVpcRequest::getDefaultValue()const
{
return defaultValue_;
}
void FtDynamicAddressHttpVpcRequest::setDefaultValue(const std::string& defaultValue)
{
defaultValue_ = defaultValue;
setParameter("DefaultValue", defaultValue);
}

58
ft/src/model/FtDynamicAddressHttpVpcResult.cc
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/ft/model/FtDynamicAddressHttpVpcResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ft;
using namespace AlibabaCloud::Ft::Model;
FtDynamicAddressHttpVpcResult::FtDynamicAddressHttpVpcResult() :
ServiceResult()
{}
FtDynamicAddressHttpVpcResult::FtDynamicAddressHttpVpcResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
FtDynamicAddressHttpVpcResult::~FtDynamicAddressHttpVpcResult()
{}
void FtDynamicAddressHttpVpcResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Params"].isNull())
params_ = value["Params"].asString();
if(!value["ServiceRpcSign"].isNull())
serviceRpcSign_ = value["ServiceRpcSign"].asString();
}
std::string FtDynamicAddressHttpVpcResult::getServiceRpcSign()const
{
return serviceRpcSign_;
}
std::string FtDynamicAddressHttpVpcResult::getParams()const
{
return params_;
}

58
ft/src/model/FtEagleEyeResult.cc
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/ft/model/FtEagleEyeResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ft;
using namespace AlibabaCloud::Ft::Model;
FtEagleEyeResult::FtEagleEyeResult() :
ServiceResult()
{}
FtEagleEyeResult::FtEagleEyeResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
FtEagleEyeResult::~FtEagleEyeResult()
{}
void FtEagleEyeResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Name"].isNull())
name_ = value["Name"].asString();
if(!value["eagleEyeTraceId"].isNull())
eagleEyeTraceId_ = value["eagleEyeTraceId"].asString();
}
std::string FtEagleEyeResult::getEagleEyeTraceId()const
{
return eagleEyeTraceId_;
}
std::string FtEagleEyeResult::getName()const
{
return name_;
}

40
ft/src/model/FtFlowSpecialRequest.cc
View File

@@ -1,40 +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/ft/model/FtFlowSpecialRequest.h>
using AlibabaCloud::Ft::Model::FtFlowSpecialRequest;
FtFlowSpecialRequest::FtFlowSpecialRequest() :
RpcServiceRequest("ft", "2018-07-13", "FtFlowSpecial")
{
setMethod(HttpRequest::Method::Post);
}
FtFlowSpecialRequest::~FtFlowSpecialRequest()
{}
std::string FtFlowSpecialRequest::getName()const
{
return name_;
}
void FtFlowSpecialRequest::setName(const std::string& name)
{
name_ = name;
setParameter("Name", name);
}

40
ft/src/model/FtGatedLaunchPolicy4Request.cc
View File

@@ -1,40 +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/ft/model/FtGatedLaunchPolicy4Request.h>
using AlibabaCloud::Ft::Model::FtGatedLaunchPolicy4Request;
FtGatedLaunchPolicy4Request::FtGatedLaunchPolicy4Request() :
RpcServiceRequest("ft", "2018-07-13", "FtGatedLaunchPolicy4")
{
setMethod(HttpRequest::Method::Post);
}
FtGatedLaunchPolicy4Request::~FtGatedLaunchPolicy4Request()
{}
std::string FtGatedLaunchPolicy4Request::getIsGatedLaunch()const
{
return isGatedLaunch_;
}
void FtGatedLaunchPolicy4Request::setIsGatedLaunch(const std::string& isGatedLaunch)
{
isGatedLaunch_ = isGatedLaunch;
setParameter("IsGatedLaunch", isGatedLaunch);
}

51
ft/src/model/FtGatedLaunchPolicy4Result.cc
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/ft/model/FtGatedLaunchPolicy4Result.h>
#include <json/json.h>
using namespace AlibabaCloud::Ft;
using namespace AlibabaCloud::Ft::Model;
FtGatedLaunchPolicy4Result::FtGatedLaunchPolicy4Result() :
ServiceResult()
{}
FtGatedLaunchPolicy4Result::FtGatedLaunchPolicy4Result(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
FtGatedLaunchPolicy4Result::~FtGatedLaunchPolicy4Result()
{}
void FtGatedLaunchPolicy4Result::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["IsGatedLaunch"].isNull())
isGatedLaunch_ = value["IsGatedLaunch"].asString();
}
std::string FtGatedLaunchPolicy4Result::getIsGatedLaunch()const
{
return isGatedLaunch_;
}

40
ft/src/model/FtIpFlowControlRequest.cc
View File

@@ -1,40 +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/ft/model/FtIpFlowControlRequest.h>
using AlibabaCloud::Ft::Model::FtIpFlowControlRequest;
FtIpFlowControlRequest::FtIpFlowControlRequest() :
RpcServiceRequest("ft", "2018-07-13", "FtIpFlowControl")
{
setMethod(HttpRequest::Method::Post);
}
FtIpFlowControlRequest::~FtIpFlowControlRequest()
{}
std::string FtIpFlowControlRequest::getName()const
{
return name_;
}
void FtIpFlowControlRequest::setName(const std::string& name)
{
name_ = name;
setParameter("Name", name);
}

51
ft/src/model/FtIpFlowControlResult.cc
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/ft/model/FtIpFlowControlResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ft;
using namespace AlibabaCloud::Ft::Model;
FtIpFlowControlResult::FtIpFlowControlResult() :
ServiceResult()
{}
FtIpFlowControlResult::FtIpFlowControlResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
FtIpFlowControlResult::~FtIpFlowControlResult()
{}
void FtIpFlowControlResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Name"].isNull())
name_ = value["Name"].asString();
}
std::string FtIpFlowControlResult::getName()const
{
return name_;
}

60
ft/src/model/FtParamListRequest.cc
View File

@@ -1,60 +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/ft/model/FtParamListRequest.h>
using AlibabaCloud::Ft::Model::FtParamListRequest;
FtParamListRequest::FtParamListRequest() :
RpcServiceRequest("ft", "2018-07-13", "FtParamList")
{
setMethod(HttpRequest::Method::Post);
}
FtParamListRequest::~FtParamListRequest()
{}
std::vector<FtParamListRequest::Disk> FtParamListRequest::getDisk()const
{
return disk_;
}
void FtParamListRequest::setDisk(const std::vector<Disk>& disk)
{
disk_ = disk;
for(int dep1 = 0; dep1!= disk.size(); dep1++) {
auto diskObj = disk.at(dep1);
std::string diskObjStr = "Disk." + std::to_string(dep1 + 1);
for(int dep2 = 0; dep2!= diskObj.size.size(); dep2++) {
setParameter(diskObjStr + ".Size."+ std::to_string(dep2), diskObj.size.at(dep2));
}
for(int dep2 = 0; dep2!= diskObj.type.size(); dep2++) {
setParameter(diskObjStr + ".Type."+ std::to_string(dep2), diskObj.type.at(dep2));
}
}
}
std::string FtParamListRequest::getName()const
{
return name_;
}
void FtParamListRequest::setName(const std::string& name)
{
name_ = name;
setParameter("Name", name);
}

39
ft/src/model/FtEagleEyeRequest.cc → ft/src/model/NormalRpcHsfApiRequest.cc
View File

@@ -1,40 +1,27 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ft/model/FtEagleEyeRequest.h>
using AlibabaCloud::Ft::Model::FtEagleEyeRequest;
FtEagleEyeRequest::FtEagleEyeRequest() :
RpcServiceRequest("ft", "2018-07-13", "FtEagleEye")
{
setMethod(HttpRequest::Method::Post);
}
FtEagleEyeRequest::~FtEagleEyeRequest()
{}
std::string FtEagleEyeRequest::getName()const
{
return name_;
*/
#include <alibabacloud/ft/model/NormalRpcHsfApiRequest.h>
using AlibabaCloud::Ft::Model::NormalRpcHsfApiRequest;
NormalRpcHsfApiRequest::NormalRpcHsfApiRequest()
: RpcServiceRequest("ft", "2021-01-01", "NormalRpcHsfApi") {
setMethod(HttpRequest::Method::Get);
}
void FtEagleEyeRequest::setName(const std::string& name)
{
name_ = name;
setParameter("Name", name);
}
NormalRpcHsfApiRequest::~NormalRpcHsfApiRequest() {}

17
ft/src/model/FTApiAliasApiResult.cc → ft/src/model/NormalRpcHsfApiResult.cc
View File

@@ -14,38 +14,31 @@
* limitations under the License.
*/
#include <alibabacloud/ft/model/FTApiAliasApiResult.h>
#include <alibabacloud/ft/model/NormalRpcHsfApiResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ft;
using namespace AlibabaCloud::Ft::Model;
FTApiAliasApiResult::FTApiAliasApiResult() :
NormalRpcHsfApiResult::NormalRpcHsfApiResult() :
ServiceResult()
{}
FTApiAliasApiResult::FTApiAliasApiResult(const std::string &payload) :
NormalRpcHsfApiResult::NormalRpcHsfApiResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
FTApiAliasApiResult::~FTApiAliasApiResult()
NormalRpcHsfApiResult::~NormalRpcHsfApiResult()
{}
void FTApiAliasApiResult::parse(const std::string &payload)
void NormalRpcHsfApiResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Name"].isNull())
name_ = value["Name"].asString();
}
std::string FTApiAliasApiResult::getName()const
{
return name_;
}

34
ft/src/model/FtDynamicAddressHsfRequest.cc → ft/src/model/NormalRpcHttpApiRequest.cc
View File

@@ -1,29 +1,27 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ft/model/FtDynamicAddressHsfRequest.h>
using AlibabaCloud::Ft::Model::FtDynamicAddressHsfRequest;
FtDynamicAddressHsfRequest::FtDynamicAddressHsfRequest() :
RpcServiceRequest("ft", "2018-07-13", "FtDynamicAddressHsf")
{
setMethod(HttpRequest::Method::Post);
}
FtDynamicAddressHsfRequest::~FtDynamicAddressHsfRequest()
{}
*/
#include <alibabacloud/ft/model/NormalRpcHttpApiRequest.h>
using AlibabaCloud::Ft::Model::NormalRpcHttpApiRequest;
NormalRpcHttpApiRequest::NormalRpcHttpApiRequest()
: RpcServiceRequest("ft", "2021-01-01", "NormalRpcHttpApi") {
setMethod(HttpRequest::Method::Get);
}
NormalRpcHttpApiRequest::~NormalRpcHttpApiRequest() {}

17
ft/src/model/FtFlowSpecialResult.cc → ft/src/model/NormalRpcHttpApiResult.cc
View File

@@ -14,38 +14,31 @@
* limitations under the License.
*/
#include <alibabacloud/ft/model/FtFlowSpecialResult.h>
#include <alibabacloud/ft/model/NormalRpcHttpApiResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ft;
using namespace AlibabaCloud::Ft::Model;
FtFlowSpecialResult::FtFlowSpecialResult() :
NormalRpcHttpApiResult::NormalRpcHttpApiResult() :
ServiceResult()
{}
FtFlowSpecialResult::FtFlowSpecialResult(const std::string &payload) :
NormalRpcHttpApiResult::NormalRpcHttpApiResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
FtFlowSpecialResult::~FtFlowSpecialResult()
NormalRpcHttpApiResult::~NormalRpcHttpApiResult()
{}
void FtFlowSpecialResult::parse(const std::string &payload)
void NormalRpcHttpApiResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Name"].isNull())
name_ = value["Name"].asString();
}
std::string FtFlowSpecialResult::getName()const
{
return name_;
}

36
ft/src/model/RpcDataUploadAndDownloadRequest.cc Normal file
View File

@@ -0,0 +1,36 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ft/model/RpcDataUploadAndDownloadRequest.h>
using AlibabaCloud::Ft::Model::RpcDataUploadAndDownloadRequest;
RpcDataUploadAndDownloadRequest::RpcDataUploadAndDownloadRequest()
: RpcServiceRequest("ft", "2021-01-01", "RpcDataUploadAndDownload") {
setMethod(HttpRequest::Method::Post);
}
RpcDataUploadAndDownloadRequest::~RpcDataUploadAndDownloadRequest() {}
std::string RpcDataUploadAndDownloadRequest::getQuery1() const {
return query1_;
}
void RpcDataUploadAndDownloadRequest::setQuery1(const std::string &query1) {
query1_ = query1;
setParameter(std::string("query1"), query1);
}

17
ft/src/model/FtParamListResult.cc → ft/src/model/RpcDataUploadAndDownloadResult.cc
View File

@@ -14,38 +14,31 @@
* limitations under the License.
*/
#include <alibabacloud/ft/model/FtParamListResult.h>
#include <alibabacloud/ft/model/RpcDataUploadAndDownloadResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ft;
using namespace AlibabaCloud::Ft::Model;
FtParamListResult::FtParamListResult() :
RpcDataUploadAndDownloadResult::RpcDataUploadAndDownloadResult() :
ServiceResult()
{}
FtParamListResult::FtParamListResult(const std::string &payload) :
RpcDataUploadAndDownloadResult::RpcDataUploadAndDownloadResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
FtParamListResult::~FtParamListResult()
RpcDataUploadAndDownloadResult::~RpcDataUploadAndDownloadResult()
{}
void FtParamListResult::parse(const std::string &payload)
void RpcDataUploadAndDownloadResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Name"].isNull())
name_ = value["Name"].asString();
}
std::string FtParamListResult::getName()const
{
return name_;
}

54
ft/src/model/RpcDataUploadRequest.cc Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ft/model/RpcDataUploadRequest.h>
using AlibabaCloud::Ft::Model::RpcDataUploadRequest;
RpcDataUploadRequest::RpcDataUploadRequest()
: RpcServiceRequest("ft", "2021-01-01", "RpcDataUpload") {
setMethod(HttpRequest::Method::Post);
}
RpcDataUploadRequest::~RpcDataUploadRequest() {}
std::string RpcDataUploadRequest::getQuery1() const {
return query1_;
}
void RpcDataUploadRequest::setQuery1(const std::string &query1) {
query1_ = query1;
setParameter(std::string("query1"), query1);
}
long RpcDataUploadRequest::getQuery2() const {
return query2_;
}
void RpcDataUploadRequest::setQuery2(long query2) {
query2_ = query2;
setParameter(std::string("query2"), std::to_string(query2));
}
std::string RpcDataUploadRequest::getLargeParam() const {
return largeParam_;
}
void RpcDataUploadRequest::setLargeParam(const std::string &largeParam) {
largeParam_ = largeParam;
setBodyParameter(std::string("largeParam"), largeParam);
}

86
ft/src/model/RpcDataUploadResult.cc Normal file
View File

@@ -0,0 +1,86 @@
/*
* 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/ft/model/RpcDataUploadResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ft;
using namespace AlibabaCloud::Ft::Model;
RpcDataUploadResult::RpcDataUploadResult() :
ServiceResult()
{}
RpcDataUploadResult::RpcDataUploadResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
RpcDataUploadResult::~RpcDataUploadResult()
{}
void RpcDataUploadResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["url"].isNull())
url_ = value["url"].asString();
if(!value["totalBytes"].isNull())
totalBytes_ = std::stol(value["totalBytes"].asString());
if(!value["totalTime"].isNull())
totalTime_ = std::stol(value["totalTime"].asString());
if(!value["speed"].isNull())
speed_ = value["speed"].asString();
if(!value["params"].isNull())
params_ = value["params"].asString();
if(!value["headers"].isNull())
headers_ = value["headers"].asString();
}
std::string RpcDataUploadResult::getSpeed()const
{
return speed_;
}
std::string RpcDataUploadResult::getHeaders()const
{
return headers_;
}
long RpcDataUploadResult::getTotalBytes()const
{
return totalBytes_;
}
long RpcDataUploadResult::getTotalTime()const
{
return totalTime_;
}
std::string RpcDataUploadResult::getParams()const
{
return params_;
}
std::string RpcDataUploadResult::getUrl()const
{
return url_;
}

39
ft/src/model/FTApiAliasApiRequest.cc → ft/src/model/RpcDataUploadTestRequest.cc
View File

@@ -1,40 +1,27 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ft/model/FTApiAliasApiRequest.h>
using AlibabaCloud::Ft::Model::FTApiAliasApiRequest;
FTApiAliasApiRequest::FTApiAliasApiRequest() :
RpcServiceRequest("ft", "2018-07-13", "FTApiAliasApi")
{
setMethod(HttpRequest::Method::Post);
}
FTApiAliasApiRequest::~FTApiAliasApiRequest()
{}
std::string FTApiAliasApiRequest::getName()const
{
return name_;
*/
#include <alibabacloud/ft/model/RpcDataUploadTestRequest.h>
using AlibabaCloud::Ft::Model::RpcDataUploadTestRequest;
RpcDataUploadTestRequest::RpcDataUploadTestRequest()
: RpcServiceRequest("ft", "2021-01-01", "RpcDataUploadTest") {
setMethod(HttpRequest::Method::Get);
}
void FTApiAliasApiRequest::setName(const std::string& name)
{
name_ = name;
setParameter("Name", name);
}
RpcDataUploadTestRequest::~RpcDataUploadTestRequest() {}

44
ft/src/model/RpcDataUploadTestResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ft/model/RpcDataUploadTestResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ft;
using namespace AlibabaCloud::Ft::Model;
RpcDataUploadTestResult::RpcDataUploadTestResult() :
ServiceResult()
{}
RpcDataUploadTestResult::RpcDataUploadTestResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
RpcDataUploadTestResult::~RpcDataUploadTestResult()
{}
void RpcDataUploadTestResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

40
ft/src/model/TestFlowStrategy01Request.cc
View File

@@ -1,40 +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/ft/model/TestFlowStrategy01Request.h>
using AlibabaCloud::Ft::Model::TestFlowStrategy01Request;
TestFlowStrategy01Request::TestFlowStrategy01Request() :
RpcServiceRequest("ft", "2018-07-13", "TestFlowStrategy01")
{
setMethod(HttpRequest::Method::Put);
}
TestFlowStrategy01Request::~TestFlowStrategy01Request()
{}
std::map<std::string, std::string> TestFlowStrategy01Request::getNames()const
{
return names_;
}
void TestFlowStrategy01Request::setNames(const std::map<std::string, std::string>& names)
{
names_ = names;
setJsonParameters("Names", names);
}

60
ft/src/model/TestFlowStrategy01Result.cc
View File

@@ -1,60 +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/ft/model/TestFlowStrategy01Result.h>
#include <json/json.h>
using namespace AlibabaCloud::Ft;
using namespace AlibabaCloud::Ft::Model;
TestFlowStrategy01Result::TestFlowStrategy01Result() :
ServiceResult()
{}
TestFlowStrategy01Result::TestFlowStrategy01Result(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
TestFlowStrategy01Result::~TestFlowStrategy01Result()
{}
void TestFlowStrategy01Result::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allList = value["List"]["Id"];
for (const auto &item : allList)
list_.push_back(item.asString());
auto allNames = value["Names"]["Names"];
for (const auto &item : allNames)
names_.push_back(item.asString());
}
std::vector<std::string> TestFlowStrategy01Result::getNames()const
{
return names_;
}
std::vector<std::string> TestFlowStrategy01Result::getList()const
{
return list_;
}

73
ft/src/model/TestHttpApiRequest.cc
View File

@@ -1,73 +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/ft/model/TestHttpApiRequest.h>
using AlibabaCloud::Ft::Model::TestHttpApiRequest;
TestHttpApiRequest::TestHttpApiRequest() :
RpcServiceRequest("ft", "2018-07-13", "TestHttpApi")
{
setMethod(HttpRequest::Method::Post);
}
TestHttpApiRequest::~TestHttpApiRequest()
{}
std::string TestHttpApiRequest::getStringValue()const
{
return stringValue_;
}
void TestHttpApiRequest::setStringValue(const std::string& stringValue)
{
stringValue_ = stringValue;
setParameter("StringValue", stringValue);
}
std::string TestHttpApiRequest::getOtherParam()const
{
return otherParam_;
}
void TestHttpApiRequest::setOtherParam(const std::string& otherParam)
{
otherParam_ = otherParam;
setParameter("OtherParam", otherParam);
}
bool TestHttpApiRequest::getBooleanParam()const
{
return booleanParam_;
}
void TestHttpApiRequest::setBooleanParam(bool booleanParam)
{
booleanParam_ = booleanParam;
setParameter("BooleanParam", booleanParam ? "true" : "false");
}
std::string TestHttpApiRequest::getDefaultValue()const
{
return defaultValue_;
}
void TestHttpApiRequest::setDefaultValue(const std::string& defaultValue)
{
defaultValue_ = defaultValue;
setParameter("DefaultValue", defaultValue);
}

58
ft/src/model/TestHttpApiResult.cc
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/ft/model/TestHttpApiResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ft;
using namespace AlibabaCloud::Ft::Model;
TestHttpApiResult::TestHttpApiResult() :
ServiceResult()
{}
TestHttpApiResult::TestHttpApiResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
TestHttpApiResult::~TestHttpApiResult()
{}
void TestHttpApiResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Params"].isNull())
params_ = value["Params"].asString();
if(!value["ServiceRpcSign"].isNull())
serviceRpcSign_ = value["ServiceRpcSign"].asString();
}
std::string TestHttpApiResult::getServiceRpcSign()const
{
return serviceRpcSign_;
}
std::string TestHttpApiResult::getParams()const
{
return params_;
}