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

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;

40
ft/src/model/FTApiAliasApiRequest.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/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_;
}
void FTApiAliasApiRequest::setName(const std::string& name)
{
name_ = name;
setParameter("Name", name);
}

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/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/FtFlowSpecialResult.cc → ft/src/model/NormalRpcHsfApiResult.cc
View File

@@ -14,38 +14,31 @@
* limitations under the License.
*/
#include <alibabacloud/ft/model/FtFlowSpecialResult.h>
#include <alibabacloud/ft/model/NormalRpcHsfApiResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ft;
using namespace AlibabaCloud::Ft::Model;
FtFlowSpecialResult::FtFlowSpecialResult() :
NormalRpcHsfApiResult::NormalRpcHsfApiResult() :
ServiceResult()
{}
FtFlowSpecialResult::FtFlowSpecialResult(const std::string &payload) :
NormalRpcHsfApiResult::NormalRpcHsfApiResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
FtFlowSpecialResult::~FtFlowSpecialResult()
NormalRpcHsfApiResult::~NormalRpcHsfApiResult()
{}
void FtFlowSpecialResult::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 FtFlowSpecialResult::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/FTApiAliasApiResult.cc → ft/src/model/NormalRpcHttpApiResult.cc
View File

@@ -14,38 +14,31 @@
* limitations under the License.
*/
#include <alibabacloud/ft/model/FTApiAliasApiResult.h>
#include <alibabacloud/ft/model/NormalRpcHttpApiResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ft;
using namespace AlibabaCloud::Ft::Model;
FTApiAliasApiResult::FTApiAliasApiResult() :
NormalRpcHttpApiResult::NormalRpcHttpApiResult() :
ServiceResult()
{}
FTApiAliasApiResult::FTApiAliasApiResult(const std::string &payload) :
NormalRpcHttpApiResult::NormalRpcHttpApiResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
FTApiAliasApiResult::~FTApiAliasApiResult()
NormalRpcHttpApiResult::~NormalRpcHttpApiResult()
{}
void FTApiAliasApiResult::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 FTApiAliasApiResult::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/FtFlowSpecialRequest.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/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_;
*/
#include <alibabacloud/ft/model/RpcDataUploadTestRequest.h>
using AlibabaCloud::Ft::Model::RpcDataUploadTestRequest;
RpcDataUploadTestRequest::RpcDataUploadTestRequest()
: RpcServiceRequest("ft", "2021-01-01", "RpcDataUploadTest") {
setMethod(HttpRequest::Method::Get);
}
void FtFlowSpecialRequest::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_;
}