Update RecognizeVideoCastCrewList.

CHANGELOG

@@ -1,3 +1,6 @@
+2022-06-28 Version: 1.36.1161
+- Update RecognizeVideoCastCrewList.
+
 2022-06-24 Version: 1.36.1160
 - Update ScreenChestCT.
 

VERSION

@@ -1 +1 @@
-1.36.1160
+1.36.1161

videorecog/CMakeLists.txt

@@ -27,6 +27,10 @@ set(videorecog_public_header_model
 	include/alibabacloud/videorecog/model/GenerateVideoCoverResult.h
 	include/alibabacloud/videorecog/model/GetAsyncJobResultRequest.h
 	include/alibabacloud/videorecog/model/GetAsyncJobResultResult.h
+	include/alibabacloud/videorecog/model/RecognizeVideoCastCrewListRequest.h
+	include/alibabacloud/videorecog/model/RecognizeVideoCastCrewListResult.h
+	include/alibabacloud/videorecog/model/SplitVideoPartsRequest.h
+	include/alibabacloud/videorecog/model/SplitVideoPartsResult.h
 	include/alibabacloud/videorecog/model/UnderstandVideoContentRequest.h
 	include/alibabacloud/videorecog/model/UnderstandVideoContentResult.h )
 
@@ -38,6 +42,10 @@ set(videorecog_src
 	src/model/GenerateVideoCoverResult.cc
 	src/model/GetAsyncJobResultRequest.cc
 	src/model/GetAsyncJobResultResult.cc
+	src/model/RecognizeVideoCastCrewListRequest.cc
+	src/model/RecognizeVideoCastCrewListResult.cc
+	src/model/SplitVideoPartsRequest.cc
+	src/model/SplitVideoPartsResult.cc
 	src/model/UnderstandVideoContentRequest.cc
 	src/model/UnderstandVideoContentResult.cc )
 

videorecog/include/alibabacloud/videorecog/VideorecogClient.h

@@ -28,6 +28,10 @@
 #include "model/GenerateVideoCoverResult.h"
 #include "model/GetAsyncJobResultRequest.h"
 #include "model/GetAsyncJobResultResult.h"
+#include "model/RecognizeVideoCastCrewListRequest.h"
+#include "model/RecognizeVideoCastCrewListResult.h"
+#include "model/SplitVideoPartsRequest.h"
+#include "model/SplitVideoPartsResult.h"
 #include "model/UnderstandVideoContentRequest.h"
 #include "model/UnderstandVideoContentResult.h"
 
@@ -48,6 +52,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::GetAsyncJobResultResult> GetAsyncJobResultOutcome;
 			typedef std::future<GetAsyncJobResultOutcome> GetAsyncJobResultOutcomeCallable;
 			typedef std::function<void(const VideorecogClient*, const Model::GetAsyncJobResultRequest&, const GetAsyncJobResultOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAsyncJobResultAsyncHandler;
+			typedef Outcome<Error, Model::RecognizeVideoCastCrewListResult> RecognizeVideoCastCrewListOutcome;
+			typedef std::future<RecognizeVideoCastCrewListOutcome> RecognizeVideoCastCrewListOutcomeCallable;
+			typedef std::function<void(const VideorecogClient*, const Model::RecognizeVideoCastCrewListRequest&, const RecognizeVideoCastCrewListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeVideoCastCrewListAsyncHandler;
+			typedef Outcome<Error, Model::SplitVideoPartsResult> SplitVideoPartsOutcome;
+			typedef std::future<SplitVideoPartsOutcome> SplitVideoPartsOutcomeCallable;
+			typedef std::function<void(const VideorecogClient*, const Model::SplitVideoPartsRequest&, const SplitVideoPartsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SplitVideoPartsAsyncHandler;
 			typedef Outcome<Error, Model::UnderstandVideoContentResult> UnderstandVideoContentOutcome;
 			typedef std::future<UnderstandVideoContentOutcome> UnderstandVideoContentOutcomeCallable;
 			typedef std::function<void(const VideorecogClient*, const Model::UnderstandVideoContentRequest&, const UnderstandVideoContentOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UnderstandVideoContentAsyncHandler;
@@ -65,6 +75,12 @@ namespace AlibabaCloud
 			GetAsyncJobResultOutcome getAsyncJobResult(const Model::GetAsyncJobResultRequest &request)const;
 			void getAsyncJobResultAsync(const Model::GetAsyncJobResultRequest& request, const GetAsyncJobResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetAsyncJobResultOutcomeCallable getAsyncJobResultCallable(const Model::GetAsyncJobResultRequest& request) const;
+			RecognizeVideoCastCrewListOutcome recognizeVideoCastCrewList(const Model::RecognizeVideoCastCrewListRequest &request)const;
+			void recognizeVideoCastCrewListAsync(const Model::RecognizeVideoCastCrewListRequest& request, const RecognizeVideoCastCrewListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RecognizeVideoCastCrewListOutcomeCallable recognizeVideoCastCrewListCallable(const Model::RecognizeVideoCastCrewListRequest& request) const;
+			SplitVideoPartsOutcome splitVideoParts(const Model::SplitVideoPartsRequest &request)const;
+			void splitVideoPartsAsync(const Model::SplitVideoPartsRequest& request, const SplitVideoPartsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SplitVideoPartsOutcomeCallable splitVideoPartsCallable(const Model::SplitVideoPartsRequest& request) const;
 			UnderstandVideoContentOutcome understandVideoContent(const Model::UnderstandVideoContentRequest &request)const;
 			void understandVideoContentAsync(const Model::UnderstandVideoContentRequest& request, const UnderstandVideoContentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UnderstandVideoContentOutcomeCallable understandVideoContentCallable(const Model::UnderstandVideoContentRequest& request) const;

videorecog/include/alibabacloud/videorecog/model/DetectVideoShotRequest.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_VIDEORECOG_MODEL_DETECTVIDEOSHOTREQUEST_H_
-#define ALIBABACLOUD_VIDEORECOG_MODEL_DETECTVIDEOSHOTREQUEST_H_
-
-#include <string>
-#include <vector>
-#include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/videorecog/VideorecogExport.h>
-
-namespace AlibabaCloud
-{
-	namespace Videorecog
-	{
-		namespace Model
-		{
-			class ALIBABACLOUD_VIDEORECOG_EXPORT DetectVideoShotRequest : public RpcServiceRequest
-			{
-
-			public:
-				DetectVideoShotRequest();
-				~DetectVideoShotRequest();
-
-				bool getAsync()const;
-				void setAsync(bool async);
-				std::string getVideoUrl()const;
-				void setVideoUrl(const std::string& videoUrl);
-
-            private:
-				bool async_;
-				std::string videoUrl_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_VIDEORECOG_MODEL_DETECTVIDEOSHOTREQUEST_H_
+ */
+
+#ifndef ALIBABACLOUD_VIDEORECOG_MODEL_DETECTVIDEOSHOTREQUEST_H_
+#define ALIBABACLOUD_VIDEORECOG_MODEL_DETECTVIDEOSHOTREQUEST_H_
+
+#include <alibabacloud/videorecog/VideorecogExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Videorecog {
+namespace Model {
+class ALIBABACLOUD_VIDEORECOG_EXPORT DetectVideoShotRequest : public RpcServiceRequest {
+public:
+	DetectVideoShotRequest();
+	~DetectVideoShotRequest();
+	bool getAsync() const;
+	void setAsync(bool async);
+	std::string getVideoUrl() const;
+	void setVideoUrl(const std::string &videoUrl);
+
+private:
+	bool async_;
+	std::string videoUrl_;
+};
+} // namespace Model
+} // namespace Videorecog
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_VIDEORECOG_MODEL_DETECTVIDEOSHOTREQUEST_H_

videorecog/include/alibabacloud/videorecog/model/GenerateVideoCoverRequest.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_VIDEORECOG_MODEL_GENERATEVIDEOCOVERREQUEST_H_
-#define ALIBABACLOUD_VIDEORECOG_MODEL_GENERATEVIDEOCOVERREQUEST_H_
-
-#include <string>
-#include <vector>
-#include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/videorecog/VideorecogExport.h>
-
-namespace AlibabaCloud
-{
-	namespace Videorecog
-	{
-		namespace Model
-		{
-			class ALIBABACLOUD_VIDEORECOG_EXPORT GenerateVideoCoverRequest : public RpcServiceRequest
-			{
-
-			public:
-				GenerateVideoCoverRequest();
-				~GenerateVideoCoverRequest();
-
-				bool getIsGif()const;
-				void setIsGif(bool isGif);
-				bool getAsync()const;
-				void setAsync(bool async);
-				std::string getVideoUrl()const;
-				void setVideoUrl(const std::string& videoUrl);
-
-            private:
-				bool isGif_;
-				bool async_;
-				std::string videoUrl_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_VIDEORECOG_MODEL_GENERATEVIDEOCOVERREQUEST_H_
+ */
+
+#ifndef ALIBABACLOUD_VIDEORECOG_MODEL_GENERATEVIDEOCOVERREQUEST_H_
+#define ALIBABACLOUD_VIDEORECOG_MODEL_GENERATEVIDEOCOVERREQUEST_H_
+
+#include <alibabacloud/videorecog/VideorecogExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Videorecog {
+namespace Model {
+class ALIBABACLOUD_VIDEORECOG_EXPORT GenerateVideoCoverRequest : public RpcServiceRequest {
+public:
+	GenerateVideoCoverRequest();
+	~GenerateVideoCoverRequest();
+	bool getIsGif() const;
+	void setIsGif(bool isGif);
+	bool getAsync() const;
+	void setAsync(bool async);
+	std::string getVideoUrl() const;
+	void setVideoUrl(const std::string &videoUrl);
+
+private:
+	bool isGif_;
+	bool async_;
+	std::string videoUrl_;
+};
+} // namespace Model
+} // namespace Videorecog
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_VIDEORECOG_MODEL_GENERATEVIDEOCOVERREQUEST_H_

videorecog/include/alibabacloud/videorecog/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_VIDEORECOG_MODEL_GETASYNCJOBRESULTREQUEST_H_
-#define ALIBABACLOUD_VIDEORECOG_MODEL_GETASYNCJOBRESULTREQUEST_H_
-
-#include <string>
-#include <vector>
-#include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/videorecog/VideorecogExport.h>
-
-namespace AlibabaCloud
-{
-	namespace Videorecog
-	{
-		namespace Model
-		{
-			class ALIBABACLOUD_VIDEORECOG_EXPORT GetAsyncJobResultRequest : public RpcServiceRequest
-			{
-
-			public:
-				GetAsyncJobResultRequest();
-				~GetAsyncJobResultRequest();
-
-				std::string getJobId()const;
-				void setJobId(const std::string& jobId);
-				bool getAsync()const;
-				void setAsync(bool async);
-
-            private:
-				std::string jobId_;
-				bool async_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_VIDEORECOG_MODEL_GETASYNCJOBRESULTREQUEST_H_
+ */
+
+#ifndef ALIBABACLOUD_VIDEORECOG_MODEL_GETASYNCJOBRESULTREQUEST_H_
+#define ALIBABACLOUD_VIDEORECOG_MODEL_GETASYNCJOBRESULTREQUEST_H_
+
+#include <alibabacloud/videorecog/VideorecogExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Videorecog {
+namespace Model {
+class ALIBABACLOUD_VIDEORECOG_EXPORT GetAsyncJobResultRequest : public RpcServiceRequest {
+public:
+	GetAsyncJobResultRequest();
+	~GetAsyncJobResultRequest();
+	std::string getJobId() const;
+	void setJobId(const std::string &jobId);
+	bool getAsync() const;
+	void setAsync(bool async);
+
+private:
+	std::string jobId_;
+	bool async_;
+};
+} // namespace Model
+} // namespace Videorecog
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_VIDEORECOG_MODEL_GETASYNCJOBRESULTREQUEST_H_

videorecog/include/alibabacloud/videorecog/model/RecognizeVideoCastCrewListRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_VIDEORECOG_MODEL_RECOGNIZEVIDEOCASTCREWLISTREQUEST_H_
+#define ALIBABACLOUD_VIDEORECOG_MODEL_RECOGNIZEVIDEOCASTCREWLISTREQUEST_H_
+
+#include <alibabacloud/videorecog/VideorecogExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Videorecog {
+namespace Model {
+class ALIBABACLOUD_VIDEORECOG_EXPORT RecognizeVideoCastCrewListRequest : public RpcServiceRequest {
+public:
+	struct Params {
+		std::string type;
+	};
+	RecognizeVideoCastCrewListRequest();
+	~RecognizeVideoCastCrewListRequest();
+	std::vector<Params> getParams() const;
+	void setParams(const std::vector<Params> &params);
+	bool getAsync() const;
+	void setAsync(bool async);
+	std::string getRegisterUrl() const;
+	void setRegisterUrl(const std::string &registerUrl);
+	std::string getVideoUrl() const;
+	void setVideoUrl(const std::string &videoUrl);
+
+private:
+	std::vector<Params> params_;
+	bool async_;
+	std::string registerUrl_;
+	std::string videoUrl_;
+};
+} // namespace Model
+} // namespace Videorecog
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_VIDEORECOG_MODEL_RECOGNIZEVIDEOCASTCREWLISTREQUEST_H_

videorecog/include/alibabacloud/videorecog/model/RecognizeVideoCastCrewListResult.h

@@ -0,0 +1,49 @@
+/*
+ * 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_VIDEORECOG_MODEL_RECOGNIZEVIDEOCASTCREWLISTRESULT_H_
+#define ALIBABACLOUD_VIDEORECOG_MODEL_RECOGNIZEVIDEOCASTCREWLISTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/videorecog/VideorecogExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Videorecog
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_VIDEORECOG_EXPORT RecognizeVideoCastCrewListResult : public ServiceResult
+			{
+			public:
+
+
+				RecognizeVideoCastCrewListResult();
+				explicit RecognizeVideoCastCrewListResult(const std::string &payload);
+				~RecognizeVideoCastCrewListResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_VIDEORECOG_MODEL_RECOGNIZEVIDEOCASTCREWLISTRESULT_H_

videorecog/include/alibabacloud/videorecog/model/SplitVideoPartsRequest.h

@@ -0,0 +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_VIDEORECOG_MODEL_SPLITVIDEOPARTSREQUEST_H_
+#define ALIBABACLOUD_VIDEORECOG_MODEL_SPLITVIDEOPARTSREQUEST_H_
+
+#include <alibabacloud/videorecog/VideorecogExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Videorecog {
+namespace Model {
+class ALIBABACLOUD_VIDEORECOG_EXPORT SplitVideoPartsRequest : public RpcServiceRequest {
+public:
+	SplitVideoPartsRequest();
+	~SplitVideoPartsRequest();
+	bool getAsync() const;
+	void setAsync(bool async);
+	std::string getVideoUrl() const;
+	void setVideoUrl(const std::string &videoUrl);
+
+private:
+	bool async_;
+	std::string videoUrl_;
+};
+} // namespace Model
+} // namespace Videorecog
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_VIDEORECOG_MODEL_SPLITVIDEOPARTSREQUEST_H_

videorecog/include/alibabacloud/videorecog/model/SplitVideoPartsResult.h

@@ -0,0 +1,65 @@
+/*
+ * 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_VIDEORECOG_MODEL_SPLITVIDEOPARTSRESULT_H_
+#define ALIBABACLOUD_VIDEORECOG_MODEL_SPLITVIDEOPARTSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/videorecog/VideorecogExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Videorecog
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_VIDEORECOG_EXPORT SplitVideoPartsResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct ElementsItem
+					{
+						float endTime;
+						float beginTime;
+						long index;
+					};
+					std::vector<ElementsItem> elements;
+				};
+
+
+				SplitVideoPartsResult();
+				explicit SplitVideoPartsResult(const std::string &payload);
+				~SplitVideoPartsResult();
+				std::string getMessage()const;
+				Data getData()const;
+				std::string getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Data data_;
+				std::string code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_VIDEORECOG_MODEL_SPLITVIDEOPARTSRESULT_H_

videorecog/include/alibabacloud/videorecog/model/UnderstandVideoContentRequest.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_VIDEORECOG_MODEL_UNDERSTANDVIDEOCONTENTREQUEST_H_
-#define ALIBABACLOUD_VIDEORECOG_MODEL_UNDERSTANDVIDEOCONTENTREQUEST_H_
-
-#include <string>
-#include <vector>
-#include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/videorecog/VideorecogExport.h>
-
-namespace AlibabaCloud
-{
-	namespace Videorecog
-	{
-		namespace Model
-		{
-			class ALIBABACLOUD_VIDEORECOG_EXPORT UnderstandVideoContentRequest : public RpcServiceRequest
-			{
-
-			public:
-				UnderstandVideoContentRequest();
-				~UnderstandVideoContentRequest();
-
-				bool getAsync()const;
-				void setAsync(bool async);
-				std::string getVideoURL()const;
-				void setVideoURL(const std::string& videoURL);
-
-            private:
-				bool async_;
-				std::string videoURL_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_VIDEORECOG_MODEL_UNDERSTANDVIDEOCONTENTREQUEST_H_
+ */
+
+#ifndef ALIBABACLOUD_VIDEORECOG_MODEL_UNDERSTANDVIDEOCONTENTREQUEST_H_
+#define ALIBABACLOUD_VIDEORECOG_MODEL_UNDERSTANDVIDEOCONTENTREQUEST_H_
+
+#include <alibabacloud/videorecog/VideorecogExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Videorecog {
+namespace Model {
+class ALIBABACLOUD_VIDEORECOG_EXPORT UnderstandVideoContentRequest : public RpcServiceRequest {
+public:
+	UnderstandVideoContentRequest();
+	~UnderstandVideoContentRequest();
+	bool getAsync() const;
+	void setAsync(bool async);
+	std::string getVideoURL() const;
+	void setVideoURL(const std::string &videoURL);
+
+private:
+	bool async_;
+	std::string videoURL_;
+};
+} // namespace Model
+} // namespace Videorecog
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_VIDEORECOG_MODEL_UNDERSTANDVIDEOCONTENTREQUEST_H_

videorecog/include/alibabacloud/videorecog/model/UnderstandVideoContentResult.h

@@ -37,8 +37,8 @@ namespace AlibabaCloud
 					struct VideoInfo
 					{
 						float fps;
-						long duration;
 						long height;
+						long duration;
 						long width;
 					};
 					std::string tagInfo;

videorecog/src/VideorecogClient.cc

@@ -159,6 +159,78 @@ VideorecogClient::GetAsyncJobResultOutcomeCallable VideorecogClient::getAsyncJob
 	return task->get_future();
 }
 
+VideorecogClient::RecognizeVideoCastCrewListOutcome VideorecogClient::recognizeVideoCastCrewList(const RecognizeVideoCastCrewListRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RecognizeVideoCastCrewListOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RecognizeVideoCastCrewListOutcome(RecognizeVideoCastCrewListResult(outcome.result()));
+	else
+		return RecognizeVideoCastCrewListOutcome(outcome.error());
+}
+
+void VideorecogClient::recognizeVideoCastCrewListAsync(const RecognizeVideoCastCrewListRequest& request, const RecognizeVideoCastCrewListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, recognizeVideoCastCrewList(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+VideorecogClient::RecognizeVideoCastCrewListOutcomeCallable VideorecogClient::recognizeVideoCastCrewListCallable(const RecognizeVideoCastCrewListRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RecognizeVideoCastCrewListOutcome()>>(
+			[this, request]()
+			{
+			return this->recognizeVideoCastCrewList(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+VideorecogClient::SplitVideoPartsOutcome VideorecogClient::splitVideoParts(const SplitVideoPartsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SplitVideoPartsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SplitVideoPartsOutcome(SplitVideoPartsResult(outcome.result()));
+	else
+		return SplitVideoPartsOutcome(outcome.error());
+}
+
+void VideorecogClient::splitVideoPartsAsync(const SplitVideoPartsRequest& request, const SplitVideoPartsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, splitVideoParts(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+VideorecogClient::SplitVideoPartsOutcomeCallable VideorecogClient::splitVideoPartsCallable(const SplitVideoPartsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SplitVideoPartsOutcome()>>(
+			[this, request]()
+			{
+			return this->splitVideoParts(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 VideorecogClient::UnderstandVideoContentOutcome VideorecogClient::understandVideoContent(const UnderstandVideoContentRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

videorecog/src/model/DetectVideoShotRequest.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/videorecog/model/DetectVideoShotRequest.h>
-
-using AlibabaCloud::Videorecog::Model::DetectVideoShotRequest;
-
-DetectVideoShotRequest::DetectVideoShotRequest() :
-	RpcServiceRequest("videorecog", "2020-03-20", "DetectVideoShot")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DetectVideoShotRequest::~DetectVideoShotRequest()
-{}
-
-bool DetectVideoShotRequest::getAsync()const
-{
-	return async_;
+ */
+
+#include <alibabacloud/videorecog/model/DetectVideoShotRequest.h>
+
+using AlibabaCloud::Videorecog::Model::DetectVideoShotRequest;
+
+DetectVideoShotRequest::DetectVideoShotRequest()
+    : RpcServiceRequest("videorecog", "2020-03-20", "DetectVideoShot") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DetectVideoShotRequest::~DetectVideoShotRequest() {}
+
+bool DetectVideoShotRequest::getAsync() const {
+  return async_;
 }
 
-void DetectVideoShotRequest::setAsync(bool async)
-{
-	async_ = async;
-	setBodyParameter("Async", async ? "true" : "false");
+void DetectVideoShotRequest::setAsync(bool async) {
+  async_ = async;
+  setBodyParameter(std::string("Async"), async ? "true" : "false");
 }
 
-std::string DetectVideoShotRequest::getVideoUrl()const
-{
-	return videoUrl_;
+std::string DetectVideoShotRequest::getVideoUrl() const {
+  return videoUrl_;
 }
 
-void DetectVideoShotRequest::setVideoUrl(const std::string& videoUrl)
-{
-	videoUrl_ = videoUrl;
-	setBodyParameter("VideoUrl", videoUrl);
+void DetectVideoShotRequest::setVideoUrl(const std::string &videoUrl) {
+  videoUrl_ = videoUrl;
+  setBodyParameter(std::string("VideoUrl"), videoUrl);
 }
 

videorecog/src/model/GenerateVideoCoverRequest.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/videorecog/model/GenerateVideoCoverRequest.h>
-
-using AlibabaCloud::Videorecog::Model::GenerateVideoCoverRequest;
-
-GenerateVideoCoverRequest::GenerateVideoCoverRequest() :
-	RpcServiceRequest("videorecog", "2020-03-20", "GenerateVideoCover")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-GenerateVideoCoverRequest::~GenerateVideoCoverRequest()
-{}
-
-bool GenerateVideoCoverRequest::getIsGif()const
-{
-	return isGif_;
+ */
+
+#include <alibabacloud/videorecog/model/GenerateVideoCoverRequest.h>
+
+using AlibabaCloud::Videorecog::Model::GenerateVideoCoverRequest;
+
+GenerateVideoCoverRequest::GenerateVideoCoverRequest()
+    : RpcServiceRequest("videorecog", "2020-03-20", "GenerateVideoCover") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GenerateVideoCoverRequest::~GenerateVideoCoverRequest() {}
+
+bool GenerateVideoCoverRequest::getIsGif() const {
+  return isGif_;
 }
 
-void GenerateVideoCoverRequest::setIsGif(bool isGif)
-{
-	isGif_ = isGif;
-	setBodyParameter("IsGif", isGif ? "true" : "false");
+void GenerateVideoCoverRequest::setIsGif(bool isGif) {
+  isGif_ = isGif;
+  setBodyParameter(std::string("IsGif"), isGif ? "true" : "false");
 }
 
-bool GenerateVideoCoverRequest::getAsync()const
-{
-	return async_;
+bool GenerateVideoCoverRequest::getAsync() const {
+  return async_;
 }
 
-void GenerateVideoCoverRequest::setAsync(bool async)
-{
-	async_ = async;
-	setBodyParameter("Async", async ? "true" : "false");
+void GenerateVideoCoverRequest::setAsync(bool async) {
+  async_ = async;
+  setBodyParameter(std::string("Async"), async ? "true" : "false");
 }
 
-std::string GenerateVideoCoverRequest::getVideoUrl()const
-{
-	return videoUrl_;
+std::string GenerateVideoCoverRequest::getVideoUrl() const {
+  return videoUrl_;
 }
 
-void GenerateVideoCoverRequest::setVideoUrl(const std::string& videoUrl)
-{
-	videoUrl_ = videoUrl;
-	setBodyParameter("VideoUrl", videoUrl);
+void GenerateVideoCoverRequest::setVideoUrl(const std::string &videoUrl) {
+  videoUrl_ = videoUrl;
+  setBodyParameter(std::string("VideoUrl"), videoUrl);
 }
 

videorecog/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/videorecog/model/GetAsyncJobResultRequest.h>
-
-using AlibabaCloud::Videorecog::Model::GetAsyncJobResultRequest;
-
-GetAsyncJobResultRequest::GetAsyncJobResultRequest() :
-	RpcServiceRequest("videorecog", "2020-03-20", "GetAsyncJobResult")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-GetAsyncJobResultRequest::~GetAsyncJobResultRequest()
-{}
-
-std::string GetAsyncJobResultRequest::getJobId()const
-{
-	return jobId_;
+ */
+
+#include <alibabacloud/videorecog/model/GetAsyncJobResultRequest.h>
+
+using AlibabaCloud::Videorecog::Model::GetAsyncJobResultRequest;
+
+GetAsyncJobResultRequest::GetAsyncJobResultRequest()
+    : RpcServiceRequest("videorecog", "2020-03-20", "GetAsyncJobResult") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetAsyncJobResultRequest::~GetAsyncJobResultRequest() {}
+
+std::string GetAsyncJobResultRequest::getJobId() const {
+  return jobId_;
 }
 
-void GetAsyncJobResultRequest::setJobId(const std::string& jobId)
-{
-	jobId_ = jobId;
-	setBodyParameter("JobId", jobId);
+void GetAsyncJobResultRequest::setJobId(const std::string &jobId) {
+  jobId_ = jobId;
+  setBodyParameter(std::string("JobId"), jobId);
 }
 
-bool GetAsyncJobResultRequest::getAsync()const
-{
-	return async_;
+bool GetAsyncJobResultRequest::getAsync() const {
+  return async_;
 }
 
-void GetAsyncJobResultRequest::setAsync(bool async)
-{
-	async_ = async;
-	setBodyParameter("Async", async ? "true" : "false");
+void GetAsyncJobResultRequest::setAsync(bool async) {
+  async_ = async;
+  setBodyParameter(std::string("Async"), async ? "true" : "false");
 }
 

videorecog/src/model/GetAsyncJobResultResult.cc

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

videorecog/src/model/RecognizeVideoCastCrewListRequest.cc

@@ -0,0 +1,65 @@
+/*
+ * 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/videorecog/model/RecognizeVideoCastCrewListRequest.h>
+
+using AlibabaCloud::Videorecog::Model::RecognizeVideoCastCrewListRequest;
+
+RecognizeVideoCastCrewListRequest::RecognizeVideoCastCrewListRequest()
+    : RpcServiceRequest("videorecog", "2020-03-20", "RecognizeVideoCastCrewList") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+RecognizeVideoCastCrewListRequest::~RecognizeVideoCastCrewListRequest() {}
+
+std::vector<RecognizeVideoCastCrewListRequest::Params> RecognizeVideoCastCrewListRequest::getParams() const {
+  return params_;
+}
+
+void RecognizeVideoCastCrewListRequest::setParams(const std::vector<RecognizeVideoCastCrewListRequest::Params> &params) {
+  params_ = params;
+  for(int dep1 = 0; dep1 != params.size(); dep1++) {
+    setBodyParameter(std::string("Params") + "." + std::to_string(dep1 + 1) + ".Type", params[dep1].type);
+  }
+}
+
+bool RecognizeVideoCastCrewListRequest::getAsync() const {
+  return async_;
+}
+
+void RecognizeVideoCastCrewListRequest::setAsync(bool async) {
+  async_ = async;
+  setBodyParameter(std::string("Async"), async ? "true" : "false");
+}
+
+std::string RecognizeVideoCastCrewListRequest::getRegisterUrl() const {
+  return registerUrl_;
+}
+
+void RecognizeVideoCastCrewListRequest::setRegisterUrl(const std::string &registerUrl) {
+  registerUrl_ = registerUrl;
+  setBodyParameter(std::string("RegisterUrl"), registerUrl);
+}
+
+std::string RecognizeVideoCastCrewListRequest::getVideoUrl() const {
+  return videoUrl_;
+}
+
+void RecognizeVideoCastCrewListRequest::setVideoUrl(const std::string &videoUrl) {
+  videoUrl_ = videoUrl;
+  setBodyParameter(std::string("VideoUrl"), videoUrl);
+}
+

videorecog/src/model/RecognizeVideoCastCrewListResult.cc

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

videorecog/src/model/SplitVideoPartsRequest.cc

@@ -0,0 +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/videorecog/model/SplitVideoPartsRequest.h>
+
+using AlibabaCloud::Videorecog::Model::SplitVideoPartsRequest;
+
+SplitVideoPartsRequest::SplitVideoPartsRequest()
+    : RpcServiceRequest("videorecog", "2020-03-20", "SplitVideoParts") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+SplitVideoPartsRequest::~SplitVideoPartsRequest() {}
+
+bool SplitVideoPartsRequest::getAsync() const {
+  return async_;
+}
+
+void SplitVideoPartsRequest::setAsync(bool async) {
+  async_ = async;
+  setBodyParameter(std::string("Async"), async ? "true" : "false");
+}
+
+std::string SplitVideoPartsRequest::getVideoUrl() const {
+  return videoUrl_;
+}
+
+void SplitVideoPartsRequest::setVideoUrl(const std::string &videoUrl) {
+  videoUrl_ = videoUrl;
+  setBodyParameter(std::string("VideoUrl"), videoUrl);
+}
+

videorecog/src/model/SplitVideoPartsResult.cc

@@ -0,0 +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/videorecog/model/SplitVideoPartsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Videorecog;
+using namespace AlibabaCloud::Videorecog::Model;
+
+SplitVideoPartsResult::SplitVideoPartsResult() :
+	ServiceResult()
+{}
+
+SplitVideoPartsResult::SplitVideoPartsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+SplitVideoPartsResult::~SplitVideoPartsResult()
+{}
+
+void SplitVideoPartsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	auto allElementsNode = dataNode["Elements"]["elementsItem"];
+	for (auto dataNodeElementselementsItem : allElementsNode)
+	{
+		Data::ElementsItem elementsItemObject;
+		if(!dataNodeElementselementsItem["BeginTime"].isNull())
+			elementsItemObject.beginTime = std::stof(dataNodeElementselementsItem["BeginTime"].asString());
+		if(!dataNodeElementselementsItem["EndTime"].isNull())
+			elementsItemObject.endTime = std::stof(dataNodeElementselementsItem["EndTime"].asString());
+		if(!dataNodeElementselementsItem["Index"].isNull())
+			elementsItemObject.index = std::stol(dataNodeElementselementsItem["Index"].asString());
+		data_.elements.push_back(elementsItemObject);
+	}
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string SplitVideoPartsResult::getMessage()const
+{
+	return message_;
+}
+
+SplitVideoPartsResult::Data SplitVideoPartsResult::getData()const
+{
+	return data_;
+}
+
+std::string SplitVideoPartsResult::getCode()const
+{
+	return code_;
+}
+

videorecog/src/model/UnderstandVideoContentRequest.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/videorecog/model/UnderstandVideoContentRequest.h>
-
-using AlibabaCloud::Videorecog::Model::UnderstandVideoContentRequest;
-
-UnderstandVideoContentRequest::UnderstandVideoContentRequest() :
-	RpcServiceRequest("videorecog", "2020-03-20", "UnderstandVideoContent")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-UnderstandVideoContentRequest::~UnderstandVideoContentRequest()
-{}
-
-bool UnderstandVideoContentRequest::getAsync()const
-{
-	return async_;
+ */
+
+#include <alibabacloud/videorecog/model/UnderstandVideoContentRequest.h>
+
+using AlibabaCloud::Videorecog::Model::UnderstandVideoContentRequest;
+
+UnderstandVideoContentRequest::UnderstandVideoContentRequest()
+    : RpcServiceRequest("videorecog", "2020-03-20", "UnderstandVideoContent") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+UnderstandVideoContentRequest::~UnderstandVideoContentRequest() {}
+
+bool UnderstandVideoContentRequest::getAsync() const {
+  return async_;
 }
 
-void UnderstandVideoContentRequest::setAsync(bool async)
-{
-	async_ = async;
-	setBodyParameter("Async", async ? "true" : "false");
+void UnderstandVideoContentRequest::setAsync(bool async) {
+  async_ = async;
+  setBodyParameter(std::string("Async"), async ? "true" : "false");
 }
 
-std::string UnderstandVideoContentRequest::getVideoURL()const
-{
-	return videoURL_;
+std::string UnderstandVideoContentRequest::getVideoURL() const {
+  return videoURL_;
 }
 
-void UnderstandVideoContentRequest::setVideoURL(const std::string& videoURL)
-{
-	videoURL_ = videoURL;
-	setBodyParameter("VideoURL", videoURL);
+void UnderstandVideoContentRequest::setVideoURL(const std::string &videoURL) {
+  videoURL_ = videoURL;
+  setBodyParameter(std::string("VideoURL"), videoURL);
 }
 

videorecog/src/model/UnderstandVideoContentResult.cc

@@ -43,18 +43,18 @@ void UnderstandVideoContentResult::parse(const std::string &payload)
 	if(!dataNode["TagInfo"].isNull())
 		data_.tagInfo = dataNode["TagInfo"].asString();
 	auto videoInfoNode = dataNode["VideoInfo"];
-	if(!videoInfoNode["Fps"].isNull())
-		data_.videoInfo.fps = std::stof(videoInfoNode["Fps"].asString());
-	if(!videoInfoNode["Duration"].isNull())
-		data_.videoInfo.duration = std::stol(videoInfoNode["Duration"].asString());
-	if(!videoInfoNode["Height"].isNull())
-		data_.videoInfo.height = std::stol(videoInfoNode["Height"].asString());
 	if(!videoInfoNode["Width"].isNull())
 		data_.videoInfo.width = std::stol(videoInfoNode["Width"].asString());
-	if(!value["Message"].isNull())
-		message_ = value["Message"].asString();
+	if(!videoInfoNode["Height"].isNull())
+		data_.videoInfo.height = std::stol(videoInfoNode["Height"].asString());
+	if(!videoInfoNode["Duration"].isNull())
+		data_.videoInfo.duration = std::stol(videoInfoNode["Duration"].asString());
+	if(!videoInfoNode["Fps"].isNull())
+		data_.videoInfo.fps = std::stof(videoInfoNode["Fps"].asString());
 	if(!value["Code"].isNull())
 		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
 
 }