Generated 2021-01-01 for Ft.

ft/src/FtClient.cc

@@ -51,108 +51,216 @@ FtClient::FtClient(const std::string & accessKeyId, const std::string & accessKe
 FtClient::~FtClient()
 {}
 
-FtClient::CreateInsOutcome FtClient::createIns(const CreateInsRequest &request) const
+FtClient::DataRateLimitTestOutcome FtClient::dataRateLimitTest(const DataRateLimitTestRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return CreateInsOutcome(endpointOutcome.error());
+		return DataRateLimitTestOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return CreateInsOutcome(CreateInsResult(outcome.result()));
+		return DataRateLimitTestOutcome(DataRateLimitTestResult(outcome.result()));
 	else
-		return CreateInsOutcome(outcome.error());
+		return DataRateLimitTestOutcome(outcome.error());
 }
 
-void FtClient::createInsAsync(const CreateInsRequest& request, const CreateInsAsyncHandler& 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, createIns(request), context);
+		handler(this, request, dataRateLimitTest(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-FtClient::CreateInsOutcomeCallable FtClient::createInsCallable(const CreateInsRequest &request) const
+FtClient::DataRateLimitTestOutcomeCallable FtClient::dataRateLimitTestCallable(const DataRateLimitTestRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<CreateInsOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<DataRateLimitTestOutcome()>>(
 			[this, request]()
 			{
-			return this->createIns(request);
+			return this->dataRateLimitTest(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
 
-FtClient::RpcNoDefaultErrorCodeApiOutcome FtClient::rpcNoDefaultErrorCodeApi(const RpcNoDefaultErrorCodeApiRequest &request) const
+FtClient::NormalRpcHsfApiOutcome FtClient::normalRpcHsfApi(const NormalRpcHsfApiRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return RpcNoDefaultErrorCodeApiOutcome(endpointOutcome.error());
+		return NormalRpcHsfApiOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return RpcNoDefaultErrorCodeApiOutcome(RpcNoDefaultErrorCodeApiResult(outcome.result()));
+		return NormalRpcHsfApiOutcome(NormalRpcHsfApiResult(outcome.result()));
 	else
-		return RpcNoDefaultErrorCodeApiOutcome(outcome.error());
+		return NormalRpcHsfApiOutcome(outcome.error());
 }
 
-void FtClient::rpcNoDefaultErrorCodeApiAsync(const RpcNoDefaultErrorCodeApiRequest& request, const RpcNoDefaultErrorCodeApiAsyncHandler& 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, rpcNoDefaultErrorCodeApi(request), context);
+		handler(this, request, normalRpcHsfApi(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-FtClient::RpcNoDefaultErrorCodeApiOutcomeCallable FtClient::rpcNoDefaultErrorCodeApiCallable(const RpcNoDefaultErrorCodeApiRequest &request) const
+FtClient::NormalRpcHsfApiOutcomeCallable FtClient::normalRpcHsfApiCallable(const NormalRpcHsfApiRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<RpcNoDefaultErrorCodeApiOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<NormalRpcHsfApiOutcome()>>(
 			[this, request]()
 			{
-			return this->rpcNoDefaultErrorCodeApi(request);
+			return this->normalRpcHsfApi(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
 
-FtClient::UpdateInsOutcome FtClient::updateIns(const UpdateInsRequest &request) const
+FtClient::NormalRpcHttpApiOutcome FtClient::normalRpcHttpApi(const NormalRpcHttpApiRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return UpdateInsOutcome(endpointOutcome.error());
+		return NormalRpcHttpApiOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return UpdateInsOutcome(UpdateInsResult(outcome.result()));
+		return NormalRpcHttpApiOutcome(NormalRpcHttpApiResult(outcome.result()));
 	else
-		return UpdateInsOutcome(outcome.error());
+		return NormalRpcHttpApiOutcome(outcome.error());
 }
 
-void FtClient::updateInsAsync(const UpdateInsRequest& request, const UpdateInsAsyncHandler& 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, updateIns(request), context);
+		handler(this, request, normalRpcHttpApi(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-FtClient::UpdateInsOutcomeCallable FtClient::updateInsCallable(const UpdateInsRequest &request) const
+FtClient::NormalRpcHttpApiOutcomeCallable FtClient::normalRpcHttpApiCallable(const NormalRpcHttpApiRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<UpdateInsOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<NormalRpcHttpApiOutcome()>>(
 			[this, request]()
 			{
-			return this->updateIns(request);
+			return this->normalRpcHttpApi(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FtClient::RpcDataUploadOutcome FtClient::rpcDataUpload(const RpcDataUploadRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RpcDataUploadOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RpcDataUploadOutcome(RpcDataUploadResult(outcome.result()));
+	else
+		return RpcDataUploadOutcome(outcome.error());
+}
+
+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, rpcDataUpload(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FtClient::RpcDataUploadOutcomeCallable FtClient::rpcDataUploadCallable(const RpcDataUploadRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RpcDataUploadOutcome()>>(
+			[this, request]()
+			{
+			return this->rpcDataUpload(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FtClient::RpcDataUploadAndDownloadOutcome FtClient::rpcDataUploadAndDownload(const RpcDataUploadAndDownloadRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RpcDataUploadAndDownloadOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RpcDataUploadAndDownloadOutcome(RpcDataUploadAndDownloadResult(outcome.result()));
+	else
+		return RpcDataUploadAndDownloadOutcome(outcome.error());
+}
+
+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, rpcDataUploadAndDownload(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FtClient::RpcDataUploadAndDownloadOutcomeCallable FtClient::rpcDataUploadAndDownloadCallable(const RpcDataUploadAndDownloadRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RpcDataUploadAndDownloadOutcome()>>(
+			[this, request]()
+			{
+			return this->rpcDataUploadAndDownload(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FtClient::RpcDataUploadTestOutcome FtClient::rpcDataUploadTest(const RpcDataUploadTestRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RpcDataUploadTestOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RpcDataUploadTestOutcome(RpcDataUploadTestResult(outcome.result()));
+	else
+		return RpcDataUploadTestOutcome(outcome.error());
+}
+
+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, rpcDataUploadTest(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FtClient::RpcDataUploadTestOutcomeCallable FtClient::rpcDataUploadTestCallable(const RpcDataUploadTestRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RpcDataUploadTestOutcome()>>(
+			[this, request]()
+			{
+			return this->rpcDataUploadTest(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));

ft/src/model/CreateInsRequest.cc

@@ -1,81 +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/CreateInsRequest.h>
-
-using AlibabaCloud::Ft::Model::CreateInsRequest;
-
-CreateInsRequest::CreateInsRequest()
-    : RpcServiceRequest("ft", "2015-03-03", "CreateIns") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-CreateInsRequest::~CreateInsRequest() {}
-
-std::string CreateInsRequest::getNewparam1() const {
-  return newparam1_;
-}
-
-void CreateInsRequest::setNewparam1(const std::string &newparam1) {
-  newparam1_ = newparam1;
-  setParameter(std::string("new-param-1"), newparam1);
-}
-
-std::string CreateInsRequest::getBind() const {
-  return bind_;
-}
-
-void CreateInsRequest::setBind(const std::string &bind) {
-  bind_ = bind;
-  setParameter(std::string("Bind"), bind);
-}
-
-std::string CreateInsRequest::getTest() const {
-  return test_;
-}
-
-void CreateInsRequest::setTest(const std::string &test) {
-  test_ = test;
-  setParameter(std::string("Test"), test);
-}
-
-std::string CreateInsRequest::getSuccess() const {
-  return success_;
-}
-
-void CreateInsRequest::setSuccess(const std::string &success) {
-  success_ = success;
-  setParameter(std::string("Success"), success);
-}
-
-std::string CreateInsRequest::getTime() const {
-  return time_;
-}
-
-void CreateInsRequest::setTime(const std::string &time) {
-  time_ = time;
-  setParameter(std::string("Time"), time);
-}
-
-std::string CreateInsRequest::getNewPala() const {
-  return newPala_;
-}
-
-void CreateInsRequest::setNewPala(const std::string &newPala) {
-  newPala_ = newPala;
-  setParameter(std::string("NewPala"), newPala);
-}
-

ft/src/model/DataRateLimitTestRequest.cc

@@ -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);
+}
+

ft/src/model/DataRateLimitTestResult.cc

@@ -14,45 +14,31 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/ft/model/UpdateInsResult.h>
+#include <alibabacloud/ft/model/DataRateLimitTestResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Ft;
 using namespace AlibabaCloud::Ft::Model;
 
-UpdateInsResult::UpdateInsResult() :
+DataRateLimitTestResult::DataRateLimitTestResult() :
 	ServiceResult()
 {}
 
-UpdateInsResult::UpdateInsResult(const std::string &payload) :
+DataRateLimitTestResult::DataRateLimitTestResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-UpdateInsResult::~UpdateInsResult()
+DataRateLimitTestResult::~DataRateLimitTestResult()
 {}
 
-void UpdateInsResult::parse(const std::string &payload)
+void DataRateLimitTestResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["Code"].isNull())
-		code_ = value["Code"].asString();
-	if(!value["Success"].isNull())
-		success_ = value["Success"].asString();
 
 }
 
-std::string UpdateInsResult::getCode()const
-{
-	return code_;
-}
-
-std::string UpdateInsResult::getSuccess()const
-{
-	return success_;
-}
-

ft/src/model/NormalRpcHsfApiRequest.cc

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

ft/src/model/NormalRpcHsfApiResult.cc

@@ -14,45 +14,31 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/ft/model/CreateInsResult.h>
+#include <alibabacloud/ft/model/NormalRpcHsfApiResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Ft;
 using namespace AlibabaCloud::Ft::Model;
 
-CreateInsResult::CreateInsResult() :
+NormalRpcHsfApiResult::NormalRpcHsfApiResult() :
 	ServiceResult()
 {}
 
-CreateInsResult::CreateInsResult(const std::string &payload) :
+NormalRpcHsfApiResult::NormalRpcHsfApiResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-CreateInsResult::~CreateInsResult()
+NormalRpcHsfApiResult::~NormalRpcHsfApiResult()
 {}
 
-void CreateInsResult::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["Code"].isNull())
-		code_ = value["Code"].asString();
-	if(!value["Success"].isNull())
-		success_ = value["Success"].asString();
 
 }
 
-std::string CreateInsResult::getCode()const
-{
-	return code_;
-}
-
-std::string CreateInsResult::getSuccess()const
-{
-	return success_;
-}
-

ft/src/model/NormalRpcHttpApiRequest.cc

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

ft/src/model/NormalRpcHttpApiResult.cc

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

ft/src/model/RpcDataUploadAndDownloadRequest.cc

@@ -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);
+}
+

ft/src/model/RpcDataUploadAndDownloadResult.cc

@@ -14,45 +14,31 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/ft/model/RpcNoDefaultErrorCodeApiResult.h>
+#include <alibabacloud/ft/model/RpcDataUploadAndDownloadResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Ft;
 using namespace AlibabaCloud::Ft::Model;
 
-RpcNoDefaultErrorCodeApiResult::RpcNoDefaultErrorCodeApiResult() :
+RpcDataUploadAndDownloadResult::RpcDataUploadAndDownloadResult() :
 	ServiceResult()
 {}
 
-RpcNoDefaultErrorCodeApiResult::RpcNoDefaultErrorCodeApiResult(const std::string &payload) :
+RpcDataUploadAndDownloadResult::RpcDataUploadAndDownloadResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-RpcNoDefaultErrorCodeApiResult::~RpcNoDefaultErrorCodeApiResult()
+RpcDataUploadAndDownloadResult::~RpcDataUploadAndDownloadResult()
 {}
 
-void RpcNoDefaultErrorCodeApiResult::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["Code"].isNull())
-		code_ = value["Code"].asString();
-	if(!value["Success"].isNull())
-		success_ = value["Success"].asString();
 
 }
 
-std::string RpcNoDefaultErrorCodeApiResult::getCode()const
-{
-	return code_;
-}
-
-std::string RpcNoDefaultErrorCodeApiResult::getSuccess()const
-{
-	return success_;
-}
-

ft/src/model/RpcDataUploadRequest.cc

@@ -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);
+}
+

ft/src/model/RpcDataUploadResult.cc

@@ -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_;
+}
+

ft/src/model/RpcDataUploadTestRequest.cc

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

ft/src/model/RpcDataUploadTestResult.cc

@@ -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());
+
+}
+

ft/src/model/RpcNoDefaultErrorCodeApiRequest.cc

@@ -1,81 +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/RpcNoDefaultErrorCodeApiRequest.h>
-
-using AlibabaCloud::Ft::Model::RpcNoDefaultErrorCodeApiRequest;
-
-RpcNoDefaultErrorCodeApiRequest::RpcNoDefaultErrorCodeApiRequest()
-    : RpcServiceRequest("ft", "2015-03-03", "RpcNoDefaultErrorCodeApi") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-RpcNoDefaultErrorCodeApiRequest::~RpcNoDefaultErrorCodeApiRequest() {}
-
-std::string RpcNoDefaultErrorCodeApiRequest::getHttpMe() const {
-  return httpMe_;
-}
-
-void RpcNoDefaultErrorCodeApiRequest::setHttpMe(const std::string &httpMe) {
-  httpMe_ = httpMe;
-  setParameter(std::string("HttpMe"), httpMe);
-}
-
-std::string RpcNoDefaultErrorCodeApiRequest::getHttpStatusCode() const {
-  return httpStatusCode_;
-}
-
-void RpcNoDefaultErrorCodeApiRequest::setHttpStatusCode(const std::string &httpStatusCode) {
-  httpStatusCode_ = httpStatusCode;
-  setParameter(std::string("HttpStatusCode"), httpStatusCode);
-}
-
-std::string RpcNoDefaultErrorCodeApiRequest::getSetUser() const {
-  return setUser_;
-}
-
-void RpcNoDefaultErrorCodeApiRequest::setSetUser(const std::string &setUser) {
-  setUser_ = setUser;
-  setParameter(std::string("SetUser"), setUser);
-}
-
-std::string RpcNoDefaultErrorCodeApiRequest::getCode() const {
-  return code_;
-}
-
-void RpcNoDefaultErrorCodeApiRequest::setCode(const std::string &code) {
-  code_ = code;
-  setParameter(std::string("Code"), code);
-}
-
-std::string RpcNoDefaultErrorCodeApiRequest::getSuccess() const {
-  return success_;
-}
-
-void RpcNoDefaultErrorCodeApiRequest::setSuccess(const std::string &success) {
-  success_ = success;
-  setParameter(std::string("Success"), success);
-}
-
-std::string RpcNoDefaultErrorCodeApiRequest::getMessage() const {
-  return message_;
-}
-
-void RpcNoDefaultErrorCodeApiRequest::setMessage(const std::string &message) {
-  message_ = message;
-  setParameter(std::string("Message"), message);
-}
-

ft/src/model/UpdateInsRequest.cc

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