Release FeedbackSession.

CHANGELOG

@@ -1,3 +1,6 @@
+2022-04-06 Version: 1.36.1099
+- Release FeedbackSession.
+
 2022-04-06 Version: 1.36.1098
 - Create App Group Support Schedule Busy Workers.
 

VERSION

@@ -1 +1 @@
-1.36.1098
+1.36.1099

imageprocess/include/alibabacloud/imageprocess/model/AnalyzeChestVesselRequest.h

@@ -1,68 +1,60 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
+ */
-
+
-#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_ANALYZECHESTVESSELREQUEST_H_
+#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_ANALYZECHESTVESSELREQUEST_H_
-#define ALIBABACLOUD_IMAGEPROCESS_MODEL_ANALYZECHESTVESSELREQUEST_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_ANALYZECHESTVESSELREQUEST_H_
-
+
-#include <string>
+#include <alibabacloud/imageprocess/ImageprocessExport.h>
-#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
-#include <alibabacloud/imageprocess/ImageprocessExport.h>
+#include <vector>
-
+#include <map>
-namespace AlibabaCloud
+
-{
+namespace AlibabaCloud {
-	namespace Imageprocess
+namespace Imageprocess {
-	{
+namespace Model {
-		namespace Model
+class ALIBABACLOUD_IMAGEPROCESS_EXPORT AnalyzeChestVesselRequest : public RpcServiceRequest {
-		{
+public:
-			class ALIBABACLOUD_IMAGEPROCESS_EXPORT AnalyzeChestVesselRequest : public RpcServiceRequest
+	struct URLList {
-			{
+		std::string uRL;
-			public:
+	};
-				struct URLList
+	AnalyzeChestVesselRequest();
-				{
+	~AnalyzeChestVesselRequest();
-					std::string uRL;
+	std::string getDataSourceType() const;
-				};
+	void setDataSourceType(const std::string &dataSourceType);
-
+	std::string getOrgName() const;
-			public:
+	void setOrgName(const std::string &orgName);
-				AnalyzeChestVesselRequest();
+	std::string getDataFormat() const;
-				~AnalyzeChestVesselRequest();
+	void setDataFormat(const std::string &dataFormat);
-
+	std::vector<URLList> getURLList() const;
-				std::string getDataSourceType()const;
+	void setURLList(const std::vector<URLList> &uRLList);
-				void setDataSourceType(const std::string& dataSourceType);
+	std::string getOrgId() const;
-				std::string getOrgName()const;
+	void setOrgId(const std::string &orgId);
-				void setOrgName(const std::string& orgName);
+	bool getAsync() const;
-				std::string getDataFormat()const;
+	void setAsync(bool async);
-				void setDataFormat(const std::string& dataFormat);
+
-				std::vector<URLList> getURLList()const;
+private:
-				void setURLList(const std::vector<URLList>& uRLList);
+	std::string dataSourceType_;
-				std::string getOrgId()const;
+	std::string orgName_;
-				void setOrgId(const std::string& orgId);
+	std::string dataFormat_;
-				bool getAsync()const;
+	std::vector<URLList> uRLList_;
-				void setAsync(bool async);
+	std::string orgId_;
-
+	bool async_;
-            private:
+};
-				std::string dataSourceType_;
+} // namespace Model
-				std::string orgName_;
+} // namespace Imageprocess
-				std::string dataFormat_;
+} // namespace AlibabaCloud
-				std::vector<URLList> uRLList_;
+#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_ANALYZECHESTVESSELREQUEST_H_
-				std::string orgId_;
-				bool async_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_ANALYZECHESTVESSELREQUEST_H_

imageprocess/include/alibabacloud/imageprocess/model/CalcCACSRequest.h

@@ -1,68 +1,60 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
+ */
-
+
-#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_CALCCACSREQUEST_H_
+#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_CALCCACSREQUEST_H_
-#define ALIBABACLOUD_IMAGEPROCESS_MODEL_CALCCACSREQUEST_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_CALCCACSREQUEST_H_
-
+
-#include <string>
+#include <alibabacloud/imageprocess/ImageprocessExport.h>
-#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
-#include <alibabacloud/imageprocess/ImageprocessExport.h>
+#include <vector>
-
+#include <map>
-namespace AlibabaCloud
+
-{
+namespace AlibabaCloud {
-	namespace Imageprocess
+namespace Imageprocess {
-	{
+namespace Model {
-		namespace Model
+class ALIBABACLOUD_IMAGEPROCESS_EXPORT CalcCACSRequest : public RpcServiceRequest {
-		{
+public:
-			class ALIBABACLOUD_IMAGEPROCESS_EXPORT CalcCACSRequest : public RpcServiceRequest
+	struct URLList {
-			{
+		std::string uRL;
-			public:
+	};
-				struct URLList
+	CalcCACSRequest();
-				{
+	~CalcCACSRequest();
-					std::string uRL;
+	std::string getDataSourceType() const;
-				};
+	void setDataSourceType(const std::string &dataSourceType);
-
+	std::string getOrgName() const;
-			public:
+	void setOrgName(const std::string &orgName);
-				CalcCACSRequest();
+	std::string getDataFormat() const;
-				~CalcCACSRequest();
+	void setDataFormat(const std::string &dataFormat);
-
+	std::vector<URLList> getURLList() const;
-				std::string getDataSourceType()const;
+	void setURLList(const std::vector<URLList> &uRLList);
-				void setDataSourceType(const std::string& dataSourceType);
+	std::string getOrgId() const;
-				std::string getDataFormat()const;
+	void setOrgId(const std::string &orgId);
-				void setDataFormat(const std::string& dataFormat);
+	bool getAsync() const;
-				std::vector<URLList> getURLList()const;
+	void setAsync(bool async);
-				void setURLList(const std::vector<URLList>& uRLList);
+
-				std::string getOrgId()const;
+private:
-				void setOrgId(const std::string& orgId);
+	std::string dataSourceType_;
-				bool getAsync()const;
+	std::string orgName_;
-				void setAsync(bool async);
+	std::string dataFormat_;
-				std::string getOrgName()const;
+	std::vector<URLList> uRLList_;
-				void setOrgName(const std::string& orgName);
+	std::string orgId_;
-
+	bool async_;
-            private:
+};
-				std::string dataSourceType_;
+} // namespace Model
-				std::string dataFormat_;
+} // namespace Imageprocess
-				std::vector<URLList> uRLList_;
+} // namespace AlibabaCloud
-				std::string orgId_;
+#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_CALCCACSREQUEST_H_
-				bool async_;
-				std::string orgName_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_CALCCACSREQUEST_H_

imageprocess/include/alibabacloud/imageprocess/model/ClassifyFNFRequest.h

@@ -1,60 +1,54 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
+ */
-
+
-#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_CLASSIFYFNFREQUEST_H_
+#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_CLASSIFYFNFREQUEST_H_
-#define ALIBABACLOUD_IMAGEPROCESS_MODEL_CLASSIFYFNFREQUEST_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_CLASSIFYFNFREQUEST_H_
-
+
-#include <string>
+#include <alibabacloud/imageprocess/ImageprocessExport.h>
-#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
-#include <alibabacloud/imageprocess/ImageprocessExport.h>
+#include <vector>
-
+#include <map>
-namespace AlibabaCloud
+
-{
+namespace AlibabaCloud {
-	namespace Imageprocess
+namespace Imageprocess {
-	{
+namespace Model {
-		namespace Model
+class ALIBABACLOUD_IMAGEPROCESS_EXPORT ClassifyFNFRequest : public RpcServiceRequest {
-		{
+public:
-			class ALIBABACLOUD_IMAGEPROCESS_EXPORT ClassifyFNFRequest : public RpcServiceRequest
+	ClassifyFNFRequest();
-			{
+	~ClassifyFNFRequest();
-
+	std::string getOrgName() const;
-			public:
+	void setOrgName(const std::string &orgName);
-				ClassifyFNFRequest();
+	std::string getTracerId() const;
-				~ClassifyFNFRequest();
+	void setTracerId(const std::string &tracerId);
-
+	std::string getDataFormat() const;
-				std::string getDataFormat()const;
+	void setDataFormat(const std::string &dataFormat);
-				void setDataFormat(const std::string& dataFormat);
+	std::string getOrgId() const;
-				std::string getOrgId()const;
+	void setOrgId(const std::string &orgId);
-				void setOrgId(const std::string& orgId);
+	std::string getImageUrl() const;
-				std::string getOrgName()const;
+	void setImageUrl(const std::string &imageUrl);
-				void setOrgName(const std::string& orgName);
+
-				std::string getImageUrl()const;
+private:
-				void setImageUrl(const std::string& imageUrl);
+	std::string orgName_;
-				std::string getTracerId()const;
+	std::string tracerId_;
-				void setTracerId(const std::string& tracerId);
+	std::string dataFormat_;
-
+	std::string orgId_;
-            private:
+	std::string imageUrl_;
-				std::string dataFormat_;
+};
-				std::string orgId_;
+} // namespace Model
-				std::string orgName_;
+} // namespace Imageprocess
-				std::string imageUrl_;
+} // namespace AlibabaCloud
-				std::string tracerId_;
+#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_CLASSIFYFNFREQUEST_H_
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_CLASSIFYFNFREQUEST_H_

imageprocess/include/alibabacloud/imageprocess/model/DetectCovid19CadRequest.h

@@ -1,65 +1,57 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
+ */
-
+
-#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTCOVID19CADREQUEST_H_
+#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTCOVID19CADREQUEST_H_
-#define ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTCOVID19CADREQUEST_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTCOVID19CADREQUEST_H_
-
+
-#include <string>
+#include <alibabacloud/imageprocess/ImageprocessExport.h>
-#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
-#include <alibabacloud/imageprocess/ImageprocessExport.h>
+#include <vector>
-
+#include <map>
-namespace AlibabaCloud
+
-{
+namespace AlibabaCloud {
-	namespace Imageprocess
+namespace Imageprocess {
-	{
+namespace Model {
-		namespace Model
+class ALIBABACLOUD_IMAGEPROCESS_EXPORT DetectCovid19CadRequest : public RpcServiceRequest {
-		{
+public:
-			class ALIBABACLOUD_IMAGEPROCESS_EXPORT DetectCovid19CadRequest : public RpcServiceRequest
+	struct URLList {
-			{
+		std::string uRL;
-			public:
+	};
-				struct URLList
+	DetectCovid19CadRequest();
-				{
+	~DetectCovid19CadRequest();
-					std::string uRL;
+	std::string getOrgName() const;
-				};
+	void setOrgName(const std::string &orgName);
-
+	std::string getDataFormat() const;
-			public:
+	void setDataFormat(const std::string &dataFormat);
-				DetectCovid19CadRequest();
+	std::vector<URLList> getURLList() const;
-				~DetectCovid19CadRequest();
+	void setURLList(const std::vector<URLList> &uRLList);
-
+	std::string getOrgId() const;
-				std::string getDataFormat()const;
+	void setOrgId(const std::string &orgId);
-				void setDataFormat(const std::string& dataFormat);
+	bool getAsync() const;
-				std::vector<URLList> getURLList()const;
+	void setAsync(bool async);
-				void setURLList(const std::vector<URLList>& uRLList);
+
-				std::string getOrgId()const;
+private:
-				void setOrgId(const std::string& orgId);
+	std::string orgName_;
-				bool getAsync()const;
+	std::string dataFormat_;
-				void setAsync(bool async);
+	std::vector<URLList> uRLList_;
-				std::string getOrgName()const;
+	std::string orgId_;
-				void setOrgName(const std::string& orgName);
+	bool async_;
-
+};
-            private:
+} // namespace Model
-				std::string dataFormat_;
+} // namespace Imageprocess
-				std::vector<URLList> uRLList_;
+} // namespace AlibabaCloud
-				std::string orgId_;
+#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTCOVID19CADREQUEST_H_
-				bool async_;
-				std::string orgName_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTCOVID19CADREQUEST_H_

imageprocess/include/alibabacloud/imageprocess/model/DetectHipKeypointXRayRequest.h

@@ -1,60 +1,54 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
+ */
-
+
-#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTHIPKEYPOINTXRAYREQUEST_H_
+#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTHIPKEYPOINTXRAYREQUEST_H_
-#define ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTHIPKEYPOINTXRAYREQUEST_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTHIPKEYPOINTXRAYREQUEST_H_
-
+
-#include <string>
+#include <alibabacloud/imageprocess/ImageprocessExport.h>
-#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
-#include <alibabacloud/imageprocess/ImageprocessExport.h>
+#include <vector>
-
+#include <map>
-namespace AlibabaCloud
+
-{
+namespace AlibabaCloud {
-	namespace Imageprocess
+namespace Imageprocess {
-	{
+namespace Model {
-		namespace Model
+class ALIBABACLOUD_IMAGEPROCESS_EXPORT DetectHipKeypointXRayRequest : public RpcServiceRequest {
-		{
+public:
-			class ALIBABACLOUD_IMAGEPROCESS_EXPORT DetectHipKeypointXRayRequest : public RpcServiceRequest
+	DetectHipKeypointXRayRequest();
-			{
+	~DetectHipKeypointXRayRequest();
-
+	std::string getOrgName() const;
-			public:
+	void setOrgName(const std::string &orgName);
-				DetectHipKeypointXRayRequest();
+	std::string getTracerId() const;
-				~DetectHipKeypointXRayRequest();
+	void setTracerId(const std::string &tracerId);
-
+	std::string getDataFormat() const;
-				std::string getOrgName()const;
+	void setDataFormat(const std::string &dataFormat);
-				void setOrgName(const std::string& orgName);
+	std::string getOrgId() const;
-				std::string getTracerId()const;
+	void setOrgId(const std::string &orgId);
-				void setTracerId(const std::string& tracerId);
+	std::string getImageUrl() const;
-				std::string getDataFormat()const;
+	void setImageUrl(const std::string &imageUrl);
-				void setDataFormat(const std::string& dataFormat);
+
-				std::string getOrgId()const;
+private:
-				void setOrgId(const std::string& orgId);
+	std::string orgName_;
-				std::string getImageUrl()const;
+	std::string tracerId_;
-				void setImageUrl(const std::string& imageUrl);
+	std::string dataFormat_;
-
+	std::string orgId_;
-            private:
+	std::string imageUrl_;
-				std::string orgName_;
+};
-				std::string tracerId_;
+} // namespace Model
-				std::string dataFormat_;
+} // namespace Imageprocess
-				std::string orgId_;
+} // namespace AlibabaCloud
-				std::string imageUrl_;
+#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTHIPKEYPOINTXRAYREQUEST_H_
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTHIPKEYPOINTXRAYREQUEST_H_

imageprocess/include/alibabacloud/imageprocess/model/DetectKneeKeypointXRayRequest.h

@@ -1,60 +1,54 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
+ */
-
+
-#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTKNEEKEYPOINTXRAYREQUEST_H_
+#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTKNEEKEYPOINTXRAYREQUEST_H_
-#define ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTKNEEKEYPOINTXRAYREQUEST_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTKNEEKEYPOINTXRAYREQUEST_H_
-
+
-#include <string>
+#include <alibabacloud/imageprocess/ImageprocessExport.h>
-#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
-#include <alibabacloud/imageprocess/ImageprocessExport.h>
+#include <vector>
-
+#include <map>
-namespace AlibabaCloud
+
-{
+namespace AlibabaCloud {
-	namespace Imageprocess
+namespace Imageprocess {
-	{
+namespace Model {
-		namespace Model
+class ALIBABACLOUD_IMAGEPROCESS_EXPORT DetectKneeKeypointXRayRequest : public RpcServiceRequest {
-		{
+public:
-			class ALIBABACLOUD_IMAGEPROCESS_EXPORT DetectKneeKeypointXRayRequest : public RpcServiceRequest
+	DetectKneeKeypointXRayRequest();
-			{
+	~DetectKneeKeypointXRayRequest();
-
+	std::string getOrgName() const;
-			public:
+	void setOrgName(const std::string &orgName);
-				DetectKneeKeypointXRayRequest();
+	std::string getTracerId() const;
-				~DetectKneeKeypointXRayRequest();
+	void setTracerId(const std::string &tracerId);
-
+	std::string getDataFormat() const;
-				std::string getDataFormat()const;
+	void setDataFormat(const std::string &dataFormat);
-				void setDataFormat(const std::string& dataFormat);
+	std::string getOrgId() const;
-				std::string getOrgId()const;
+	void setOrgId(const std::string &orgId);
-				void setOrgId(const std::string& orgId);
+	std::string getImageUrl() const;
-				std::string getOrgName()const;
+	void setImageUrl(const std::string &imageUrl);
-				void setOrgName(const std::string& orgName);
+
-				std::string getImageUrl()const;
+private:
-				void setImageUrl(const std::string& imageUrl);
+	std::string orgName_;
-				std::string getTracerId()const;
+	std::string tracerId_;
-				void setTracerId(const std::string& tracerId);
+	std::string dataFormat_;
-
+	std::string orgId_;
-            private:
+	std::string imageUrl_;
-				std::string dataFormat_;
+};
-				std::string orgId_;
+} // namespace Model
-				std::string orgName_;
+} // namespace Imageprocess
-				std::string imageUrl_;
+} // namespace AlibabaCloud
-				std::string tracerId_;
+#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTKNEEKEYPOINTXRAYREQUEST_H_
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTKNEEKEYPOINTXRAYREQUEST_H_

imageprocess/include/alibabacloud/imageprocess/model/DetectKneeXRayRequest.h

@@ -1,57 +1,51 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
+ */
-
+
-#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTKNEEXRAYREQUEST_H_
+#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTKNEEXRAYREQUEST_H_
-#define ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTKNEEXRAYREQUEST_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTKNEEXRAYREQUEST_H_
-
+
-#include <string>
+#include <alibabacloud/imageprocess/ImageprocessExport.h>
-#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
-#include <alibabacloud/imageprocess/ImageprocessExport.h>
+#include <vector>
-
+#include <map>
-namespace AlibabaCloud
+
-{
+namespace AlibabaCloud {
-	namespace Imageprocess
+namespace Imageprocess {
-	{
+namespace Model {
-		namespace Model
+class ALIBABACLOUD_IMAGEPROCESS_EXPORT DetectKneeXRayRequest : public RpcServiceRequest {
-		{
+public:
-			class ALIBABACLOUD_IMAGEPROCESS_EXPORT DetectKneeXRayRequest : public RpcServiceRequest
+	DetectKneeXRayRequest();
-			{
+	~DetectKneeXRayRequest();
-
+	std::string getOrgName() const;
-			public:
+	void setOrgName(const std::string &orgName);
-				DetectKneeXRayRequest();
+	std::string getDataFormat() const;
-				~DetectKneeXRayRequest();
+	void setDataFormat(const std::string &dataFormat);
-
+	std::string getUrl() const;
-				std::string getDataFormat()const;
+	void setUrl(const std::string &url);
-				void setDataFormat(const std::string& dataFormat);
+	std::string getOrgId() const;
-				std::string getUrl()const;
+	void setOrgId(const std::string &orgId);
-				void setUrl(const std::string& url);
+
-				std::string getOrgId()const;
+private:
-				void setOrgId(const std::string& orgId);
+	std::string orgName_;
-				std::string getOrgName()const;
+	std::string dataFormat_;
-				void setOrgName(const std::string& orgName);
+	std::string url_;
-
+	std::string orgId_;
-            private:
+};
-				std::string dataFormat_;
+} // namespace Model
-				std::string url_;
+} // namespace Imageprocess
-				std::string orgId_;
+} // namespace AlibabaCloud
-				std::string orgName_;
+#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTKNEEXRAYREQUEST_H_
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTKNEEXRAYREQUEST_H_

imageprocess/include/alibabacloud/imageprocess/model/DetectLungNoduleRequest.h

@@ -1,68 +1,60 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
+ */
-
+
-#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTLUNGNODULEREQUEST_H_
+#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTLUNGNODULEREQUEST_H_
-#define ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTLUNGNODULEREQUEST_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTLUNGNODULEREQUEST_H_
-
+
-#include <string>
+#include <alibabacloud/imageprocess/ImageprocessExport.h>
-#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
-#include <alibabacloud/imageprocess/ImageprocessExport.h>
+#include <vector>
-
+#include <map>
-namespace AlibabaCloud
+
-{
+namespace AlibabaCloud {
-	namespace Imageprocess
+namespace Imageprocess {
-	{
+namespace Model {
-		namespace Model
+class ALIBABACLOUD_IMAGEPROCESS_EXPORT DetectLungNoduleRequest : public RpcServiceRequest {
-		{
+public:
-			class ALIBABACLOUD_IMAGEPROCESS_EXPORT DetectLungNoduleRequest : public RpcServiceRequest
+	struct URLList {
-			{
+		std::string uRL;
-			public:
+	};
-				struct URLList
+	DetectLungNoduleRequest();
-				{
+	~DetectLungNoduleRequest();
-					std::string uRL;
+	float getThreshold() const;
-				};
+	void setThreshold(float threshold);
-
+	std::string getOrgName() const;
-			public:
+	void setOrgName(const std::string &orgName);
-				DetectLungNoduleRequest();
+	std::string getDataFormat() const;
-				~DetectLungNoduleRequest();
+	void setDataFormat(const std::string &dataFormat);
-
+	std::vector<URLList> getURLList() const;
-				float getThreshold()const;
+	void setURLList(const std::vector<URLList> &uRLList);
-				void setThreshold(float threshold);
+	std::string getOrgId() const;
-				std::string getOrgName()const;
+	void setOrgId(const std::string &orgId);
-				void setOrgName(const std::string& orgName);
+	bool getAsync() const;
-				std::string getDataFormat()const;
+	void setAsync(bool async);
-				void setDataFormat(const std::string& dataFormat);
+
-				std::vector<URLList> getURLList()const;
+private:
-				void setURLList(const std::vector<URLList>& uRLList);
+	float threshold_;
-				std::string getOrgId()const;
+	std::string orgName_;
-				void setOrgId(const std::string& orgId);
+	std::string dataFormat_;
-				bool getAsync()const;
+	std::vector<URLList> uRLList_;
-				void setAsync(bool async);
+	std::string orgId_;
-
+	bool async_;
-            private:
+};
-				float threshold_;
+} // namespace Model
-				std::string orgName_;
+} // namespace Imageprocess
-				std::string dataFormat_;
+} // namespace AlibabaCloud
-				std::vector<URLList> uRLList_;
+#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTLUNGNODULEREQUEST_H_
-				std::string orgId_;
-				bool async_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTLUNGNODULEREQUEST_H_

imageprocess/include/alibabacloud/imageprocess/model/DetectRibFractureRequest.h

@@ -1,68 +1,60 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
+ */
-
+
-#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTRIBFRACTUREREQUEST_H_
+#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTRIBFRACTUREREQUEST_H_
-#define ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTRIBFRACTUREREQUEST_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTRIBFRACTUREREQUEST_H_
-
+
-#include <string>
+#include <alibabacloud/imageprocess/ImageprocessExport.h>
-#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
-#include <alibabacloud/imageprocess/ImageprocessExport.h>
+#include <vector>
-
+#include <map>
-namespace AlibabaCloud
+
-{
+namespace AlibabaCloud {
-	namespace Imageprocess
+namespace Imageprocess {
-	{
+namespace Model {
-		namespace Model
+class ALIBABACLOUD_IMAGEPROCESS_EXPORT DetectRibFractureRequest : public RpcServiceRequest {
-		{
+public:
-			class ALIBABACLOUD_IMAGEPROCESS_EXPORT DetectRibFractureRequest : public RpcServiceRequest
+	struct URLList {
-			{
+		std::string uRL;
-			public:
+	};
-				struct URLList
+	DetectRibFractureRequest();
-				{
+	~DetectRibFractureRequest();
-					std::string uRL;
+	std::string getOrgName() const;
-				};
+	void setOrgName(const std::string &orgName);
-
+	std::string getSourceType() const;
-			public:
+	void setSourceType(const std::string &sourceType);
-				DetectRibFractureRequest();
+	std::string getDataFormat() const;
-				~DetectRibFractureRequest();
+	void setDataFormat(const std::string &dataFormat);
-
+	std::vector<URLList> getURLList() const;
-				std::string getOrgName()const;
+	void setURLList(const std::vector<URLList> &uRLList);
-				void setOrgName(const std::string& orgName);
+	std::string getOrgId() const;
-				std::string getSourceType()const;
+	void setOrgId(const std::string &orgId);
-				void setSourceType(const std::string& sourceType);
+	bool getAsync() const;
-				std::string getDataFormat()const;
+	void setAsync(bool async);
-				void setDataFormat(const std::string& dataFormat);
+
-				std::vector<URLList> getURLList()const;
+private:
-				void setURLList(const std::vector<URLList>& uRLList);
+	std::string orgName_;
-				std::string getOrgId()const;
+	std::string sourceType_;
-				void setOrgId(const std::string& orgId);
+	std::string dataFormat_;
-				bool getAsync()const;
+	std::vector<URLList> uRLList_;
-				void setAsync(bool async);
+	std::string orgId_;
-
+	bool async_;
-            private:
+};
-				std::string orgName_;
+} // namespace Model
-				std::string sourceType_;
+} // namespace Imageprocess
-				std::string dataFormat_;
+} // namespace AlibabaCloud
-				std::vector<URLList> uRLList_;
+#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTRIBFRACTUREREQUEST_H_
-				std::string orgId_;
-				bool async_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTRIBFRACTUREREQUEST_H_

imageprocess/include/alibabacloud/imageprocess/model/DetectSkinDiseaseRequest.h

@@ -1,54 +1,48 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
+ */
-
+
-#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTSKINDISEASEREQUEST_H_
+#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTSKINDISEASEREQUEST_H_
-#define ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTSKINDISEASEREQUEST_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTSKINDISEASEREQUEST_H_
-
+
-#include <string>
+#include <alibabacloud/imageprocess/ImageprocessExport.h>
-#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
-#include <alibabacloud/imageprocess/ImageprocessExport.h>
+#include <vector>
-
+#include <map>
-namespace AlibabaCloud
+
-{
+namespace AlibabaCloud {
-	namespace Imageprocess
+namespace Imageprocess {
-	{
+namespace Model {
-		namespace Model
+class ALIBABACLOUD_IMAGEPROCESS_EXPORT DetectSkinDiseaseRequest : public RpcServiceRequest {
-		{
+public:
-			class ALIBABACLOUD_IMAGEPROCESS_EXPORT DetectSkinDiseaseRequest : public RpcServiceRequest
+	DetectSkinDiseaseRequest();
-			{
+	~DetectSkinDiseaseRequest();
-
+	std::string getOrgName() const;
-			public:
+	void setOrgName(const std::string &orgName);
-				DetectSkinDiseaseRequest();
+	std::string getUrl() const;
-				~DetectSkinDiseaseRequest();
+	void setUrl(const std::string &url);
-
+	std::string getOrgId() const;
-				std::string getUrl()const;
+	void setOrgId(const std::string &orgId);
-				void setUrl(const std::string& url);
+
-				std::string getOrgId()const;
+private:
-				void setOrgId(const std::string& orgId);
+	std::string orgName_;
-				std::string getOrgName()const;
+	std::string url_;
-				void setOrgName(const std::string& orgName);
+	std::string orgId_;
-
+};
-            private:
+} // namespace Model
-				std::string url_;
+} // namespace Imageprocess
-				std::string orgId_;
+} // namespace AlibabaCloud
-				std::string orgName_;
+#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTSKINDISEASEREQUEST_H_
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTSKINDISEASEREQUEST_H_

imageprocess/include/alibabacloud/imageprocess/model/DetectSpineMRIRequest.h

@@ -1,62 +1,54 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
+ */
-
+
-#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTSPINEMRIREQUEST_H_
+#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTSPINEMRIREQUEST_H_
-#define ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTSPINEMRIREQUEST_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTSPINEMRIREQUEST_H_
-
+
-#include <string>
+#include <alibabacloud/imageprocess/ImageprocessExport.h>
-#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
-#include <alibabacloud/imageprocess/ImageprocessExport.h>
+#include <vector>
-
+#include <map>
-namespace AlibabaCloud
+
-{
+namespace AlibabaCloud {
-	namespace Imageprocess
+namespace Imageprocess {
-	{
+namespace Model {
-		namespace Model
+class ALIBABACLOUD_IMAGEPROCESS_EXPORT DetectSpineMRIRequest : public RpcServiceRequest {
-		{
+public:
-			class ALIBABACLOUD_IMAGEPROCESS_EXPORT DetectSpineMRIRequest : public RpcServiceRequest
+	struct URLList {
-			{
+		std::string uRL;
-			public:
+	};
-				struct URLList
+	DetectSpineMRIRequest();
-				{
+	~DetectSpineMRIRequest();
-					std::string uRL;
+	std::string getOrgName() const;
-				};
+	void setOrgName(const std::string &orgName);
-
+	std::string getDataFormat() const;
-			public:
+	void setDataFormat(const std::string &dataFormat);
-				DetectSpineMRIRequest();
+	std::vector<URLList> getURLList() const;
-				~DetectSpineMRIRequest();
+	void setURLList(const std::vector<URLList> &uRLList);
-
+	std::string getOrgId() const;
-				std::string getDataFormat()const;
+	void setOrgId(const std::string &orgId);
-				void setDataFormat(const std::string& dataFormat);
+
-				std::vector<URLList> getURLList()const;
+private:
-				void setURLList(const std::vector<URLList>& uRLList);
+	std::string orgName_;
-				std::string getOrgId()const;
+	std::string dataFormat_;
-				void setOrgId(const std::string& orgId);
+	std::vector<URLList> uRLList_;
-				std::string getOrgName()const;
+	std::string orgId_;
-				void setOrgName(const std::string& orgName);
+};
-
+} // namespace Model
-            private:
+} // namespace Imageprocess
-				std::string dataFormat_;
+} // namespace AlibabaCloud
-				std::vector<URLList> uRLList_;
+#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTSPINEMRIREQUEST_H_
-				std::string orgId_;
-				std::string orgName_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_DETECTSPINEMRIREQUEST_H_

imageprocess/include/alibabacloud/imageprocess/model/GetAsyncJobResultRequest.h

@@ -1,51 +1,45 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
+ */
-
+
-#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_GETASYNCJOBRESULTREQUEST_H_
+#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_GETASYNCJOBRESULTREQUEST_H_
-#define ALIBABACLOUD_IMAGEPROCESS_MODEL_GETASYNCJOBRESULTREQUEST_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_GETASYNCJOBRESULTREQUEST_H_
-
+
-#include <string>
+#include <alibabacloud/imageprocess/ImageprocessExport.h>
-#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
-#include <alibabacloud/imageprocess/ImageprocessExport.h>
+#include <vector>
-
+#include <map>
-namespace AlibabaCloud
+
-{
+namespace AlibabaCloud {
-	namespace Imageprocess
+namespace Imageprocess {
-	{
+namespace Model {
-		namespace Model
+class ALIBABACLOUD_IMAGEPROCESS_EXPORT GetAsyncJobResultRequest : public RpcServiceRequest {
-		{
+public:
-			class ALIBABACLOUD_IMAGEPROCESS_EXPORT GetAsyncJobResultRequest : public RpcServiceRequest
+	GetAsyncJobResultRequest();
-			{
+	~GetAsyncJobResultRequest();
-
+	std::string getJobId() const;
-			public:
+	void setJobId(const std::string &jobId);
-				GetAsyncJobResultRequest();
+	bool getAsync() const;
-				~GetAsyncJobResultRequest();
+	void setAsync(bool async);
-
+
-				bool getAsync()const;
+private:
-				void setAsync(bool async);
+	std::string jobId_;
-				std::string getJobId()const;
+	bool async_;
-				void setJobId(const std::string& jobId);
+};
-
+} // namespace Model
-            private:
+} // namespace Imageprocess
-				bool async_;
+} // namespace AlibabaCloud
-				std::string jobId_;
+#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_GETASYNCJOBRESULTREQUEST_H_
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_GETASYNCJOBRESULTREQUEST_H_

imageprocess/include/alibabacloud/imageprocess/model/RunCTRegistrationRequest.h

@@ -1,75 +1,66 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
+ */
-
+
-#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_RUNCTREGISTRATIONREQUEST_H_
+#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_RUNCTREGISTRATIONREQUEST_H_
-#define ALIBABACLOUD_IMAGEPROCESS_MODEL_RUNCTREGISTRATIONREQUEST_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_RUNCTREGISTRATIONREQUEST_H_
-
+
-#include <string>
+#include <alibabacloud/imageprocess/ImageprocessExport.h>
-#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
-#include <alibabacloud/imageprocess/ImageprocessExport.h>
+#include <vector>
-
+#include <map>
-namespace AlibabaCloud
+
-{
+namespace AlibabaCloud {
-	namespace Imageprocess
+namespace Imageprocess {
-	{
+namespace Model {
-		namespace Model
+class ALIBABACLOUD_IMAGEPROCESS_EXPORT RunCTRegistrationRequest : public RpcServiceRequest {
-		{
+public:
-			class ALIBABACLOUD_IMAGEPROCESS_EXPORT RunCTRegistrationRequest : public RpcServiceRequest
+	struct ReferenceList {
-			{
+		std::string referenceURL;
-			public:
+	};
-				struct ReferenceList
+	struct FloatingList {
-				{
+		std::string floatingURL;
-					std::string referenceURL;
+	};
-				};
+	RunCTRegistrationRequest();
-				struct FloatingList
+	~RunCTRegistrationRequest();
-				{
+	std::string getDataSourceType() const;
-					std::string floatingURL;
+	void setDataSourceType(const std::string &dataSourceType);
-				};
+	std::string getOrgName() const;
-
+	void setOrgName(const std::string &orgName);
-			public:
+	std::vector<ReferenceList> getReferenceList() const;
-				RunCTRegistrationRequest();
+	void setReferenceList(const std::vector<ReferenceList> &referenceList);
-				~RunCTRegistrationRequest();
+	std::string getDataFormat() const;
-
+	void setDataFormat(const std::string &dataFormat);
-				std::string getDataSourceType()const;
+	std::string getOrgId() const;
-				void setDataSourceType(const std::string& dataSourceType);
+	void setOrgId(const std::string &orgId);
-				std::string getOrgName()const;
+	bool getAsync() const;
-				void setOrgName(const std::string& orgName);
+	void setAsync(bool async);
-				std::vector<ReferenceList> getReferenceList()const;
+	std::vector<FloatingList> getFloatingList() const;
-				void setReferenceList(const std::vector<ReferenceList>& referenceList);
+	void setFloatingList(const std::vector<FloatingList> &floatingList);
-				std::string getDataFormat()const;
+
-				void setDataFormat(const std::string& dataFormat);
+private:
-				std::string getOrgId()const;
+	std::string dataSourceType_;
-				void setOrgId(const std::string& orgId);
+	std::string orgName_;
-				bool getAsync()const;
+	std::vector<ReferenceList> referenceList_;
-				void setAsync(bool async);
+	std::string dataFormat_;
-				std::vector<FloatingList> getFloatingList()const;
+	std::string orgId_;
-				void setFloatingList(const std::vector<FloatingList>& floatingList);
+	bool async_;
-
+	std::vector<FloatingList> floatingList_;
-            private:
+};
-				std::string dataSourceType_;
+} // namespace Model
-				std::string orgName_;
+} // namespace Imageprocess
-				std::vector<ReferenceList> referenceList_;
+} // namespace AlibabaCloud
-				std::string dataFormat_;
+#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_RUNCTREGISTRATIONREQUEST_H_
-				std::string orgId_;
-				bool async_;
-				std::vector<FloatingList> floatingList_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_RUNCTREGISTRATIONREQUEST_H_

imageprocess/include/alibabacloud/imageprocess/model/RunMedQARequest.h

@@ -1,82 +1,72 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
+ */
-
+
-#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_RUNMEDQAREQUEST_H_
+#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_RUNMEDQAREQUEST_H_
-#define ALIBABACLOUD_IMAGEPROCESS_MODEL_RUNMEDQAREQUEST_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_RUNMEDQAREQUEST_H_
-
+
-#include <string>
+#include <alibabacloud/imageprocess/ImageprocessExport.h>
-#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
-#include <alibabacloud/imageprocess/ImageprocessExport.h>
+#include <vector>
-
+#include <map>
-namespace AlibabaCloud
+
-{
+namespace AlibabaCloud {
-	namespace Imageprocess
+namespace Imageprocess {
-	{
+namespace Model {
-		namespace Model
+class ALIBABACLOUD_IMAGEPROCESS_EXPORT RunMedQARequest : public RpcServiceRequest {
-		{
+public:
-			class ALIBABACLOUD_IMAGEPROCESS_EXPORT RunMedQARequest : public RpcServiceRequest
+	struct AnswerImageDataList {
-			{
+		std::string answerImageData;
-			public:
+	};
-				struct AnswerImageDataList
+	struct AnswerTextList {
-				{
+		std::string answerText;
-					std::string answerImageData;
+	};
-				};
+	struct AnswerImageURLList {
-				struct AnswerTextList
+		std::string answerImageURL;
-				{
+	};
-					std::string answerText;
+	RunMedQARequest();
-				};
+	~RunMedQARequest();
-				struct AnswerImageURLList
+	std::string getSessionId() const;
-				{
+	void setSessionId(const std::string &sessionId);
-					std::string answerImageURL;
+	std::string getOrgName() const;
-				};
+	void setOrgName(const std::string &orgName);
-
+	std::vector<AnswerImageDataList> getAnswerImageDataList() const;
-			public:
+	void setAnswerImageDataList(const std::vector<AnswerImageDataList> &answerImageDataList);
-				RunMedQARequest();
+	std::vector<AnswerTextList> getAnswerTextList() const;
-				~RunMedQARequest();
+	void setAnswerTextList(const std::vector<AnswerTextList> &answerTextList);
-
+	std::string getDepartment() const;
-				std::string getSessionId()const;
+	void setDepartment(const std::string &department);
-				void setSessionId(const std::string& sessionId);
+	std::vector<AnswerImageURLList> getAnswerImageURLList() const;
-				std::string getOrgName()const;
+	void setAnswerImageURLList(const std::vector<AnswerImageURLList> &answerImageURLList);
-				void setOrgName(const std::string& orgName);
+	std::string getQuestionType() const;
-				std::vector<AnswerImageDataList> getAnswerImageDataList()const;
+	void setQuestionType(const std::string &questionType);
-				void setAnswerImageDataList(const std::vector<AnswerImageDataList>& answerImageDataList);
+	std::string getOrgId() const;
-				std::vector<AnswerTextList> getAnswerTextList()const;
+	void setOrgId(const std::string &orgId);
-				void setAnswerTextList(const std::vector<AnswerTextList>& answerTextList);
+
-				std::string getDepartment()const;
+private:
-				void setDepartment(const std::string& department);
+	std::string sessionId_;
-				std::vector<AnswerImageURLList> getAnswerImageURLList()const;
+	std::string orgName_;
-				void setAnswerImageURLList(const std::vector<AnswerImageURLList>& answerImageURLList);
+	std::vector<AnswerImageDataList> answerImageDataList_;
-				std::string getQuestionType()const;
+	std::vector<AnswerTextList> answerTextList_;
-				void setQuestionType(const std::string& questionType);
+	std::string department_;
-				std::string getOrgId()const;
+	std::vector<AnswerImageURLList> answerImageURLList_;
-				void setOrgId(const std::string& orgId);
+	std::string questionType_;
-
+	std::string orgId_;
-            private:
+};
-				std::string sessionId_;
+} // namespace Model
-				std::string orgName_;
+} // namespace Imageprocess
-				std::vector<AnswerImageDataList> answerImageDataList_;
+} // namespace AlibabaCloud
-				std::vector<AnswerTextList> answerTextList_;
+#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_RUNMEDQAREQUEST_H_
-				std::string department_;
-				std::vector<AnswerImageURLList> answerImageURLList_;
-				std::string questionType_;
-				std::string orgId_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_RUNMEDQAREQUEST_H_

imageprocess/include/alibabacloud/imageprocess/model/RunMedQAResult.h

@@ -35,10 +35,10 @@ namespace AlibabaCloud
 				struct Data
 				{
 					std::vector<std::string> options;
-					std::string reports;
 					std::string questionType;
-					std::string answerType;
+					std::string reports;
 					std::string question;
+					std::string answerType;
 					std::string sessionId;
 				};
 

imageprocess/include/alibabacloud/imageprocess/model/ScreenChestCTRequest.h

@@ -1,68 +1,60 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
+ */
-
+
-#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_SCREENCHESTCTREQUEST_H_
+#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_SCREENCHESTCTREQUEST_H_
-#define ALIBABACLOUD_IMAGEPROCESS_MODEL_SCREENCHESTCTREQUEST_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_SCREENCHESTCTREQUEST_H_
-
+
-#include <string>
+#include <alibabacloud/imageprocess/ImageprocessExport.h>
-#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
-#include <alibabacloud/imageprocess/ImageprocessExport.h>
+#include <vector>
-
+#include <map>
-namespace AlibabaCloud
+
-{
+namespace AlibabaCloud {
-	namespace Imageprocess
+namespace Imageprocess {
-	{
+namespace Model {
-		namespace Model
+class ALIBABACLOUD_IMAGEPROCESS_EXPORT ScreenChestCTRequest : public RpcServiceRequest {
-		{
+public:
-			class ALIBABACLOUD_IMAGEPROCESS_EXPORT ScreenChestCTRequest : public RpcServiceRequest
+	struct URLList {
-			{
+		std::string uRL;
-			public:
+	};
-				struct URLList
+	ScreenChestCTRequest();
-				{
+	~ScreenChestCTRequest();
-					std::string uRL;
+	std::string getOrgName() const;
-				};
+	void setOrgName(const std::string &orgName);
-
+	long getMask() const;
-			public:
+	void setMask(long mask);
-				ScreenChestCTRequest();
+	std::string getDataFormat() const;
-				~ScreenChestCTRequest();
+	void setDataFormat(const std::string &dataFormat);
-
+	std::vector<URLList> getURLList() const;
-				std::string getOrgName()const;
+	void setURLList(const std::vector<URLList> &uRLList);
-				void setOrgName(const std::string& orgName);
+	std::string getOrgId() const;
-				long getMask()const;
+	void setOrgId(const std::string &orgId);
-				void setMask(long mask);
+	bool getAsync() const;
-				std::string getDataFormat()const;
+	void setAsync(bool async);
-				void setDataFormat(const std::string& dataFormat);
+
-				std::vector<URLList> getURLList()const;
+private:
-				void setURLList(const std::vector<URLList>& uRLList);
+	std::string orgName_;
-				std::string getOrgId()const;
+	long mask_;
-				void setOrgId(const std::string& orgId);
+	std::string dataFormat_;
-				bool getAsync()const;
+	std::vector<URLList> uRLList_;
-				void setAsync(bool async);
+	std::string orgId_;
-
+	bool async_;
-            private:
+};
-				std::string orgName_;
+} // namespace Model
-				long mask_;
+} // namespace Imageprocess
-				std::string dataFormat_;
+} // namespace AlibabaCloud
-				std::vector<URLList> uRLList_;
+#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_SCREENCHESTCTREQUEST_H_
-				std::string orgId_;
-				bool async_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_SCREENCHESTCTREQUEST_H_

imageprocess/include/alibabacloud/imageprocess/model/TranslateMedRequest.h

@@ -1,54 +1,48 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
+ */
-
+
-#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_TRANSLATEMEDREQUEST_H_
+#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_TRANSLATEMEDREQUEST_H_
-#define ALIBABACLOUD_IMAGEPROCESS_MODEL_TRANSLATEMEDREQUEST_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_TRANSLATEMEDREQUEST_H_
-
+
-#include <string>
+#include <alibabacloud/imageprocess/ImageprocessExport.h>
-#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
-#include <alibabacloud/imageprocess/ImageprocessExport.h>
+#include <vector>
-
+#include <map>
-namespace AlibabaCloud
+
-{
+namespace AlibabaCloud {
-	namespace Imageprocess
+namespace Imageprocess {
-	{
+namespace Model {
-		namespace Model
+class ALIBABACLOUD_IMAGEPROCESS_EXPORT TranslateMedRequest : public RpcServiceRequest {
-		{
+public:
-			class ALIBABACLOUD_IMAGEPROCESS_EXPORT TranslateMedRequest : public RpcServiceRequest
+	TranslateMedRequest();
-			{
+	~TranslateMedRequest();
-
+	std::string getToLanguage() const;
-			public:
+	void setToLanguage(const std::string &toLanguage);
-				TranslateMedRequest();
+	std::string getText() const;
-				~TranslateMedRequest();
+	void setText(const std::string &text);
-
+	std::string getFromLanguage() const;
-				std::string getFromLanguage()const;
+	void setFromLanguage(const std::string &fromLanguage);
-				void setFromLanguage(const std::string& fromLanguage);
+
-				std::string getToLanguage()const;
+private:
-				void setToLanguage(const std::string& toLanguage);
+	std::string toLanguage_;
-				std::string getText()const;
+	std::string text_;
-				void setText(const std::string& text);
+	std::string fromLanguage_;
-
+};
-            private:
+} // namespace Model
-				std::string fromLanguage_;
+} // namespace Imageprocess
-				std::string toLanguage_;
+} // namespace AlibabaCloud
-				std::string text_;
+#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_TRANSLATEMEDREQUEST_H_
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_TRANSLATEMEDREQUEST_H_

imageprocess/src/model/AnalyzeChestVesselRequest.cc

@@ -1,99 +1,85 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
+ */
-
+
-#include <alibabacloud/imageprocess/model/AnalyzeChestVesselRequest.h>
+#include <alibabacloud/imageprocess/model/AnalyzeChestVesselRequest.h>
-
+
-using AlibabaCloud::Imageprocess::Model::AnalyzeChestVesselRequest;
+using AlibabaCloud::Imageprocess::Model::AnalyzeChestVesselRequest;
-
+
-AnalyzeChestVesselRequest::AnalyzeChestVesselRequest() :
+AnalyzeChestVesselRequest::AnalyzeChestVesselRequest()
-	RpcServiceRequest("imageprocess", "2020-03-20", "AnalyzeChestVessel")
+    : RpcServiceRequest("imageprocess", "2020-03-20", "AnalyzeChestVessel") {
-{
+  setMethod(HttpRequest::Method::Post);
-	setMethod(HttpRequest::Method::Post);
-}
-
-AnalyzeChestVesselRequest::~AnalyzeChestVesselRequest()
-{}
-
-std::string AnalyzeChestVesselRequest::getDataSourceType()const
-{
-	return dataSourceType_;
 }
 
-void AnalyzeChestVesselRequest::setDataSourceType(const std::string& dataSourceType)
+AnalyzeChestVesselRequest::~AnalyzeChestVesselRequest() {}
-{
+
-	dataSourceType_ = dataSourceType;
+std::string AnalyzeChestVesselRequest::getDataSourceType() const {
-	setBodyParameter("DataSourceType", dataSourceType);
+  return dataSourceType_;
 }
 
-std::string AnalyzeChestVesselRequest::getOrgName()const
+void AnalyzeChestVesselRequest::setDataSourceType(const std::string &dataSourceType) {
-{
+  dataSourceType_ = dataSourceType;
-	return orgName_;
+  setBodyParameter(std::string("DataSourceType"), dataSourceType);
 }
 
-void AnalyzeChestVesselRequest::setOrgName(const std::string& orgName)
+std::string AnalyzeChestVesselRequest::getOrgName() const {
-{
+  return orgName_;
-	orgName_ = orgName;
-	setBodyParameter("OrgName", orgName);
 }
 
-std::string AnalyzeChestVesselRequest::getDataFormat()const
+void AnalyzeChestVesselRequest::setOrgName(const std::string &orgName) {
-{
+  orgName_ = orgName;
-	return dataFormat_;
+  setBodyParameter(std::string("OrgName"), orgName);
 }
 
-void AnalyzeChestVesselRequest::setDataFormat(const std::string& dataFormat)
+std::string AnalyzeChestVesselRequest::getDataFormat() const {
-{
+  return dataFormat_;
-	dataFormat_ = dataFormat;
-	setBodyParameter("DataFormat", dataFormat);
 }
 
-std::vector<AnalyzeChestVesselRequest::URLList> AnalyzeChestVesselRequest::getURLList()const
+void AnalyzeChestVesselRequest::setDataFormat(const std::string &dataFormat) {
-{
+  dataFormat_ = dataFormat;
-	return uRLList_;
+  setBodyParameter(std::string("DataFormat"), dataFormat);
 }
 
-void AnalyzeChestVesselRequest::setURLList(const std::vector<URLList>& uRLList)
+std::vector<AnalyzeChestVesselRequest::URLList> AnalyzeChestVesselRequest::getURLList() const {
-{
+  return uRLList_;
-	uRLList_ = uRLList;
-	for(int dep1 = 0; dep1!= uRLList.size(); dep1++) {
-		auto uRLListObj = uRLList.at(dep1);
-		std::string uRLListObjStr = "URLList." + std::to_string(dep1 + 1);
-		setParameter(uRLListObjStr + ".URL", uRLListObj.uRL);
-	}
 }
 
-std::string AnalyzeChestVesselRequest::getOrgId()const
+void AnalyzeChestVesselRequest::setURLList(const std::vector<AnalyzeChestVesselRequest::URLList> &uRLList) {
-{
+  uRLList_ = uRLList;
-	return orgId_;
+  for(int dep1 = 0; dep1 != uRLList.size(); dep1++) {
+  auto uRLListObj = uRLList.at(dep1);
+  std::string uRLListObjStr = std::string("URLList") + "." + std::to_string(dep1 + 1);
+    setBodyParameter(uRLListObjStr + ".URL", uRLListObj.uRL);
+  }
 }
 
-void AnalyzeChestVesselRequest::setOrgId(const std::string& orgId)
+std::string AnalyzeChestVesselRequest::getOrgId() const {
-{
+  return orgId_;
-	orgId_ = orgId;
-	setBodyParameter("OrgId", orgId);
 }
 
-bool AnalyzeChestVesselRequest::getAsync()const
+void AnalyzeChestVesselRequest::setOrgId(const std::string &orgId) {
-{
+  orgId_ = orgId;
-	return async_;
+  setBodyParameter(std::string("OrgId"), orgId);
 }
 
-void AnalyzeChestVesselRequest::setAsync(bool async)
+bool AnalyzeChestVesselRequest::getAsync() const {
-{
+  return async_;
-	async_ = async;
+}
-	setBodyParameter("Async", async ? "true" : "false");
+
+void AnalyzeChestVesselRequest::setAsync(bool async) {
+  async_ = async;
+  setBodyParameter(std::string("Async"), async ? "true" : "false");
 }
 

imageprocess/src/model/CalcCACSRequest.cc

@@ -1,99 +1,85 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
+ */
-
+
-#include <alibabacloud/imageprocess/model/CalcCACSRequest.h>
+#include <alibabacloud/imageprocess/model/CalcCACSRequest.h>
-
+
-using AlibabaCloud::Imageprocess::Model::CalcCACSRequest;
+using AlibabaCloud::Imageprocess::Model::CalcCACSRequest;
-
+
-CalcCACSRequest::CalcCACSRequest() :
+CalcCACSRequest::CalcCACSRequest()
-	RpcServiceRequest("imageprocess", "2020-03-20", "CalcCACS")
+    : RpcServiceRequest("imageprocess", "2020-03-20", "CalcCACS") {
-{
+  setMethod(HttpRequest::Method::Post);
-	setMethod(HttpRequest::Method::Post);
-}
-
-CalcCACSRequest::~CalcCACSRequest()
-{}
-
-std::string CalcCACSRequest::getDataSourceType()const
-{
-	return dataSourceType_;
 }
 
-void CalcCACSRequest::setDataSourceType(const std::string& dataSourceType)
+CalcCACSRequest::~CalcCACSRequest() {}
-{
+
-	dataSourceType_ = dataSourceType;
+std::string CalcCACSRequest::getDataSourceType() const {
-	setBodyParameter("DataSourceType", dataSourceType);
+  return dataSourceType_;
 }
 
-std::string CalcCACSRequest::getDataFormat()const
+void CalcCACSRequest::setDataSourceType(const std::string &dataSourceType) {
-{
+  dataSourceType_ = dataSourceType;
-	return dataFormat_;
+  setBodyParameter(std::string("DataSourceType"), dataSourceType);
 }
 
-void CalcCACSRequest::setDataFormat(const std::string& dataFormat)
+std::string CalcCACSRequest::getOrgName() const {
-{
+  return orgName_;
-	dataFormat_ = dataFormat;
-	setBodyParameter("DataFormat", dataFormat);
 }
 
-std::vector<CalcCACSRequest::URLList> CalcCACSRequest::getURLList()const
+void CalcCACSRequest::setOrgName(const std::string &orgName) {
-{
+  orgName_ = orgName;
-	return uRLList_;
+  setBodyParameter(std::string("OrgName"), orgName);
 }
 
-void CalcCACSRequest::setURLList(const std::vector<URLList>& uRLList)
+std::string CalcCACSRequest::getDataFormat() const {
-{
+  return dataFormat_;
-	uRLList_ = uRLList;
-	for(int dep1 = 0; dep1!= uRLList.size(); dep1++) {
-		auto uRLListObj = uRLList.at(dep1);
-		std::string uRLListObjStr = "URLList." + std::to_string(dep1 + 1);
-		setParameter(uRLListObjStr + ".URL", uRLListObj.uRL);
-	}
 }
 
-std::string CalcCACSRequest::getOrgId()const
+void CalcCACSRequest::setDataFormat(const std::string &dataFormat) {
-{
+  dataFormat_ = dataFormat;
-	return orgId_;
+  setBodyParameter(std::string("DataFormat"), dataFormat);
 }
 
-void CalcCACSRequest::setOrgId(const std::string& orgId)
+std::vector<CalcCACSRequest::URLList> CalcCACSRequest::getURLList() const {
-{
+  return uRLList_;
-	orgId_ = orgId;
-	setBodyParameter("OrgId", orgId);
 }
 
-bool CalcCACSRequest::getAsync()const
+void CalcCACSRequest::setURLList(const std::vector<CalcCACSRequest::URLList> &uRLList) {
-{
+  uRLList_ = uRLList;
-	return async_;
+  for(int dep1 = 0; dep1 != uRLList.size(); dep1++) {
+  auto uRLListObj = uRLList.at(dep1);
+  std::string uRLListObjStr = std::string("URLList") + "." + std::to_string(dep1 + 1);
+    setBodyParameter(uRLListObjStr + ".URL", uRLListObj.uRL);
+  }
 }
 
-void CalcCACSRequest::setAsync(bool async)
+std::string CalcCACSRequest::getOrgId() const {
-{
+  return orgId_;
-	async_ = async;
-	setBodyParameter("Async", async ? "true" : "false");
 }
 
-std::string CalcCACSRequest::getOrgName()const
+void CalcCACSRequest::setOrgId(const std::string &orgId) {
-{
+  orgId_ = orgId;
-	return orgName_;
+  setBodyParameter(std::string("OrgId"), orgId);
 }
 
-void CalcCACSRequest::setOrgName(const std::string& orgName)
+bool CalcCACSRequest::getAsync() const {
-{
+  return async_;
-	orgName_ = orgName;
+}
-	setBodyParameter("OrgName", orgName);
+
+void CalcCACSRequest::setAsync(bool async) {
+  async_ = async;
+  setBodyParameter(std::string("Async"), async ? "true" : "false");
 }
 

imageprocess/src/model/CalcCACSResult.cc

@@ -40,10 +40,10 @@ void CalcCACSResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto dataNode = value["Data"];
-	if(!dataNode["Score"].isNull())
-		data_.score = dataNode["Score"].asString();
 	if(!dataNode["ResultUrl"].isNull())
 		data_.resultUrl = dataNode["ResultUrl"].asString();
+	if(!dataNode["Score"].isNull())
+		data_.score = dataNode["Score"].asString();
 
 }
 

imageprocess/src/model/ClassifyFNFRequest.cc

@@ -1,84 +1,72 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
+ */
-
+
-#include <alibabacloud/imageprocess/model/ClassifyFNFRequest.h>
+#include <alibabacloud/imageprocess/model/ClassifyFNFRequest.h>
-
+
-using AlibabaCloud::Imageprocess::Model::ClassifyFNFRequest;
+using AlibabaCloud::Imageprocess::Model::ClassifyFNFRequest;
-
+
-ClassifyFNFRequest::ClassifyFNFRequest() :
+ClassifyFNFRequest::ClassifyFNFRequest()
-	RpcServiceRequest("imageprocess", "2020-03-20", "ClassifyFNF")
+    : RpcServiceRequest("imageprocess", "2020-03-20", "ClassifyFNF") {
-{
+  setMethod(HttpRequest::Method::Post);
-	setMethod(HttpRequest::Method::Post);
-}
-
-ClassifyFNFRequest::~ClassifyFNFRequest()
-{}
-
-std::string ClassifyFNFRequest::getDataFormat()const
-{
-	return dataFormat_;
 }
 
-void ClassifyFNFRequest::setDataFormat(const std::string& dataFormat)
+ClassifyFNFRequest::~ClassifyFNFRequest() {}
-{
+
-	dataFormat_ = dataFormat;
+std::string ClassifyFNFRequest::getOrgName() const {
-	setBodyParameter("DataFormat", dataFormat);
+  return orgName_;
 }
 
-std::string ClassifyFNFRequest::getOrgId()const
+void ClassifyFNFRequest::setOrgName(const std::string &orgName) {
-{
+  orgName_ = orgName;
-	return orgId_;
+  setBodyParameter(std::string("OrgName"), orgName);
 }
 
-void ClassifyFNFRequest::setOrgId(const std::string& orgId)
+std::string ClassifyFNFRequest::getTracerId() const {
-{
+  return tracerId_;
-	orgId_ = orgId;
-	setBodyParameter("OrgId", orgId);
 }
 
-std::string ClassifyFNFRequest::getOrgName()const
+void ClassifyFNFRequest::setTracerId(const std::string &tracerId) {
-{
+  tracerId_ = tracerId;
-	return orgName_;
+  setBodyParameter(std::string("TracerId"), tracerId);
 }
 
-void ClassifyFNFRequest::setOrgName(const std::string& orgName)
+std::string ClassifyFNFRequest::getDataFormat() const {
-{
+  return dataFormat_;
-	orgName_ = orgName;
-	setBodyParameter("OrgName", orgName);
 }
 
-std::string ClassifyFNFRequest::getImageUrl()const
+void ClassifyFNFRequest::setDataFormat(const std::string &dataFormat) {
-{
+  dataFormat_ = dataFormat;
-	return imageUrl_;
+  setBodyParameter(std::string("DataFormat"), dataFormat);
 }
 
-void ClassifyFNFRequest::setImageUrl(const std::string& imageUrl)
+std::string ClassifyFNFRequest::getOrgId() const {
-{
+  return orgId_;
-	imageUrl_ = imageUrl;
-	setBodyParameter("ImageUrl", imageUrl);
 }
 
-std::string ClassifyFNFRequest::getTracerId()const
+void ClassifyFNFRequest::setOrgId(const std::string &orgId) {
-{
+  orgId_ = orgId;
-	return tracerId_;
+  setBodyParameter(std::string("OrgId"), orgId);
 }
 
-void ClassifyFNFRequest::setTracerId(const std::string& tracerId)
+std::string ClassifyFNFRequest::getImageUrl() const {
-{
+  return imageUrl_;
-	tracerId_ = tracerId;
+}
-	setBodyParameter("TracerId", tracerId);
+
+void ClassifyFNFRequest::setImageUrl(const std::string &imageUrl) {
+  imageUrl_ = imageUrl;
+  setBodyParameter(std::string("ImageUrl"), imageUrl);
 }
 

imageprocess/src/model/DetectCovid19CadRequest.cc

@@ -1,88 +1,76 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
+ */
-
+
-#include <alibabacloud/imageprocess/model/DetectCovid19CadRequest.h>
+#include <alibabacloud/imageprocess/model/DetectCovid19CadRequest.h>
-
+
-using AlibabaCloud::Imageprocess::Model::DetectCovid19CadRequest;
+using AlibabaCloud::Imageprocess::Model::DetectCovid19CadRequest;
-
+
-DetectCovid19CadRequest::DetectCovid19CadRequest() :
+DetectCovid19CadRequest::DetectCovid19CadRequest()
-	RpcServiceRequest("imageprocess", "2020-03-20", "DetectCovid19Cad")
+    : RpcServiceRequest("imageprocess", "2020-03-20", "DetectCovid19Cad") {
-{
+  setMethod(HttpRequest::Method::Post);
-	setMethod(HttpRequest::Method::Post);
-}
-
-DetectCovid19CadRequest::~DetectCovid19CadRequest()
-{}
-
-std::string DetectCovid19CadRequest::getDataFormat()const
-{
-	return dataFormat_;
 }
 
-void DetectCovid19CadRequest::setDataFormat(const std::string& dataFormat)
+DetectCovid19CadRequest::~DetectCovid19CadRequest() {}
-{
+
-	dataFormat_ = dataFormat;
+std::string DetectCovid19CadRequest::getOrgName() const {
-	setBodyParameter("DataFormat", dataFormat);
+  return orgName_;
 }
 
-std::vector<DetectCovid19CadRequest::URLList> DetectCovid19CadRequest::getURLList()const
+void DetectCovid19CadRequest::setOrgName(const std::string &orgName) {
-{
+  orgName_ = orgName;
-	return uRLList_;
+  setBodyParameter(std::string("OrgName"), orgName);
 }
 
-void DetectCovid19CadRequest::setURLList(const std::vector<URLList>& uRLList)
+std::string DetectCovid19CadRequest::getDataFormat() const {
-{
+  return dataFormat_;
-	uRLList_ = uRLList;
-	for(int dep1 = 0; dep1!= uRLList.size(); dep1++) {
-		auto uRLListObj = uRLList.at(dep1);
-		std::string uRLListObjStr = "URLList." + std::to_string(dep1 + 1);
-		setParameter(uRLListObjStr + ".URL", uRLListObj.uRL);
-	}
 }
 
-std::string DetectCovid19CadRequest::getOrgId()const
+void DetectCovid19CadRequest::setDataFormat(const std::string &dataFormat) {
-{
+  dataFormat_ = dataFormat;
-	return orgId_;
+  setBodyParameter(std::string("DataFormat"), dataFormat);
 }
 
-void DetectCovid19CadRequest::setOrgId(const std::string& orgId)
+std::vector<DetectCovid19CadRequest::URLList> DetectCovid19CadRequest::getURLList() const {
-{
+  return uRLList_;
-	orgId_ = orgId;
-	setBodyParameter("OrgId", orgId);
 }
 
-bool DetectCovid19CadRequest::getAsync()const
+void DetectCovid19CadRequest::setURLList(const std::vector<DetectCovid19CadRequest::URLList> &uRLList) {
-{
+  uRLList_ = uRLList;
-	return async_;
+  for(int dep1 = 0; dep1 != uRLList.size(); dep1++) {
+  auto uRLListObj = uRLList.at(dep1);
+  std::string uRLListObjStr = std::string("URLList") + "." + std::to_string(dep1 + 1);
+    setBodyParameter(uRLListObjStr + ".URL", uRLListObj.uRL);
+  }
 }
 
-void DetectCovid19CadRequest::setAsync(bool async)
+std::string DetectCovid19CadRequest::getOrgId() const {
-{
+  return orgId_;
-	async_ = async;
-	setBodyParameter("Async", async ? "true" : "false");
 }
 
-std::string DetectCovid19CadRequest::getOrgName()const
+void DetectCovid19CadRequest::setOrgId(const std::string &orgId) {
-{
+  orgId_ = orgId;
-	return orgName_;
+  setBodyParameter(std::string("OrgId"), orgId);
 }
 
-void DetectCovid19CadRequest::setOrgName(const std::string& orgName)
+bool DetectCovid19CadRequest::getAsync() const {
-{
+  return async_;
-	orgName_ = orgName;
+}
-	setBodyParameter("OrgName", orgName);
+
+void DetectCovid19CadRequest::setAsync(bool async) {
+  async_ = async;
+  setBodyParameter(std::string("Async"), async ? "true" : "false");
 }
 

imageprocess/src/model/DetectCovid19CadResult.cc

@@ -40,14 +40,14 @@ void DetectCovid19CadResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto dataNode = value["Data"];
-	if(!dataNode["NewProbability"].isNull())
-		data_.newProbability = dataNode["NewProbability"].asString();
 	if(!dataNode["NormalProbability"].isNull())
 		data_.normalProbability = dataNode["NormalProbability"].asString();
-	if(!dataNode["OtherProbability"].isNull())
+	if(!dataNode["NewProbability"].isNull())
-		data_.otherProbability = dataNode["OtherProbability"].asString();
+		data_.newProbability = dataNode["NewProbability"].asString();
 	if(!dataNode["LesionRatio"].isNull())
 		data_.lesionRatio = dataNode["LesionRatio"].asString();
+	if(!dataNode["OtherProbability"].isNull())
+		data_.otherProbability = dataNode["OtherProbability"].asString();
 	if(!dataNode["Mask"].isNull())
 		data_.mask = dataNode["Mask"].asString();
 

imageprocess/src/model/DetectHipKeypointXRayRequest.cc

@@ -1,84 +1,72 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
+ */
-
+
-#include <alibabacloud/imageprocess/model/DetectHipKeypointXRayRequest.h>
+#include <alibabacloud/imageprocess/model/DetectHipKeypointXRayRequest.h>
-
+
-using AlibabaCloud::Imageprocess::Model::DetectHipKeypointXRayRequest;
+using AlibabaCloud::Imageprocess::Model::DetectHipKeypointXRayRequest;
-
+
-DetectHipKeypointXRayRequest::DetectHipKeypointXRayRequest() :
+DetectHipKeypointXRayRequest::DetectHipKeypointXRayRequest()
-	RpcServiceRequest("imageprocess", "2020-03-20", "DetectHipKeypointXRay")
+    : RpcServiceRequest("imageprocess", "2020-03-20", "DetectHipKeypointXRay") {
-{
+  setMethod(HttpRequest::Method::Post);
-	setMethod(HttpRequest::Method::Post);
-}
-
-DetectHipKeypointXRayRequest::~DetectHipKeypointXRayRequest()
-{}
-
-std::string DetectHipKeypointXRayRequest::getOrgName()const
-{
-	return orgName_;
 }
 
-void DetectHipKeypointXRayRequest::setOrgName(const std::string& orgName)
+DetectHipKeypointXRayRequest::~DetectHipKeypointXRayRequest() {}
-{
+
-	orgName_ = orgName;
+std::string DetectHipKeypointXRayRequest::getOrgName() const {
-	setBodyParameter("OrgName", orgName);
+  return orgName_;
 }
 
-std::string DetectHipKeypointXRayRequest::getTracerId()const
+void DetectHipKeypointXRayRequest::setOrgName(const std::string &orgName) {
-{
+  orgName_ = orgName;
-	return tracerId_;
+  setBodyParameter(std::string("OrgName"), orgName);
 }
 
-void DetectHipKeypointXRayRequest::setTracerId(const std::string& tracerId)
+std::string DetectHipKeypointXRayRequest::getTracerId() const {
-{
+  return tracerId_;
-	tracerId_ = tracerId;
-	setBodyParameter("TracerId", tracerId);
 }
 
-std::string DetectHipKeypointXRayRequest::getDataFormat()const
+void DetectHipKeypointXRayRequest::setTracerId(const std::string &tracerId) {
-{
+  tracerId_ = tracerId;
-	return dataFormat_;
+  setBodyParameter(std::string("TracerId"), tracerId);
 }
 
-void DetectHipKeypointXRayRequest::setDataFormat(const std::string& dataFormat)
+std::string DetectHipKeypointXRayRequest::getDataFormat() const {
-{
+  return dataFormat_;
-	dataFormat_ = dataFormat;
-	setBodyParameter("DataFormat", dataFormat);
 }
 
-std::string DetectHipKeypointXRayRequest::getOrgId()const
+void DetectHipKeypointXRayRequest::setDataFormat(const std::string &dataFormat) {
-{
+  dataFormat_ = dataFormat;
-	return orgId_;
+  setBodyParameter(std::string("DataFormat"), dataFormat);
 }
 
-void DetectHipKeypointXRayRequest::setOrgId(const std::string& orgId)
+std::string DetectHipKeypointXRayRequest::getOrgId() const {
-{
+  return orgId_;
-	orgId_ = orgId;
-	setBodyParameter("OrgId", orgId);
 }
 
-std::string DetectHipKeypointXRayRequest::getImageUrl()const
+void DetectHipKeypointXRayRequest::setOrgId(const std::string &orgId) {
-{
+  orgId_ = orgId;
-	return imageUrl_;
+  setBodyParameter(std::string("OrgId"), orgId);
 }
 
-void DetectHipKeypointXRayRequest::setImageUrl(const std::string& imageUrl)
+std::string DetectHipKeypointXRayRequest::getImageUrl() const {
-{
+  return imageUrl_;
-	imageUrl_ = imageUrl;
+}
-	setBodyParameter("ImageUrl", imageUrl);
+
+void DetectHipKeypointXRayRequest::setImageUrl(const std::string &imageUrl) {
+  imageUrl_ = imageUrl;
+  setBodyParameter(std::string("ImageUrl"), imageUrl);
 }
 

imageprocess/src/model/DetectHipKeypointXRayResult.cc

@@ -40,10 +40,10 @@ void DetectHipKeypointXRayResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto dataNode = value["Data"];
-	if(!dataNode["OrgId"].isNull())
-		data_.orgId = dataNode["OrgId"].asString();
 	if(!dataNode["ImageUrl"].isNull())
 		data_.imageUrl = dataNode["ImageUrl"].asString();
+	if(!dataNode["OrgId"].isNull())
+		data_.orgId = dataNode["OrgId"].asString();
 	if(!dataNode["OrgName"].isNull())
 		data_.orgName = dataNode["OrgName"].asString();
 	auto allKeyPointsNode = dataNode["KeyPoints"]["KeyPointsItem"];
@@ -53,10 +53,10 @@ void DetectHipKeypointXRayResult::parse(const std::string &payload)
 		if(!dataNodeKeyPointsKeyPointsItem["Value"].isNull())
 			keyPointsItemObject.value = std::stof(dataNodeKeyPointsKeyPointsItem["Value"].asString());
 		auto tagNode = value["Tag"];
-		if(!tagNode["Label"].isNull())
-			keyPointsItemObject.tag.label = tagNode["Label"].asString();
 		if(!tagNode["Direction"].isNull())
 			keyPointsItemObject.tag.direction = tagNode["Direction"].asString();
+		if(!tagNode["Label"].isNull())
+			keyPointsItemObject.tag.label = tagNode["Label"].asString();
 		auto allCoordinates = value["Coordinates"]["Coordinate"];
 		for (auto value : allCoordinates)
 			keyPointsItemObject.coordinates.push_back(value.asString());

imageprocess/src/model/DetectKneeKeypointXRayRequest.cc

@@ -1,84 +1,72 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
+ */
-
+
-#include <alibabacloud/imageprocess/model/DetectKneeKeypointXRayRequest.h>
+#include <alibabacloud/imageprocess/model/DetectKneeKeypointXRayRequest.h>
-
+
-using AlibabaCloud::Imageprocess::Model::DetectKneeKeypointXRayRequest;
+using AlibabaCloud::Imageprocess::Model::DetectKneeKeypointXRayRequest;
-
+
-DetectKneeKeypointXRayRequest::DetectKneeKeypointXRayRequest() :
+DetectKneeKeypointXRayRequest::DetectKneeKeypointXRayRequest()
-	RpcServiceRequest("imageprocess", "2020-03-20", "DetectKneeKeypointXRay")
+    : RpcServiceRequest("imageprocess", "2020-03-20", "DetectKneeKeypointXRay") {
-{
+  setMethod(HttpRequest::Method::Post);
-	setMethod(HttpRequest::Method::Post);
-}
-
-DetectKneeKeypointXRayRequest::~DetectKneeKeypointXRayRequest()
-{}
-
-std::string DetectKneeKeypointXRayRequest::getDataFormat()const
-{
-	return dataFormat_;
 }
 
-void DetectKneeKeypointXRayRequest::setDataFormat(const std::string& dataFormat)
+DetectKneeKeypointXRayRequest::~DetectKneeKeypointXRayRequest() {}
-{
+
-	dataFormat_ = dataFormat;
+std::string DetectKneeKeypointXRayRequest::getOrgName() const {
-	setBodyParameter("DataFormat", dataFormat);
+  return orgName_;
 }
 
-std::string DetectKneeKeypointXRayRequest::getOrgId()const
+void DetectKneeKeypointXRayRequest::setOrgName(const std::string &orgName) {
-{
+  orgName_ = orgName;
-	return orgId_;
+  setBodyParameter(std::string("OrgName"), orgName);
 }
 
-void DetectKneeKeypointXRayRequest::setOrgId(const std::string& orgId)
+std::string DetectKneeKeypointXRayRequest::getTracerId() const {
-{
+  return tracerId_;
-	orgId_ = orgId;
-	setBodyParameter("OrgId", orgId);
 }
 
-std::string DetectKneeKeypointXRayRequest::getOrgName()const
+void DetectKneeKeypointXRayRequest::setTracerId(const std::string &tracerId) {
-{
+  tracerId_ = tracerId;
-	return orgName_;
+  setBodyParameter(std::string("TracerId"), tracerId);
 }
 
-void DetectKneeKeypointXRayRequest::setOrgName(const std::string& orgName)
+std::string DetectKneeKeypointXRayRequest::getDataFormat() const {
-{
+  return dataFormat_;
-	orgName_ = orgName;
-	setBodyParameter("OrgName", orgName);
 }
 
-std::string DetectKneeKeypointXRayRequest::getImageUrl()const
+void DetectKneeKeypointXRayRequest::setDataFormat(const std::string &dataFormat) {
-{
+  dataFormat_ = dataFormat;
-	return imageUrl_;
+  setBodyParameter(std::string("DataFormat"), dataFormat);
 }
 
-void DetectKneeKeypointXRayRequest::setImageUrl(const std::string& imageUrl)
+std::string DetectKneeKeypointXRayRequest::getOrgId() const {
-{
+  return orgId_;
-	imageUrl_ = imageUrl;
-	setBodyParameter("ImageUrl", imageUrl);
 }
 
-std::string DetectKneeKeypointXRayRequest::getTracerId()const
+void DetectKneeKeypointXRayRequest::setOrgId(const std::string &orgId) {
-{
+  orgId_ = orgId;
-	return tracerId_;
+  setBodyParameter(std::string("OrgId"), orgId);
 }
 
-void DetectKneeKeypointXRayRequest::setTracerId(const std::string& tracerId)
+std::string DetectKneeKeypointXRayRequest::getImageUrl() const {
-{
+  return imageUrl_;
-	tracerId_ = tracerId;
+}
-	setBodyParameter("TracerId", tracerId);
+
+void DetectKneeKeypointXRayRequest::setImageUrl(const std::string &imageUrl) {
+  imageUrl_ = imageUrl;
+  setBodyParameter(std::string("ImageUrl"), imageUrl);
 }
 

imageprocess/src/model/DetectKneeXRayRequest.cc

@@ -1,73 +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/imageprocess/model/DetectKneeXRayRequest.h>
+#include <alibabacloud/imageprocess/model/DetectKneeXRayRequest.h>
-
+
-using AlibabaCloud::Imageprocess::Model::DetectKneeXRayRequest;
+using AlibabaCloud::Imageprocess::Model::DetectKneeXRayRequest;
-
+
-DetectKneeXRayRequest::DetectKneeXRayRequest() :
+DetectKneeXRayRequest::DetectKneeXRayRequest()
-	RpcServiceRequest("imageprocess", "2020-03-20", "DetectKneeXRay")
+    : RpcServiceRequest("imageprocess", "2020-03-20", "DetectKneeXRay") {
-{
+  setMethod(HttpRequest::Method::Post);
-	setMethod(HttpRequest::Method::Post);
-}
-
-DetectKneeXRayRequest::~DetectKneeXRayRequest()
-{}
-
-std::string DetectKneeXRayRequest::getDataFormat()const
-{
-	return dataFormat_;
 }
 
-void DetectKneeXRayRequest::setDataFormat(const std::string& dataFormat)
+DetectKneeXRayRequest::~DetectKneeXRayRequest() {}
-{
+
-	dataFormat_ = dataFormat;
+std::string DetectKneeXRayRequest::getOrgName() const {
-	setBodyParameter("DataFormat", dataFormat);
+  return orgName_;
 }
 
-std::string DetectKneeXRayRequest::getUrl()const
+void DetectKneeXRayRequest::setOrgName(const std::string &orgName) {
-{
+  orgName_ = orgName;
-	return url_;
+  setBodyParameter(std::string("OrgName"), orgName);
 }
 
-void DetectKneeXRayRequest::setUrl(const std::string& url)
+std::string DetectKneeXRayRequest::getDataFormat() const {
-{
+  return dataFormat_;
-	url_ = url;
-	setBodyParameter("Url", url);
 }
 
-std::string DetectKneeXRayRequest::getOrgId()const
+void DetectKneeXRayRequest::setDataFormat(const std::string &dataFormat) {
-{
+  dataFormat_ = dataFormat;
-	return orgId_;
+  setBodyParameter(std::string("DataFormat"), dataFormat);
 }
 
-void DetectKneeXRayRequest::setOrgId(const std::string& orgId)
+std::string DetectKneeXRayRequest::getUrl() const {
-{
+  return url_;
-	orgId_ = orgId;
-	setBodyParameter("OrgId", orgId);
 }
 
-std::string DetectKneeXRayRequest::getOrgName()const
+void DetectKneeXRayRequest::setUrl(const std::string &url) {
-{
+  url_ = url;
-	return orgName_;
+  setBodyParameter(std::string("Url"), url);
 }
 
-void DetectKneeXRayRequest::setOrgName(const std::string& orgName)
+std::string DetectKneeXRayRequest::getOrgId() const {
-{
+  return orgId_;
-	orgName_ = orgName;
+}
-	setBodyParameter("OrgName", orgName);
+
+void DetectKneeXRayRequest::setOrgId(const std::string &orgId) {
+  orgId_ = orgId;
+  setBodyParameter(std::string("OrgId"), orgId);
 }
 

imageprocess/src/model/DetectLungNoduleRequest.cc

@@ -1,99 +1,85 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
+ */
-
+
-#include <alibabacloud/imageprocess/model/DetectLungNoduleRequest.h>
+#include <alibabacloud/imageprocess/model/DetectLungNoduleRequest.h>
-
+
-using AlibabaCloud::Imageprocess::Model::DetectLungNoduleRequest;
+using AlibabaCloud::Imageprocess::Model::DetectLungNoduleRequest;
-
+
-DetectLungNoduleRequest::DetectLungNoduleRequest() :
+DetectLungNoduleRequest::DetectLungNoduleRequest()
-	RpcServiceRequest("imageprocess", "2020-03-20", "DetectLungNodule")
+    : RpcServiceRequest("imageprocess", "2020-03-20", "DetectLungNodule") {
-{
+  setMethod(HttpRequest::Method::Post);
-	setMethod(HttpRequest::Method::Post);
-}
-
-DetectLungNoduleRequest::~DetectLungNoduleRequest()
-{}
-
-float DetectLungNoduleRequest::getThreshold()const
-{
-	return threshold_;
 }
 
-void DetectLungNoduleRequest::setThreshold(float threshold)
+DetectLungNoduleRequest::~DetectLungNoduleRequest() {}
-{
+
-	threshold_ = threshold;
+float DetectLungNoduleRequest::getThreshold() const {
-	setBodyParameter("Threshold", std::to_string(threshold));
+  return threshold_;
 }
 
-std::string DetectLungNoduleRequest::getOrgName()const
+void DetectLungNoduleRequest::setThreshold(float threshold) {
-{
+  threshold_ = threshold;
-	return orgName_;
+  setBodyParameter(std::string("Threshold"), std::to_string(threshold));
 }
 
-void DetectLungNoduleRequest::setOrgName(const std::string& orgName)
+std::string DetectLungNoduleRequest::getOrgName() const {
-{
+  return orgName_;
-	orgName_ = orgName;
-	setBodyParameter("OrgName", orgName);
 }
 
-std::string DetectLungNoduleRequest::getDataFormat()const
+void DetectLungNoduleRequest::setOrgName(const std::string &orgName) {
-{
+  orgName_ = orgName;
-	return dataFormat_;
+  setBodyParameter(std::string("OrgName"), orgName);
 }
 
-void DetectLungNoduleRequest::setDataFormat(const std::string& dataFormat)
+std::string DetectLungNoduleRequest::getDataFormat() const {
-{
+  return dataFormat_;
-	dataFormat_ = dataFormat;
-	setBodyParameter("DataFormat", dataFormat);
 }
 
-std::vector<DetectLungNoduleRequest::URLList> DetectLungNoduleRequest::getURLList()const
+void DetectLungNoduleRequest::setDataFormat(const std::string &dataFormat) {
-{
+  dataFormat_ = dataFormat;
-	return uRLList_;
+  setBodyParameter(std::string("DataFormat"), dataFormat);
 }
 
-void DetectLungNoduleRequest::setURLList(const std::vector<URLList>& uRLList)
+std::vector<DetectLungNoduleRequest::URLList> DetectLungNoduleRequest::getURLList() const {
-{
+  return uRLList_;
-	uRLList_ = uRLList;
-	for(int dep1 = 0; dep1!= uRLList.size(); dep1++) {
-		auto uRLListObj = uRLList.at(dep1);
-		std::string uRLListObjStr = "URLList." + std::to_string(dep1 + 1);
-		setParameter(uRLListObjStr + ".URL", uRLListObj.uRL);
-	}
 }
 
-std::string DetectLungNoduleRequest::getOrgId()const
+void DetectLungNoduleRequest::setURLList(const std::vector<DetectLungNoduleRequest::URLList> &uRLList) {
-{
+  uRLList_ = uRLList;
-	return orgId_;
+  for(int dep1 = 0; dep1 != uRLList.size(); dep1++) {
+  auto uRLListObj = uRLList.at(dep1);
+  std::string uRLListObjStr = std::string("URLList") + "." + std::to_string(dep1 + 1);
+    setBodyParameter(uRLListObjStr + ".URL", uRLListObj.uRL);
+  }
 }
 
-void DetectLungNoduleRequest::setOrgId(const std::string& orgId)
+std::string DetectLungNoduleRequest::getOrgId() const {
-{
+  return orgId_;
-	orgId_ = orgId;
-	setBodyParameter("OrgId", orgId);
 }
 
-bool DetectLungNoduleRequest::getAsync()const
+void DetectLungNoduleRequest::setOrgId(const std::string &orgId) {
-{
+  orgId_ = orgId;
-	return async_;
+  setBodyParameter(std::string("OrgId"), orgId);
 }
 
-void DetectLungNoduleRequest::setAsync(bool async)
+bool DetectLungNoduleRequest::getAsync() const {
-{
+  return async_;
-	async_ = async;
+}
-	setBodyParameter("Async", async ? "true" : "false");
+
+void DetectLungNoduleRequest::setAsync(bool async) {
+  async_ = async;
+  setBodyParameter(std::string("Async"), async ? "true" : "false");
 }
 

imageprocess/src/model/DetectRibFractureRequest.cc

@@ -1,99 +1,85 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
+ */
-
+
-#include <alibabacloud/imageprocess/model/DetectRibFractureRequest.h>
+#include <alibabacloud/imageprocess/model/DetectRibFractureRequest.h>
-
+
-using AlibabaCloud::Imageprocess::Model::DetectRibFractureRequest;
+using AlibabaCloud::Imageprocess::Model::DetectRibFractureRequest;
-
+
-DetectRibFractureRequest::DetectRibFractureRequest() :
+DetectRibFractureRequest::DetectRibFractureRequest()
-	RpcServiceRequest("imageprocess", "2020-03-20", "DetectRibFracture")
+    : RpcServiceRequest("imageprocess", "2020-03-20", "DetectRibFracture") {
-{
+  setMethod(HttpRequest::Method::Post);
-	setMethod(HttpRequest::Method::Post);
-}
-
-DetectRibFractureRequest::~DetectRibFractureRequest()
-{}
-
-std::string DetectRibFractureRequest::getOrgName()const
-{
-	return orgName_;
 }
 
-void DetectRibFractureRequest::setOrgName(const std::string& orgName)
+DetectRibFractureRequest::~DetectRibFractureRequest() {}
-{
+
-	orgName_ = orgName;
+std::string DetectRibFractureRequest::getOrgName() const {
-	setBodyParameter("OrgName", orgName);
+  return orgName_;
 }
 
-std::string DetectRibFractureRequest::getSourceType()const
+void DetectRibFractureRequest::setOrgName(const std::string &orgName) {
-{
+  orgName_ = orgName;
-	return sourceType_;
+  setBodyParameter(std::string("OrgName"), orgName);
 }
 
-void DetectRibFractureRequest::setSourceType(const std::string& sourceType)
+std::string DetectRibFractureRequest::getSourceType() const {
-{
+  return sourceType_;
-	sourceType_ = sourceType;
-	setBodyParameter("SourceType", sourceType);
 }
 
-std::string DetectRibFractureRequest::getDataFormat()const
+void DetectRibFractureRequest::setSourceType(const std::string &sourceType) {
-{
+  sourceType_ = sourceType;
-	return dataFormat_;
+  setBodyParameter(std::string("SourceType"), sourceType);
 }
 
-void DetectRibFractureRequest::setDataFormat(const std::string& dataFormat)
+std::string DetectRibFractureRequest::getDataFormat() const {
-{
+  return dataFormat_;
-	dataFormat_ = dataFormat;
-	setBodyParameter("DataFormat", dataFormat);
 }
 
-std::vector<DetectRibFractureRequest::URLList> DetectRibFractureRequest::getURLList()const
+void DetectRibFractureRequest::setDataFormat(const std::string &dataFormat) {
-{
+  dataFormat_ = dataFormat;
-	return uRLList_;
+  setBodyParameter(std::string("DataFormat"), dataFormat);
 }
 
-void DetectRibFractureRequest::setURLList(const std::vector<URLList>& uRLList)
+std::vector<DetectRibFractureRequest::URLList> DetectRibFractureRequest::getURLList() const {
-{
+  return uRLList_;
-	uRLList_ = uRLList;
-	for(int dep1 = 0; dep1!= uRLList.size(); dep1++) {
-		auto uRLListObj = uRLList.at(dep1);
-		std::string uRLListObjStr = "URLList." + std::to_string(dep1 + 1);
-		setParameter(uRLListObjStr + ".URL", uRLListObj.uRL);
-	}
 }
 
-std::string DetectRibFractureRequest::getOrgId()const
+void DetectRibFractureRequest::setURLList(const std::vector<DetectRibFractureRequest::URLList> &uRLList) {
-{
+  uRLList_ = uRLList;
-	return orgId_;
+  for(int dep1 = 0; dep1 != uRLList.size(); dep1++) {
+  auto uRLListObj = uRLList.at(dep1);
+  std::string uRLListObjStr = std::string("URLList") + "." + std::to_string(dep1 + 1);
+    setBodyParameter(uRLListObjStr + ".URL", uRLListObj.uRL);
+  }
 }
 
-void DetectRibFractureRequest::setOrgId(const std::string& orgId)
+std::string DetectRibFractureRequest::getOrgId() const {
-{
+  return orgId_;
-	orgId_ = orgId;
-	setBodyParameter("OrgId", orgId);
 }
 
-bool DetectRibFractureRequest::getAsync()const
+void DetectRibFractureRequest::setOrgId(const std::string &orgId) {
-{
+  orgId_ = orgId;
-	return async_;
+  setBodyParameter(std::string("OrgId"), orgId);
 }
 
-void DetectRibFractureRequest::setAsync(bool async)
+bool DetectRibFractureRequest::getAsync() const {
-{
+  return async_;
-	async_ = async;
+}
-	setBodyParameter("Async", async ? "true" : "false");
+
+void DetectRibFractureRequest::setAsync(bool async) {
+  async_ = async;
+  setBodyParameter(std::string("Async"), async ? "true" : "false");
 }
 

imageprocess/src/model/DetectSkinDiseaseRequest.cc

@@ -1,62 +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/imageprocess/model/DetectSkinDiseaseRequest.h>
+#include <alibabacloud/imageprocess/model/DetectSkinDiseaseRequest.h>
-
+
-using AlibabaCloud::Imageprocess::Model::DetectSkinDiseaseRequest;
+using AlibabaCloud::Imageprocess::Model::DetectSkinDiseaseRequest;
-
+
-DetectSkinDiseaseRequest::DetectSkinDiseaseRequest() :
+DetectSkinDiseaseRequest::DetectSkinDiseaseRequest()
-	RpcServiceRequest("imageprocess", "2020-03-20", "DetectSkinDisease")
+    : RpcServiceRequest("imageprocess", "2020-03-20", "DetectSkinDisease") {
-{
+  setMethod(HttpRequest::Method::Post);
-	setMethod(HttpRequest::Method::Post);
-}
-
-DetectSkinDiseaseRequest::~DetectSkinDiseaseRequest()
-{}
-
-std::string DetectSkinDiseaseRequest::getUrl()const
-{
-	return url_;
 }
 
-void DetectSkinDiseaseRequest::setUrl(const std::string& url)
+DetectSkinDiseaseRequest::~DetectSkinDiseaseRequest() {}
-{
+
-	url_ = url;
+std::string DetectSkinDiseaseRequest::getOrgName() const {
-	setBodyParameter("Url", url);
+  return orgName_;
 }
 
-std::string DetectSkinDiseaseRequest::getOrgId()const
+void DetectSkinDiseaseRequest::setOrgName(const std::string &orgName) {
-{
+  orgName_ = orgName;
-	return orgId_;
+  setBodyParameter(std::string("OrgName"), orgName);
 }
 
-void DetectSkinDiseaseRequest::setOrgId(const std::string& orgId)
+std::string DetectSkinDiseaseRequest::getUrl() const {
-{
+  return url_;
-	orgId_ = orgId;
-	setBodyParameter("OrgId", orgId);
 }
 
-std::string DetectSkinDiseaseRequest::getOrgName()const
+void DetectSkinDiseaseRequest::setUrl(const std::string &url) {
-{
+  url_ = url;
-	return orgName_;
+  setBodyParameter(std::string("Url"), url);
 }
 
-void DetectSkinDiseaseRequest::setOrgName(const std::string& orgName)
+std::string DetectSkinDiseaseRequest::getOrgId() const {
-{
+  return orgId_;
-	orgName_ = orgName;
+}
-	setBodyParameter("OrgName", orgName);
+
+void DetectSkinDiseaseRequest::setOrgId(const std::string &orgId) {
+  orgId_ = orgId;
+  setBodyParameter(std::string("OrgId"), orgId);
 }
 

imageprocess/src/model/DetectSpineMRIRequest.cc

@@ -1,77 +1,67 @@
 /*
  * 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/imageprocess/model/DetectSpineMRIRequest.h>
+#include <alibabacloud/imageprocess/model/DetectSpineMRIRequest.h>
-
+
-using AlibabaCloud::Imageprocess::Model::DetectSpineMRIRequest;
+using AlibabaCloud::Imageprocess::Model::DetectSpineMRIRequest;
-
+
-DetectSpineMRIRequest::DetectSpineMRIRequest() :
+DetectSpineMRIRequest::DetectSpineMRIRequest()
-	RpcServiceRequest("imageprocess", "2020-03-20", "DetectSpineMRI")
+    : RpcServiceRequest("imageprocess", "2020-03-20", "DetectSpineMRI") {
-{
+  setMethod(HttpRequest::Method::Post);
-	setMethod(HttpRequest::Method::Post);
-}
-
-DetectSpineMRIRequest::~DetectSpineMRIRequest()
-{}
-
-std::string DetectSpineMRIRequest::getDataFormat()const
-{
-	return dataFormat_;
 }
 
-void DetectSpineMRIRequest::setDataFormat(const std::string& dataFormat)
+DetectSpineMRIRequest::~DetectSpineMRIRequest() {}
-{
+
-	dataFormat_ = dataFormat;
+std::string DetectSpineMRIRequest::getOrgName() const {
-	setBodyParameter("DataFormat", dataFormat);
+  return orgName_;
 }
 
-std::vector<DetectSpineMRIRequest::URLList> DetectSpineMRIRequest::getURLList()const
+void DetectSpineMRIRequest::setOrgName(const std::string &orgName) {
-{
+  orgName_ = orgName;
-	return uRLList_;
+  setBodyParameter(std::string("OrgName"), orgName);
 }
 
-void DetectSpineMRIRequest::setURLList(const std::vector<URLList>& uRLList)
+std::string DetectSpineMRIRequest::getDataFormat() const {
-{
+  return dataFormat_;
-	uRLList_ = uRLList;
-	for(int dep1 = 0; dep1!= uRLList.size(); dep1++) {
-		auto uRLListObj = uRLList.at(dep1);
-		std::string uRLListObjStr = "URLList." + std::to_string(dep1 + 1);
-		setParameter(uRLListObjStr + ".URL", uRLListObj.uRL);
-	}
 }
 
-std::string DetectSpineMRIRequest::getOrgId()const
+void DetectSpineMRIRequest::setDataFormat(const std::string &dataFormat) {
-{
+  dataFormat_ = dataFormat;
-	return orgId_;
+  setBodyParameter(std::string("DataFormat"), dataFormat);
 }
 
-void DetectSpineMRIRequest::setOrgId(const std::string& orgId)
+std::vector<DetectSpineMRIRequest::URLList> DetectSpineMRIRequest::getURLList() const {
-{
+  return uRLList_;
-	orgId_ = orgId;
-	setBodyParameter("OrgId", orgId);
 }
 
-std::string DetectSpineMRIRequest::getOrgName()const
+void DetectSpineMRIRequest::setURLList(const std::vector<DetectSpineMRIRequest::URLList> &uRLList) {
-{
+  uRLList_ = uRLList;
-	return orgName_;
+  for(int dep1 = 0; dep1 != uRLList.size(); dep1++) {
+  auto uRLListObj = uRLList.at(dep1);
+  std::string uRLListObjStr = std::string("URLList") + "." + std::to_string(dep1 + 1);
+    setBodyParameter(uRLListObjStr + ".URL", uRLListObj.uRL);
+  }
 }
 
-void DetectSpineMRIRequest::setOrgName(const std::string& orgName)
+std::string DetectSpineMRIRequest::getOrgId() const {
-{
+  return orgId_;
-	orgName_ = orgName;
+}
-	setBodyParameter("OrgName", orgName);
+
+void DetectSpineMRIRequest::setOrgId(const std::string &orgId) {
+  orgId_ = orgId;
+  setBodyParameter(std::string("OrgId"), orgId);
 }
 

imageprocess/src/model/DetectSpineMRIResult.cc

@@ -44,10 +44,10 @@ void DetectSpineMRIResult::parse(const std::string &payload)
 	for (auto dataNodeDiscsDisc : allDiscsNode)
 	{
 		Data::Disc discObject;
-		if(!dataNodeDiscsDisc["Disease"].isNull())
-			discObject.disease = dataNodeDiscsDisc["Disease"].asString();
 		if(!dataNodeDiscsDisc["Identification"].isNull())
 			discObject.identification = dataNodeDiscsDisc["Identification"].asString();
+		if(!dataNodeDiscsDisc["Disease"].isNull())
+			discObject.disease = dataNodeDiscsDisc["Disease"].asString();
 		auto allLocation = value["Location"]["Location"];
 		for (auto value : allLocation)
 			discObject.location.push_back(value.asString());
@@ -57,10 +57,10 @@ void DetectSpineMRIResult::parse(const std::string &payload)
 	for (auto dataNodeVertebrasVertebra : allVertebrasNode)
 	{
 		Data::Vertebra vertebraObject;
-		if(!dataNodeVertebrasVertebra["Disease"].isNull())
-			vertebraObject.disease = dataNodeVertebrasVertebra["Disease"].asString();
 		if(!dataNodeVertebrasVertebra["Identification"].isNull())
 			vertebraObject.identification = dataNodeVertebrasVertebra["Identification"].asString();
+		if(!dataNodeVertebrasVertebra["Disease"].isNull())
+			vertebraObject.disease = dataNodeVertebrasVertebra["Disease"].asString();
 		auto allLocation1 = value["Location"]["Location"];
 		for (auto value : allLocation1)
 			vertebraObject.location1.push_back(value.asString());

imageprocess/src/model/GetAsyncJobResultRequest.cc

@@ -1,51 +1,45 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
+ */
-
+
-#include <alibabacloud/imageprocess/model/GetAsyncJobResultRequest.h>
+#include <alibabacloud/imageprocess/model/GetAsyncJobResultRequest.h>
-
+
-using AlibabaCloud::Imageprocess::Model::GetAsyncJobResultRequest;
+using AlibabaCloud::Imageprocess::Model::GetAsyncJobResultRequest;
-
+
-GetAsyncJobResultRequest::GetAsyncJobResultRequest() :
+GetAsyncJobResultRequest::GetAsyncJobResultRequest()
-	RpcServiceRequest("imageprocess", "2020-03-20", "GetAsyncJobResult")
+    : RpcServiceRequest("imageprocess", "2020-03-20", "GetAsyncJobResult") {
-{
+  setMethod(HttpRequest::Method::Post);
-	setMethod(HttpRequest::Method::Post);
-}
-
-GetAsyncJobResultRequest::~GetAsyncJobResultRequest()
-{}
-
-bool GetAsyncJobResultRequest::getAsync()const
-{
-	return async_;
 }
 
-void GetAsyncJobResultRequest::setAsync(bool async)
+GetAsyncJobResultRequest::~GetAsyncJobResultRequest() {}
-{
+
-	async_ = async;
+std::string GetAsyncJobResultRequest::getJobId() const {
-	setBodyParameter("Async", async ? "true" : "false");
+  return jobId_;
 }
 
-std::string GetAsyncJobResultRequest::getJobId()const
+void GetAsyncJobResultRequest::setJobId(const std::string &jobId) {
-{
+  jobId_ = jobId;
-	return jobId_;
+  setBodyParameter(std::string("JobId"), jobId);
 }
 
-void GetAsyncJobResultRequest::setJobId(const std::string& jobId)
+bool GetAsyncJobResultRequest::getAsync() const {
-{
+  return async_;
-	jobId_ = jobId;
+}
-	setBodyParameter("JobId", jobId);
+
+void GetAsyncJobResultRequest::setAsync(bool async) {
+  async_ = async;
+  setBodyParameter(std::string("Async"), async ? "true" : "false");
 }
 

imageprocess/src/model/GetAsyncJobResultResult.cc

@@ -40,16 +40,16 @@ void GetAsyncJobResultResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto dataNode = value["Data"];
-	if(!dataNode["JobId"].isNull())
-		data_.jobId = dataNode["JobId"].asString();
 	if(!dataNode["Status"].isNull())
 		data_.status = dataNode["Status"].asString();
+	if(!dataNode["ErrorMessage"].isNull())
+		data_.errorMessage = dataNode["ErrorMessage"].asString();
 	if(!dataNode["Result"].isNull())
 		data_.result = dataNode["Result"].asString();
 	if(!dataNode["ErrorCode"].isNull())
 		data_.errorCode = dataNode["ErrorCode"].asString();
-	if(!dataNode["ErrorMessage"].isNull())
+	if(!dataNode["JobId"].isNull())
-		data_.errorMessage = dataNode["ErrorMessage"].asString();
+		data_.jobId = dataNode["JobId"].asString();
 
 }
 

imageprocess/src/model/RunCTRegistrationRequest.cc

@@ -1,114 +1,98 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
+ */
-
+
-#include <alibabacloud/imageprocess/model/RunCTRegistrationRequest.h>
+#include <alibabacloud/imageprocess/model/RunCTRegistrationRequest.h>
-
+
-using AlibabaCloud::Imageprocess::Model::RunCTRegistrationRequest;
+using AlibabaCloud::Imageprocess::Model::RunCTRegistrationRequest;
-
+
-RunCTRegistrationRequest::RunCTRegistrationRequest() :
+RunCTRegistrationRequest::RunCTRegistrationRequest()
-	RpcServiceRequest("imageprocess", "2020-03-20", "RunCTRegistration")
+    : RpcServiceRequest("imageprocess", "2020-03-20", "RunCTRegistration") {
-{
+  setMethod(HttpRequest::Method::Post);
-	setMethod(HttpRequest::Method::Post);
-}
-
-RunCTRegistrationRequest::~RunCTRegistrationRequest()
-{}
-
-std::string RunCTRegistrationRequest::getDataSourceType()const
-{
-	return dataSourceType_;
 }
 
-void RunCTRegistrationRequest::setDataSourceType(const std::string& dataSourceType)
+RunCTRegistrationRequest::~RunCTRegistrationRequest() {}
-{
+
-	dataSourceType_ = dataSourceType;
+std::string RunCTRegistrationRequest::getDataSourceType() const {
-	setBodyParameter("DataSourceType", dataSourceType);
+  return dataSourceType_;
 }
 
-std::string RunCTRegistrationRequest::getOrgName()const
+void RunCTRegistrationRequest::setDataSourceType(const std::string &dataSourceType) {
-{
+  dataSourceType_ = dataSourceType;
-	return orgName_;
+  setBodyParameter(std::string("DataSourceType"), dataSourceType);
 }
 
-void RunCTRegistrationRequest::setOrgName(const std::string& orgName)
+std::string RunCTRegistrationRequest::getOrgName() const {
-{
+  return orgName_;
-	orgName_ = orgName;
-	setBodyParameter("OrgName", orgName);
 }
 
-std::vector<RunCTRegistrationRequest::ReferenceList> RunCTRegistrationRequest::getReferenceList()const
+void RunCTRegistrationRequest::setOrgName(const std::string &orgName) {
-{
+  orgName_ = orgName;
-	return referenceList_;
+  setBodyParameter(std::string("OrgName"), orgName);
 }
 
-void RunCTRegistrationRequest::setReferenceList(const std::vector<ReferenceList>& referenceList)
+std::vector<RunCTRegistrationRequest::ReferenceList> RunCTRegistrationRequest::getReferenceList() const {
-{
+  return referenceList_;
-	referenceList_ = referenceList;
-	for(int dep1 = 0; dep1!= referenceList.size(); dep1++) {
-		auto referenceListObj = referenceList.at(dep1);
-		std::string referenceListObjStr = "ReferenceList." + std::to_string(dep1 + 1);
-		setParameter(referenceListObjStr + ".ReferenceURL", referenceListObj.referenceURL);
-	}
 }
 
-std::string RunCTRegistrationRequest::getDataFormat()const
+void RunCTRegistrationRequest::setReferenceList(const std::vector<RunCTRegistrationRequest::ReferenceList> &referenceList) {
-{
+  referenceList_ = referenceList;
-	return dataFormat_;
+  for(int dep1 = 0; dep1 != referenceList.size(); dep1++) {
+  auto referenceListObj = referenceList.at(dep1);
+  std::string referenceListObjStr = std::string("ReferenceList") + "." + std::to_string(dep1 + 1);
+    setBodyParameter(referenceListObjStr + ".ReferenceURL", referenceListObj.referenceURL);
+  }
 }
 
-void RunCTRegistrationRequest::setDataFormat(const std::string& dataFormat)
+std::string RunCTRegistrationRequest::getDataFormat() const {
-{
+  return dataFormat_;
-	dataFormat_ = dataFormat;
-	setBodyParameter("DataFormat", dataFormat);
 }
 
-std::string RunCTRegistrationRequest::getOrgId()const
+void RunCTRegistrationRequest::setDataFormat(const std::string &dataFormat) {
-{
+  dataFormat_ = dataFormat;
-	return orgId_;
+  setBodyParameter(std::string("DataFormat"), dataFormat);
 }
 
-void RunCTRegistrationRequest::setOrgId(const std::string& orgId)
+std::string RunCTRegistrationRequest::getOrgId() const {
-{
+  return orgId_;
-	orgId_ = orgId;
-	setBodyParameter("OrgId", orgId);
 }
 
-bool RunCTRegistrationRequest::getAsync()const
+void RunCTRegistrationRequest::setOrgId(const std::string &orgId) {
-{
+  orgId_ = orgId;
-	return async_;
+  setBodyParameter(std::string("OrgId"), orgId);
 }
 
-void RunCTRegistrationRequest::setAsync(bool async)
+bool RunCTRegistrationRequest::getAsync() const {
-{
+  return async_;
-	async_ = async;
-	setBodyParameter("Async", async ? "true" : "false");
 }
 
-std::vector<RunCTRegistrationRequest::FloatingList> RunCTRegistrationRequest::getFloatingList()const
+void RunCTRegistrationRequest::setAsync(bool async) {
-{
+  async_ = async;
-	return floatingList_;
+  setBodyParameter(std::string("Async"), async ? "true" : "false");
 }
 
-void RunCTRegistrationRequest::setFloatingList(const std::vector<FloatingList>& floatingList)
+std::vector<RunCTRegistrationRequest::FloatingList> RunCTRegistrationRequest::getFloatingList() const {
-{
+  return floatingList_;
-	floatingList_ = floatingList;
+}
-	for(int dep1 = 0; dep1!= floatingList.size(); dep1++) {
+
-		auto floatingListObj = floatingList.at(dep1);
+void RunCTRegistrationRequest::setFloatingList(const std::vector<RunCTRegistrationRequest::FloatingList> &floatingList) {
-		std::string floatingListObjStr = "FloatingList." + std::to_string(dep1 + 1);
+  floatingList_ = floatingList;
-		setParameter(floatingListObjStr + ".FloatingURL", floatingListObj.floatingURL);
+  for(int dep1 = 0; dep1 != floatingList.size(); dep1++) {
-	}
+  auto floatingListObj = floatingList.at(dep1);
+  std::string floatingListObjStr = std::string("FloatingList") + "." + std::to_string(dep1 + 1);
+    setBodyParameter(floatingListObjStr + ".FloatingURL", floatingListObj.floatingURL);
+  }
 }
 

imageprocess/src/model/RunMedQARequest.cc

@@ -1,129 +1,111 @@
 /*
  * 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/imageprocess/model/RunMedQARequest.h>
+#include <alibabacloud/imageprocess/model/RunMedQARequest.h>
-
+
-using AlibabaCloud::Imageprocess::Model::RunMedQARequest;
+using AlibabaCloud::Imageprocess::Model::RunMedQARequest;
-
+
-RunMedQARequest::RunMedQARequest() :
+RunMedQARequest::RunMedQARequest()
-	RpcServiceRequest("imageprocess", "2020-03-20", "RunMedQA")
+    : RpcServiceRequest("imageprocess", "2020-03-20", "RunMedQA") {
-{
+  setMethod(HttpRequest::Method::Post);
-	setMethod(HttpRequest::Method::Post);
-}
-
-RunMedQARequest::~RunMedQARequest()
-{}
-
-std::string RunMedQARequest::getSessionId()const
-{
-	return sessionId_;
 }
 
-void RunMedQARequest::setSessionId(const std::string& sessionId)
+RunMedQARequest::~RunMedQARequest() {}
-{
+
-	sessionId_ = sessionId;
+std::string RunMedQARequest::getSessionId() const {
-	setBodyParameter("SessionId", sessionId);
+  return sessionId_;
 }
 
-std::string RunMedQARequest::getOrgName()const
+void RunMedQARequest::setSessionId(const std::string &sessionId) {
-{
+  sessionId_ = sessionId;
-	return orgName_;
+  setBodyParameter(std::string("SessionId"), sessionId);
 }
 
-void RunMedQARequest::setOrgName(const std::string& orgName)
+std::string RunMedQARequest::getOrgName() const {
-{
+  return orgName_;
-	orgName_ = orgName;
-	setBodyParameter("OrgName", orgName);
 }
 
-std::vector<RunMedQARequest::AnswerImageDataList> RunMedQARequest::getAnswerImageDataList()const
+void RunMedQARequest::setOrgName(const std::string &orgName) {
-{
+  orgName_ = orgName;
-	return answerImageDataList_;
+  setBodyParameter(std::string("OrgName"), orgName);
 }
 
-void RunMedQARequest::setAnswerImageDataList(const std::vector<AnswerImageDataList>& answerImageDataList)
+std::vector<RunMedQARequest::AnswerImageDataList> RunMedQARequest::getAnswerImageDataList() const {
-{
+  return answerImageDataList_;
-	answerImageDataList_ = answerImageDataList;
-	for(int dep1 = 0; dep1!= answerImageDataList.size(); dep1++) {
-		auto answerImageDataListObj = answerImageDataList.at(dep1);
-		std::string answerImageDataListObjStr = "AnswerImageDataList." + std::to_string(dep1 + 1);
-		setParameter(answerImageDataListObjStr + ".AnswerImageData", answerImageDataListObj.answerImageData);
-	}
 }
 
-std::vector<RunMedQARequest::AnswerTextList> RunMedQARequest::getAnswerTextList()const
+void RunMedQARequest::setAnswerImageDataList(const std::vector<RunMedQARequest::AnswerImageDataList> &answerImageDataList) {
-{
+  answerImageDataList_ = answerImageDataList;
-	return answerTextList_;
+  for(int dep1 = 0; dep1 != answerImageDataList.size(); dep1++) {
+  auto answerImageDataListObj = answerImageDataList.at(dep1);
+  std::string answerImageDataListObjStr = std::string("AnswerImageDataList") + "." + std::to_string(dep1 + 1);
+    setBodyParameter(answerImageDataListObjStr + ".AnswerImageData", answerImageDataListObj.answerImageData);
+  }
 }
 
-void RunMedQARequest::setAnswerTextList(const std::vector<AnswerTextList>& answerTextList)
+std::vector<RunMedQARequest::AnswerTextList> RunMedQARequest::getAnswerTextList() const {
-{
+  return answerTextList_;
-	answerTextList_ = answerTextList;
-	for(int dep1 = 0; dep1!= answerTextList.size(); dep1++) {
-		auto answerTextListObj = answerTextList.at(dep1);
-		std::string answerTextListObjStr = "AnswerTextList." + std::to_string(dep1 + 1);
-		setParameter(answerTextListObjStr + ".AnswerText", answerTextListObj.answerText);
-	}
 }
 
-std::string RunMedQARequest::getDepartment()const
+void RunMedQARequest::setAnswerTextList(const std::vector<RunMedQARequest::AnswerTextList> &answerTextList) {
-{
+  answerTextList_ = answerTextList;
-	return department_;
+  for(int dep1 = 0; dep1 != answerTextList.size(); dep1++) {
+  auto answerTextListObj = answerTextList.at(dep1);
+  std::string answerTextListObjStr = std::string("AnswerTextList") + "." + std::to_string(dep1 + 1);
+    setBodyParameter(answerTextListObjStr + ".AnswerText", answerTextListObj.answerText);
+  }
 }
 
-void RunMedQARequest::setDepartment(const std::string& department)
+std::string RunMedQARequest::getDepartment() const {
-{
+  return department_;
-	department_ = department;
-	setBodyParameter("Department", department);
 }
 
-std::vector<RunMedQARequest::AnswerImageURLList> RunMedQARequest::getAnswerImageURLList()const
+void RunMedQARequest::setDepartment(const std::string &department) {
-{
+  department_ = department;
-	return answerImageURLList_;
+  setBodyParameter(std::string("Department"), department);
 }
 
-void RunMedQARequest::setAnswerImageURLList(const std::vector<AnswerImageURLList>& answerImageURLList)
+std::vector<RunMedQARequest::AnswerImageURLList> RunMedQARequest::getAnswerImageURLList() const {
-{
+  return answerImageURLList_;
-	answerImageURLList_ = answerImageURLList;
-	for(int dep1 = 0; dep1!= answerImageURLList.size(); dep1++) {
-		auto answerImageURLListObj = answerImageURLList.at(dep1);
-		std::string answerImageURLListObjStr = "AnswerImageURLList." + std::to_string(dep1 + 1);
-		setParameter(answerImageURLListObjStr + ".AnswerImageURL", answerImageURLListObj.answerImageURL);
-	}
 }
 
-std::string RunMedQARequest::getQuestionType()const
+void RunMedQARequest::setAnswerImageURLList(const std::vector<RunMedQARequest::AnswerImageURLList> &answerImageURLList) {
-{
+  answerImageURLList_ = answerImageURLList;
-	return questionType_;
+  for(int dep1 = 0; dep1 != answerImageURLList.size(); dep1++) {
+  auto answerImageURLListObj = answerImageURLList.at(dep1);
+  std::string answerImageURLListObjStr = std::string("AnswerImageURLList") + "." + std::to_string(dep1 + 1);
+    setBodyParameter(answerImageURLListObjStr + ".AnswerImageURL", answerImageURLListObj.answerImageURL);
+  }
 }
 
-void RunMedQARequest::setQuestionType(const std::string& questionType)
+std::string RunMedQARequest::getQuestionType() const {
-{
+  return questionType_;
-	questionType_ = questionType;
-	setBodyParameter("QuestionType", questionType);
 }
 
-std::string RunMedQARequest::getOrgId()const
+void RunMedQARequest::setQuestionType(const std::string &questionType) {
-{
+  questionType_ = questionType;
-	return orgId_;
+  setBodyParameter(std::string("QuestionType"), questionType);
 }
 
-void RunMedQARequest::setOrgId(const std::string& orgId)
+std::string RunMedQARequest::getOrgId() const {
-{
+  return orgId_;
-	orgId_ = orgId;
+}
-	setBodyParameter("OrgId", orgId);
+
+void RunMedQARequest::setOrgId(const std::string &orgId) {
+  orgId_ = orgId;
+  setBodyParameter(std::string("OrgId"), orgId);
 }
 

imageprocess/src/model/RunMedQAResult.cc

@@ -40,23 +40,23 @@ void RunMedQAResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto dataNode = value["Data"];
-	if(!dataNode["Reports"].isNull())
-		data_.reports = dataNode["Reports"].asString();
-	if(!dataNode["QuestionType"].isNull())
-		data_.questionType = dataNode["QuestionType"].asString();
-	if(!dataNode["AnswerType"].isNull())
-		data_.answerType = dataNode["AnswerType"].asString();
-	if(!dataNode["Question"].isNull())
-		data_.question = dataNode["Question"].asString();
 	if(!dataNode["SessionId"].isNull())
 		data_.sessionId = dataNode["SessionId"].asString();
+	if(!dataNode["QuestionType"].isNull())
+		data_.questionType = dataNode["QuestionType"].asString();
+	if(!dataNode["Question"].isNull())
+		data_.question = dataNode["Question"].asString();
+	if(!dataNode["AnswerType"].isNull())
+		data_.answerType = dataNode["AnswerType"].asString();
+	if(!dataNode["Reports"].isNull())
+		data_.reports = dataNode["Reports"].asString();
 		auto allOptions = dataNode["Options"]["options"];
 		for (auto value : allOptions)
 			data_.options.push_back(value.asString());
-	if(!value["Message"].isNull())
-		message_ = value["Message"].asString();
 	if(!value["Code"].isNull())
 		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
 
 }
 

imageprocess/src/model/ScreenChestCTRequest.cc

@@ -1,99 +1,85 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
+ */
-
+
-#include <alibabacloud/imageprocess/model/ScreenChestCTRequest.h>
+#include <alibabacloud/imageprocess/model/ScreenChestCTRequest.h>
-
+
-using AlibabaCloud::Imageprocess::Model::ScreenChestCTRequest;
+using AlibabaCloud::Imageprocess::Model::ScreenChestCTRequest;
-
+
-ScreenChestCTRequest::ScreenChestCTRequest() :
+ScreenChestCTRequest::ScreenChestCTRequest()
-	RpcServiceRequest("imageprocess", "2020-03-20", "ScreenChestCT")
+    : RpcServiceRequest("imageprocess", "2020-03-20", "ScreenChestCT") {
-{
+  setMethod(HttpRequest::Method::Post);
-	setMethod(HttpRequest::Method::Post);
-}
-
-ScreenChestCTRequest::~ScreenChestCTRequest()
-{}
-
-std::string ScreenChestCTRequest::getOrgName()const
-{
-	return orgName_;
 }
 
-void ScreenChestCTRequest::setOrgName(const std::string& orgName)
+ScreenChestCTRequest::~ScreenChestCTRequest() {}
-{
+
-	orgName_ = orgName;
+std::string ScreenChestCTRequest::getOrgName() const {
-	setBodyParameter("OrgName", orgName);
+  return orgName_;
 }
 
-long ScreenChestCTRequest::getMask()const
+void ScreenChestCTRequest::setOrgName(const std::string &orgName) {
-{
+  orgName_ = orgName;
-	return mask_;
+  setBodyParameter(std::string("OrgName"), orgName);
 }
 
-void ScreenChestCTRequest::setMask(long mask)
+long ScreenChestCTRequest::getMask() const {
-{
+  return mask_;
-	mask_ = mask;
-	setBodyParameter("Mask", std::to_string(mask));
 }
 
-std::string ScreenChestCTRequest::getDataFormat()const
+void ScreenChestCTRequest::setMask(long mask) {
-{
+  mask_ = mask;
-	return dataFormat_;
+  setBodyParameter(std::string("Mask"), std::to_string(mask));
 }
 
-void ScreenChestCTRequest::setDataFormat(const std::string& dataFormat)
+std::string ScreenChestCTRequest::getDataFormat() const {
-{
+  return dataFormat_;
-	dataFormat_ = dataFormat;
-	setBodyParameter("DataFormat", dataFormat);
 }
 
-std::vector<ScreenChestCTRequest::URLList> ScreenChestCTRequest::getURLList()const
+void ScreenChestCTRequest::setDataFormat(const std::string &dataFormat) {
-{
+  dataFormat_ = dataFormat;
-	return uRLList_;
+  setBodyParameter(std::string("DataFormat"), dataFormat);
 }
 
-void ScreenChestCTRequest::setURLList(const std::vector<URLList>& uRLList)
+std::vector<ScreenChestCTRequest::URLList> ScreenChestCTRequest::getURLList() const {
-{
+  return uRLList_;
-	uRLList_ = uRLList;
-	for(int dep1 = 0; dep1!= uRLList.size(); dep1++) {
-		auto uRLListObj = uRLList.at(dep1);
-		std::string uRLListObjStr = "URLList." + std::to_string(dep1 + 1);
-		setParameter(uRLListObjStr + ".URL", uRLListObj.uRL);
-	}
 }
 
-std::string ScreenChestCTRequest::getOrgId()const
+void ScreenChestCTRequest::setURLList(const std::vector<ScreenChestCTRequest::URLList> &uRLList) {
-{
+  uRLList_ = uRLList;
-	return orgId_;
+  for(int dep1 = 0; dep1 != uRLList.size(); dep1++) {
+  auto uRLListObj = uRLList.at(dep1);
+  std::string uRLListObjStr = std::string("URLList") + "." + std::to_string(dep1 + 1);
+    setBodyParameter(uRLListObjStr + ".URL", uRLListObj.uRL);
+  }
 }
 
-void ScreenChestCTRequest::setOrgId(const std::string& orgId)
+std::string ScreenChestCTRequest::getOrgId() const {
-{
+  return orgId_;
-	orgId_ = orgId;
-	setBodyParameter("OrgId", orgId);
 }
 
-bool ScreenChestCTRequest::getAsync()const
+void ScreenChestCTRequest::setOrgId(const std::string &orgId) {
-{
+  orgId_ = orgId;
-	return async_;
+  setBodyParameter(std::string("OrgId"), orgId);
 }
 
-void ScreenChestCTRequest::setAsync(bool async)
+bool ScreenChestCTRequest::getAsync() const {
-{
+  return async_;
-	async_ = async;
+}
-	setBodyParameter("Async", async ? "true" : "false");
+
+void ScreenChestCTRequest::setAsync(bool async) {
+  async_ = async;
+  setBodyParameter(std::string("Async"), async ? "true" : "false");
 }
 

imageprocess/src/model/ScreenChestCTResult.cc

@@ -126,7 +126,7 @@ void ScreenChestCTResult::parse(const std::string &payload)
 			detectionsItemObject.fractureLocation = detectRibFractureNodeDetectionsDetectionsItem["FractureLocation"].asString();
 		if(!detectRibFractureNodeDetectionsDetectionsItem["FractureSegment"].isNull())
 			detectionsItemObject.fractureSegment = std::stol(detectRibFractureNodeDetectionsDetectionsItem["FractureSegment"].asString());
-		auto allCoordinates = value["Coordinates"]["coordinates"];
+		auto allCoordinates = value["Coordinates"]["Coordinates"];
 		for (auto value : allCoordinates)
 			detectionsItemObject.coordinates.push_back(value.asString());
 		auto allCoordinateImage = value["CoordinateImage"]["CoordinateImage"];

imageprocess/src/model/TranslateMedRequest.cc

@@ -1,62 +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/imageprocess/model/TranslateMedRequest.h>
+#include <alibabacloud/imageprocess/model/TranslateMedRequest.h>
-
+
-using AlibabaCloud::Imageprocess::Model::TranslateMedRequest;
+using AlibabaCloud::Imageprocess::Model::TranslateMedRequest;
-
+
-TranslateMedRequest::TranslateMedRequest() :
+TranslateMedRequest::TranslateMedRequest()
-	RpcServiceRequest("imageprocess", "2020-03-20", "TranslateMed")
+    : RpcServiceRequest("imageprocess", "2020-03-20", "TranslateMed") {
-{
+  setMethod(HttpRequest::Method::Post);
-	setMethod(HttpRequest::Method::Post);
-}
-
-TranslateMedRequest::~TranslateMedRequest()
-{}
-
-std::string TranslateMedRequest::getFromLanguage()const
-{
-	return fromLanguage_;
 }
 
-void TranslateMedRequest::setFromLanguage(const std::string& fromLanguage)
+TranslateMedRequest::~TranslateMedRequest() {}
-{
+
-	fromLanguage_ = fromLanguage;
+std::string TranslateMedRequest::getToLanguage() const {
-	setBodyParameter("FromLanguage", fromLanguage);
+  return toLanguage_;
 }
 
-std::string TranslateMedRequest::getToLanguage()const
+void TranslateMedRequest::setToLanguage(const std::string &toLanguage) {
-{
+  toLanguage_ = toLanguage;
-	return toLanguage_;
+  setBodyParameter(std::string("ToLanguage"), toLanguage);
 }
 
-void TranslateMedRequest::setToLanguage(const std::string& toLanguage)
+std::string TranslateMedRequest::getText() const {
-{
+  return text_;
-	toLanguage_ = toLanguage;
-	setBodyParameter("ToLanguage", toLanguage);
 }
 
-std::string TranslateMedRequest::getText()const
+void TranslateMedRequest::setText(const std::string &text) {
-{
+  text_ = text;
-	return text_;
+  setBodyParameter(std::string("Text"), text);
 }
 
-void TranslateMedRequest::setText(const std::string& text)
+std::string TranslateMedRequest::getFromLanguage() const {
-{
+  return fromLanguage_;
-	text_ = text;
+}
-	setBodyParameter("Text", text);
+
+void TranslateMedRequest::setFromLanguage(const std::string &fromLanguage) {
+  fromLanguage_ = fromLanguage;
+  setBodyParameter(std::string("FromLanguage"), fromLanguage);
 }
 

imageprocess/src/model/TranslateMedResult.cc

@@ -40,10 +40,10 @@ void TranslateMedResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto dataNode = value["Data"];
-	if(!dataNode["Text"].isNull())
-		data_.text = dataNode["Text"].asString();
 	if(!dataNode["Words"].isNull())
 		data_.words = std::stol(dataNode["Words"].asString());
+	if(!dataNode["Text"].isNull())
+		data_.text = dataNode["Text"].asString();
 
 }