Update RecognizeVideoCharacter.

VERSION

@@ -1 +1 @@
-1.36.1450
+1.36.1451

ocr/CMakeLists.txt

@@ -43,12 +43,8 @@ set(ocr_public_header_model
 	include/alibabacloud/ocr/model/RecognizeDrivingLicenseResult.h
 	include/alibabacloud/ocr/model/RecognizeIdentityCardRequest.h
 	include/alibabacloud/ocr/model/RecognizeIdentityCardResult.h
-	include/alibabacloud/ocr/model/RecognizeIndonesiaIdentityCardRequest.h
-	include/alibabacloud/ocr/model/RecognizeIndonesiaIdentityCardResult.h
 	include/alibabacloud/ocr/model/RecognizeLicensePlateRequest.h
 	include/alibabacloud/ocr/model/RecognizeLicensePlateResult.h
-	include/alibabacloud/ocr/model/RecognizeMalaysiaIdentityCardRequest.h
-	include/alibabacloud/ocr/model/RecognizeMalaysiaIdentityCardResult.h
 	include/alibabacloud/ocr/model/RecognizePassportMRZRequest.h
 	include/alibabacloud/ocr/model/RecognizePassportMRZResult.h
 	include/alibabacloud/ocr/model/RecognizePdfRequest.h
@@ -59,8 +55,6 @@ set(ocr_public_header_model
 	include/alibabacloud/ocr/model/RecognizeQrCodeResult.h
 	include/alibabacloud/ocr/model/RecognizeQuotaInvoiceRequest.h
 	include/alibabacloud/ocr/model/RecognizeQuotaInvoiceResult.h
-	include/alibabacloud/ocr/model/RecognizeRussiaIdentityCardRequest.h
-	include/alibabacloud/ocr/model/RecognizeRussiaIdentityCardResult.h
 	include/alibabacloud/ocr/model/RecognizeStampRequest.h
 	include/alibabacloud/ocr/model/RecognizeStampResult.h
 	include/alibabacloud/ocr/model/RecognizeTableRequest.h
@@ -73,22 +67,14 @@ set(ocr_public_header_model
 	include/alibabacloud/ocr/model/RecognizeTicketInvoiceResult.h
 	include/alibabacloud/ocr/model/RecognizeTrainTicketRequest.h
 	include/alibabacloud/ocr/model/RecognizeTrainTicketResult.h
-	include/alibabacloud/ocr/model/RecognizeTurkeyIdentityCardRequest.h
-	include/alibabacloud/ocr/model/RecognizeTurkeyIdentityCardResult.h
-	include/alibabacloud/ocr/model/RecognizeUkraineIdentityCardRequest.h
-	include/alibabacloud/ocr/model/RecognizeUkraineIdentityCardResult.h
 	include/alibabacloud/ocr/model/RecognizeVATInvoiceRequest.h
 	include/alibabacloud/ocr/model/RecognizeVATInvoiceResult.h
 	include/alibabacloud/ocr/model/RecognizeVINCodeRequest.h
 	include/alibabacloud/ocr/model/RecognizeVINCodeResult.h
 	include/alibabacloud/ocr/model/RecognizeVerificationcodeRequest.h
 	include/alibabacloud/ocr/model/RecognizeVerificationcodeResult.h
-	include/alibabacloud/ocr/model/RecognizeVideoCastCrewListRequest.h
-	include/alibabacloud/ocr/model/RecognizeVideoCastCrewListResult.h
 	include/alibabacloud/ocr/model/RecognizeVideoCharacterRequest.h
 	include/alibabacloud/ocr/model/RecognizeVideoCharacterResult.h
-	include/alibabacloud/ocr/model/RecognizeVietnamIdentityCardRequest.h
-	include/alibabacloud/ocr/model/RecognizeVietnamIdentityCardResult.h
 	include/alibabacloud/ocr/model/TrimDocumentRequest.h
 	include/alibabacloud/ocr/model/TrimDocumentResult.h )
 
@@ -116,12 +102,8 @@ set(ocr_src
 	src/model/RecognizeDrivingLicenseResult.cc
 	src/model/RecognizeIdentityCardRequest.cc
 	src/model/RecognizeIdentityCardResult.cc
-	src/model/RecognizeIndonesiaIdentityCardRequest.cc
-	src/model/RecognizeIndonesiaIdentityCardResult.cc
 	src/model/RecognizeLicensePlateRequest.cc
 	src/model/RecognizeLicensePlateResult.cc
-	src/model/RecognizeMalaysiaIdentityCardRequest.cc
-	src/model/RecognizeMalaysiaIdentityCardResult.cc
 	src/model/RecognizePassportMRZRequest.cc
 	src/model/RecognizePassportMRZResult.cc
 	src/model/RecognizePdfRequest.cc
@@ -132,8 +114,6 @@ set(ocr_src
 	src/model/RecognizeQrCodeResult.cc
 	src/model/RecognizeQuotaInvoiceRequest.cc
 	src/model/RecognizeQuotaInvoiceResult.cc
-	src/model/RecognizeRussiaIdentityCardRequest.cc
-	src/model/RecognizeRussiaIdentityCardResult.cc
 	src/model/RecognizeStampRequest.cc
 	src/model/RecognizeStampResult.cc
 	src/model/RecognizeTableRequest.cc
@@ -146,22 +126,14 @@ set(ocr_src
 	src/model/RecognizeTicketInvoiceResult.cc
 	src/model/RecognizeTrainTicketRequest.cc
 	src/model/RecognizeTrainTicketResult.cc
-	src/model/RecognizeTurkeyIdentityCardRequest.cc
-	src/model/RecognizeTurkeyIdentityCardResult.cc
-	src/model/RecognizeUkraineIdentityCardRequest.cc
-	src/model/RecognizeUkraineIdentityCardResult.cc
 	src/model/RecognizeVATInvoiceRequest.cc
 	src/model/RecognizeVATInvoiceResult.cc
 	src/model/RecognizeVINCodeRequest.cc
 	src/model/RecognizeVINCodeResult.cc
 	src/model/RecognizeVerificationcodeRequest.cc
 	src/model/RecognizeVerificationcodeResult.cc
-	src/model/RecognizeVideoCastCrewListRequest.cc
-	src/model/RecognizeVideoCastCrewListResult.cc
 	src/model/RecognizeVideoCharacterRequest.cc
 	src/model/RecognizeVideoCharacterResult.cc
-	src/model/RecognizeVietnamIdentityCardRequest.cc
-	src/model/RecognizeVietnamIdentityCardResult.cc
 	src/model/TrimDocumentRequest.cc
 	src/model/TrimDocumentResult.cc )
 

ocr/include/alibabacloud/ocr/OcrClient.h

@@ -44,12 +44,8 @@
 #include "model/RecognizeDrivingLicenseResult.h"
 #include "model/RecognizeIdentityCardRequest.h"
 #include "model/RecognizeIdentityCardResult.h"
-#include "model/RecognizeIndonesiaIdentityCardRequest.h"
-#include "model/RecognizeIndonesiaIdentityCardResult.h"
 #include "model/RecognizeLicensePlateRequest.h"
 #include "model/RecognizeLicensePlateResult.h"
-#include "model/RecognizeMalaysiaIdentityCardRequest.h"
-#include "model/RecognizeMalaysiaIdentityCardResult.h"
 #include "model/RecognizePassportMRZRequest.h"
 #include "model/RecognizePassportMRZResult.h"
 #include "model/RecognizePdfRequest.h"
@@ -60,8 +56,6 @@
 #include "model/RecognizeQrCodeResult.h"
 #include "model/RecognizeQuotaInvoiceRequest.h"
 #include "model/RecognizeQuotaInvoiceResult.h"
-#include "model/RecognizeRussiaIdentityCardRequest.h"
-#include "model/RecognizeRussiaIdentityCardResult.h"
 #include "model/RecognizeStampRequest.h"
 #include "model/RecognizeStampResult.h"
 #include "model/RecognizeTableRequest.h"
@@ -74,22 +68,14 @@
 #include "model/RecognizeTicketInvoiceResult.h"
 #include "model/RecognizeTrainTicketRequest.h"
 #include "model/RecognizeTrainTicketResult.h"
-#include "model/RecognizeTurkeyIdentityCardRequest.h"
-#include "model/RecognizeTurkeyIdentityCardResult.h"
-#include "model/RecognizeUkraineIdentityCardRequest.h"
-#include "model/RecognizeUkraineIdentityCardResult.h"
 #include "model/RecognizeVATInvoiceRequest.h"
 #include "model/RecognizeVATInvoiceResult.h"
 #include "model/RecognizeVINCodeRequest.h"
 #include "model/RecognizeVINCodeResult.h"
 #include "model/RecognizeVerificationcodeRequest.h"
 #include "model/RecognizeVerificationcodeResult.h"
-#include "model/RecognizeVideoCastCrewListRequest.h"
-#include "model/RecognizeVideoCastCrewListResult.h"
 #include "model/RecognizeVideoCharacterRequest.h"
 #include "model/RecognizeVideoCharacterResult.h"
-#include "model/RecognizeVietnamIdentityCardRequest.h"
-#include "model/RecognizeVietnamIdentityCardResult.h"
 #include "model/TrimDocumentRequest.h"
 #include "model/TrimDocumentResult.h"
 
@@ -134,15 +120,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::RecognizeIdentityCardResult> RecognizeIdentityCardOutcome;
 			typedef std::future<RecognizeIdentityCardOutcome> RecognizeIdentityCardOutcomeCallable;
 			typedef std::function<void(const OcrClient*, const Model::RecognizeIdentityCardRequest&, const RecognizeIdentityCardOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeIdentityCardAsyncHandler;
-			typedef Outcome<Error, Model::RecognizeIndonesiaIdentityCardResult> RecognizeIndonesiaIdentityCardOutcome;
-			typedef std::future<RecognizeIndonesiaIdentityCardOutcome> RecognizeIndonesiaIdentityCardOutcomeCallable;
-			typedef std::function<void(const OcrClient*, const Model::RecognizeIndonesiaIdentityCardRequest&, const RecognizeIndonesiaIdentityCardOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeIndonesiaIdentityCardAsyncHandler;
 			typedef Outcome<Error, Model::RecognizeLicensePlateResult> RecognizeLicensePlateOutcome;
 			typedef std::future<RecognizeLicensePlateOutcome> RecognizeLicensePlateOutcomeCallable;
 			typedef std::function<void(const OcrClient*, const Model::RecognizeLicensePlateRequest&, const RecognizeLicensePlateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeLicensePlateAsyncHandler;
-			typedef Outcome<Error, Model::RecognizeMalaysiaIdentityCardResult> RecognizeMalaysiaIdentityCardOutcome;
-			typedef std::future<RecognizeMalaysiaIdentityCardOutcome> RecognizeMalaysiaIdentityCardOutcomeCallable;
-			typedef std::function<void(const OcrClient*, const Model::RecognizeMalaysiaIdentityCardRequest&, const RecognizeMalaysiaIdentityCardOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeMalaysiaIdentityCardAsyncHandler;
 			typedef Outcome<Error, Model::RecognizePassportMRZResult> RecognizePassportMRZOutcome;
 			typedef std::future<RecognizePassportMRZOutcome> RecognizePassportMRZOutcomeCallable;
 			typedef std::function<void(const OcrClient*, const Model::RecognizePassportMRZRequest&, const RecognizePassportMRZOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizePassportMRZAsyncHandler;
@@ -158,9 +138,6 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::RecognizeQuotaInvoiceResult> RecognizeQuotaInvoiceOutcome;
 			typedef std::future<RecognizeQuotaInvoiceOutcome> RecognizeQuotaInvoiceOutcomeCallable;
 			typedef std::function<void(const OcrClient*, const Model::RecognizeQuotaInvoiceRequest&, const RecognizeQuotaInvoiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeQuotaInvoiceAsyncHandler;
-			typedef Outcome<Error, Model::RecognizeRussiaIdentityCardResult> RecognizeRussiaIdentityCardOutcome;
-			typedef std::future<RecognizeRussiaIdentityCardOutcome> RecognizeRussiaIdentityCardOutcomeCallable;
-			typedef std::function<void(const OcrClient*, const Model::RecognizeRussiaIdentityCardRequest&, const RecognizeRussiaIdentityCardOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeRussiaIdentityCardAsyncHandler;
 			typedef Outcome<Error, Model::RecognizeStampResult> RecognizeStampOutcome;
 			typedef std::future<RecognizeStampOutcome> RecognizeStampOutcomeCallable;
 			typedef std::function<void(const OcrClient*, const Model::RecognizeStampRequest&, const RecognizeStampOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeStampAsyncHandler;
@@ -179,12 +156,6 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::RecognizeTrainTicketResult> RecognizeTrainTicketOutcome;
 			typedef std::future<RecognizeTrainTicketOutcome> RecognizeTrainTicketOutcomeCallable;
 			typedef std::function<void(const OcrClient*, const Model::RecognizeTrainTicketRequest&, const RecognizeTrainTicketOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeTrainTicketAsyncHandler;
-			typedef Outcome<Error, Model::RecognizeTurkeyIdentityCardResult> RecognizeTurkeyIdentityCardOutcome;
-			typedef std::future<RecognizeTurkeyIdentityCardOutcome> RecognizeTurkeyIdentityCardOutcomeCallable;
-			typedef std::function<void(const OcrClient*, const Model::RecognizeTurkeyIdentityCardRequest&, const RecognizeTurkeyIdentityCardOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeTurkeyIdentityCardAsyncHandler;
-			typedef Outcome<Error, Model::RecognizeUkraineIdentityCardResult> RecognizeUkraineIdentityCardOutcome;
-			typedef std::future<RecognizeUkraineIdentityCardOutcome> RecognizeUkraineIdentityCardOutcomeCallable;
-			typedef std::function<void(const OcrClient*, const Model::RecognizeUkraineIdentityCardRequest&, const RecognizeUkraineIdentityCardOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeUkraineIdentityCardAsyncHandler;
 			typedef Outcome<Error, Model::RecognizeVATInvoiceResult> RecognizeVATInvoiceOutcome;
 			typedef std::future<RecognizeVATInvoiceOutcome> RecognizeVATInvoiceOutcomeCallable;
 			typedef std::function<void(const OcrClient*, const Model::RecognizeVATInvoiceRequest&, const RecognizeVATInvoiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeVATInvoiceAsyncHandler;
@@ -194,15 +165,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::RecognizeVerificationcodeResult> RecognizeVerificationcodeOutcome;
 			typedef std::future<RecognizeVerificationcodeOutcome> RecognizeVerificationcodeOutcomeCallable;
 			typedef std::function<void(const OcrClient*, const Model::RecognizeVerificationcodeRequest&, const RecognizeVerificationcodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeVerificationcodeAsyncHandler;
-			typedef Outcome<Error, Model::RecognizeVideoCastCrewListResult> RecognizeVideoCastCrewListOutcome;
-			typedef std::future<RecognizeVideoCastCrewListOutcome> RecognizeVideoCastCrewListOutcomeCallable;
-			typedef std::function<void(const OcrClient*, const Model::RecognizeVideoCastCrewListRequest&, const RecognizeVideoCastCrewListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeVideoCastCrewListAsyncHandler;
 			typedef Outcome<Error, Model::RecognizeVideoCharacterResult> RecognizeVideoCharacterOutcome;
 			typedef std::future<RecognizeVideoCharacterOutcome> RecognizeVideoCharacterOutcomeCallable;
 			typedef std::function<void(const OcrClient*, const Model::RecognizeVideoCharacterRequest&, const RecognizeVideoCharacterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeVideoCharacterAsyncHandler;
-			typedef Outcome<Error, Model::RecognizeVietnamIdentityCardResult> RecognizeVietnamIdentityCardOutcome;
-			typedef std::future<RecognizeVietnamIdentityCardOutcome> RecognizeVietnamIdentityCardOutcomeCallable;
-			typedef std::function<void(const OcrClient*, const Model::RecognizeVietnamIdentityCardRequest&, const RecognizeVietnamIdentityCardOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeVietnamIdentityCardAsyncHandler;
 			typedef Outcome<Error, Model::TrimDocumentResult> TrimDocumentOutcome;
 			typedef std::future<TrimDocumentOutcome> TrimDocumentOutcomeCallable;
 			typedef std::function<void(const OcrClient*, const Model::TrimDocumentRequest&, const TrimDocumentOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TrimDocumentAsyncHandler;
@@ -244,15 +209,9 @@ namespace AlibabaCloud
 			RecognizeIdentityCardOutcome recognizeIdentityCard(const Model::RecognizeIdentityCardRequest &request)const;
 			void recognizeIdentityCardAsync(const Model::RecognizeIdentityCardRequest& request, const RecognizeIdentityCardAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			RecognizeIdentityCardOutcomeCallable recognizeIdentityCardCallable(const Model::RecognizeIdentityCardRequest& request) const;
-			RecognizeIndonesiaIdentityCardOutcome recognizeIndonesiaIdentityCard(const Model::RecognizeIndonesiaIdentityCardRequest &request)const;
-			void recognizeIndonesiaIdentityCardAsync(const Model::RecognizeIndonesiaIdentityCardRequest& request, const RecognizeIndonesiaIdentityCardAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			RecognizeIndonesiaIdentityCardOutcomeCallable recognizeIndonesiaIdentityCardCallable(const Model::RecognizeIndonesiaIdentityCardRequest& request) const;
 			RecognizeLicensePlateOutcome recognizeLicensePlate(const Model::RecognizeLicensePlateRequest &request)const;
 			void recognizeLicensePlateAsync(const Model::RecognizeLicensePlateRequest& request, const RecognizeLicensePlateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			RecognizeLicensePlateOutcomeCallable recognizeLicensePlateCallable(const Model::RecognizeLicensePlateRequest& request) const;
-			RecognizeMalaysiaIdentityCardOutcome recognizeMalaysiaIdentityCard(const Model::RecognizeMalaysiaIdentityCardRequest &request)const;
-			void recognizeMalaysiaIdentityCardAsync(const Model::RecognizeMalaysiaIdentityCardRequest& request, const RecognizeMalaysiaIdentityCardAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			RecognizeMalaysiaIdentityCardOutcomeCallable recognizeMalaysiaIdentityCardCallable(const Model::RecognizeMalaysiaIdentityCardRequest& request) const;
 			RecognizePassportMRZOutcome recognizePassportMRZ(const Model::RecognizePassportMRZRequest &request)const;
 			void recognizePassportMRZAsync(const Model::RecognizePassportMRZRequest& request, const RecognizePassportMRZAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			RecognizePassportMRZOutcomeCallable recognizePassportMRZCallable(const Model::RecognizePassportMRZRequest& request) const;
@@ -268,9 +227,6 @@ namespace AlibabaCloud
 			RecognizeQuotaInvoiceOutcome recognizeQuotaInvoice(const Model::RecognizeQuotaInvoiceRequest &request)const;
 			void recognizeQuotaInvoiceAsync(const Model::RecognizeQuotaInvoiceRequest& request, const RecognizeQuotaInvoiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			RecognizeQuotaInvoiceOutcomeCallable recognizeQuotaInvoiceCallable(const Model::RecognizeQuotaInvoiceRequest& request) const;
-			RecognizeRussiaIdentityCardOutcome recognizeRussiaIdentityCard(const Model::RecognizeRussiaIdentityCardRequest &request)const;
-			void recognizeRussiaIdentityCardAsync(const Model::RecognizeRussiaIdentityCardRequest& request, const RecognizeRussiaIdentityCardAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			RecognizeRussiaIdentityCardOutcomeCallable recognizeRussiaIdentityCardCallable(const Model::RecognizeRussiaIdentityCardRequest& request) const;
 			RecognizeStampOutcome recognizeStamp(const Model::RecognizeStampRequest &request)const;
 			void recognizeStampAsync(const Model::RecognizeStampRequest& request, const RecognizeStampAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			RecognizeStampOutcomeCallable recognizeStampCallable(const Model::RecognizeStampRequest& request) const;
@@ -289,12 +245,6 @@ namespace AlibabaCloud
 			RecognizeTrainTicketOutcome recognizeTrainTicket(const Model::RecognizeTrainTicketRequest &request)const;
 			void recognizeTrainTicketAsync(const Model::RecognizeTrainTicketRequest& request, const RecognizeTrainTicketAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			RecognizeTrainTicketOutcomeCallable recognizeTrainTicketCallable(const Model::RecognizeTrainTicketRequest& request) const;
-			RecognizeTurkeyIdentityCardOutcome recognizeTurkeyIdentityCard(const Model::RecognizeTurkeyIdentityCardRequest &request)const;
-			void recognizeTurkeyIdentityCardAsync(const Model::RecognizeTurkeyIdentityCardRequest& request, const RecognizeTurkeyIdentityCardAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			RecognizeTurkeyIdentityCardOutcomeCallable recognizeTurkeyIdentityCardCallable(const Model::RecognizeTurkeyIdentityCardRequest& request) const;
-			RecognizeUkraineIdentityCardOutcome recognizeUkraineIdentityCard(const Model::RecognizeUkraineIdentityCardRequest &request)const;
-			void recognizeUkraineIdentityCardAsync(const Model::RecognizeUkraineIdentityCardRequest& request, const RecognizeUkraineIdentityCardAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			RecognizeUkraineIdentityCardOutcomeCallable recognizeUkraineIdentityCardCallable(const Model::RecognizeUkraineIdentityCardRequest& request) const;
 			RecognizeVATInvoiceOutcome recognizeVATInvoice(const Model::RecognizeVATInvoiceRequest &request)const;
 			void recognizeVATInvoiceAsync(const Model::RecognizeVATInvoiceRequest& request, const RecognizeVATInvoiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			RecognizeVATInvoiceOutcomeCallable recognizeVATInvoiceCallable(const Model::RecognizeVATInvoiceRequest& request) const;
@@ -304,15 +254,9 @@ namespace AlibabaCloud
 			RecognizeVerificationcodeOutcome recognizeVerificationcode(const Model::RecognizeVerificationcodeRequest &request)const;
 			void recognizeVerificationcodeAsync(const Model::RecognizeVerificationcodeRequest& request, const RecognizeVerificationcodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			RecognizeVerificationcodeOutcomeCallable recognizeVerificationcodeCallable(const Model::RecognizeVerificationcodeRequest& 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;
 			RecognizeVideoCharacterOutcome recognizeVideoCharacter(const Model::RecognizeVideoCharacterRequest &request)const;
 			void recognizeVideoCharacterAsync(const Model::RecognizeVideoCharacterRequest& request, const RecognizeVideoCharacterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			RecognizeVideoCharacterOutcomeCallable recognizeVideoCharacterCallable(const Model::RecognizeVideoCharacterRequest& request) const;
-			RecognizeVietnamIdentityCardOutcome recognizeVietnamIdentityCard(const Model::RecognizeVietnamIdentityCardRequest &request)const;
-			void recognizeVietnamIdentityCardAsync(const Model::RecognizeVietnamIdentityCardRequest& request, const RecognizeVietnamIdentityCardAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			RecognizeVietnamIdentityCardOutcomeCallable recognizeVietnamIdentityCardCallable(const Model::RecognizeVietnamIdentityCardRequest& request) const;
 			TrimDocumentOutcome trimDocument(const Model::TrimDocumentRequest &request)const;
 			void trimDocumentAsync(const Model::TrimDocumentRequest& request, const TrimDocumentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			TrimDocumentOutcomeCallable trimDocumentCallable(const Model::TrimDocumentRequest& request) const;

ocr/include/alibabacloud/ocr/model/RecognizeIndonesiaIdentityCardRequest.h

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

ocr/include/alibabacloud/ocr/model/RecognizeIndonesiaIdentityCardResult.h

@@ -1,322 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEINDONESIAIDENTITYCARDRESULT_H_
-#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEINDONESIAIDENTITYCARDRESULT_H_
-
-#include <string>
-#include <vector>
-#include <utility>
-#include <alibabacloud/core/ServiceResult.h>
-#include <alibabacloud/ocr/OcrExport.h>
-
-namespace AlibabaCloud
-{
-	namespace Ocr
-	{
-		namespace Model
-		{
-			class ALIBABACLOUD_OCR_EXPORT RecognizeIndonesiaIdentityCardResult : public ServiceResult
-			{
-			public:
-				struct Data
-				{
-					struct AddressFirstLine
-					{
-						struct KeyPointsItem
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem> keyPoints;
-						std::string text;
-					};
-					struct AddressSecondLine
-					{
-						struct KeyPointsItem2
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem2> keyPoints1;
-						std::string text;
-					};
-					struct AddressThirdLine
-					{
-						struct KeyPointsItem4
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem4> keyPoints3;
-						std::string text;
-					};
-					struct AddressFourthLine
-					{
-						struct KeyPointsItem6
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem6> keyPoints5;
-						std::string text;
-					};
-					struct AddressFifthLine
-					{
-						struct KeyPointsItem8
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::string text;
-						std::vector<KeyPointsItem8> keyPoints7;
-					};
-					struct BirthDate
-					{
-						struct KeyPointsItem10
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::string text;
-						std::vector<KeyPointsItem10> keyPoints9;
-					};
-					struct BirthPlace
-					{
-						struct KeyPointsItem12
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::vector<KeyPointsItem12> keyPoints11;
-						std::string text;
-					};
-					struct CardBox
-					{
-						struct KeyPointsItem14
-						{
-							float x;
-							float y;
-						};
-						std::vector<KeyPointsItem14> keyPoints13;
-						std::string score;
-						std::string text;
-					};
-					struct ExpiryDate
-					{
-						struct KeyPointsItem16
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::vector<KeyPointsItem16> keyPoints15;
-						std::string text;
-					};
-					struct Gender
-					{
-						struct KeyPointsItem18
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::string text;
-						std::vector<KeyPointsItem18> keyPoints17;
-					};
-					struct Height
-					{
-						struct KeyPointsItem20
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::string text;
-						std::vector<KeyPointsItem20> keyPoints19;
-					};
-					struct IdNumber
-					{
-						struct KeyPointsItem22
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::vector<KeyPointsItem22> keyPoints21;
-						std::string text;
-					};
-					struct LicenseNumber
-					{
-						struct KeyPointsItem24
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::vector<KeyPointsItem24> keyPoints23;
-						std::string text;
-					};
-					struct MaritalStatus
-					{
-						struct KeyPointsItem26
-						{
-							float x;
-							float y;
-						};
-						std::vector<KeyPointsItem26> keyPoints25;
-						std::string score;
-						std::string text;
-					};
-					struct NameFirstLine
-					{
-						struct KeyPointsItem28
-						{
-							float x;
-							float y;
-						};
-						std::vector<KeyPointsItem28> keyPoints27;
-						std::string score;
-						std::string text;
-					};
-					struct NameSecondLine
-					{
-						struct KeyPointsItem30
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::string text;
-						std::vector<KeyPointsItem30> keyPoints29;
-					};
-					struct Nationality
-					{
-						struct KeyPointsItem32
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::vector<KeyPointsItem32> keyPoints31;
-						std::string text;
-					};
-					struct Occupation
-					{
-						struct KeyPointsItem34
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::vector<KeyPointsItem34> keyPoints33;
-						std::string text;
-					};
-					struct PortraitBox
-					{
-						struct KeyPointsItem36
-						{
-							float x;
-							float y;
-						};
-						std::vector<KeyPointsItem36> keyPoints35;
-						std::string score;
-						std::string text;
-					};
-					struct Province
-					{
-						struct KeyPointsItem38
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::vector<KeyPointsItem38> keyPoints37;
-						std::string text;
-					};
-					struct Religion
-					{
-						struct KeyPointsItem40
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::string text;
-						std::vector<KeyPointsItem40> keyPoints39;
-					};
-					struct Sex
-					{
-						struct KeyPointsItem42
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::vector<KeyPointsItem42> keyPoints41;
-						std::string text;
-					};
-					ExpiryDate expiryDate;
-					BirthPlace birthPlace;
-					LicenseNumber licenseNumber;
-					IdNumber idNumber;
-					CardBox cardBox;
-					Sex sex;
-					NameFirstLine nameFirstLine;
-					Religion religion;
-					Gender gender;
-					PortraitBox portraitBox;
-					Nationality nationality;
-					Province province;
-					MaritalStatus maritalStatus;
-					Occupation occupation;
-					AddressThirdLine addressThirdLine;
-					AddressFourthLine addressFourthLine;
-					AddressFirstLine addressFirstLine;
-					Height height;
-					NameSecondLine nameSecondLine;
-					AddressSecondLine addressSecondLine;
-					AddressFifthLine addressFifthLine;
-					BirthDate birthDate;
-				};
-
-
-				RecognizeIndonesiaIdentityCardResult();
-				explicit RecognizeIndonesiaIdentityCardResult(const std::string &payload);
-				~RecognizeIndonesiaIdentityCardResult();
-				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_OCR_MODEL_RECOGNIZEINDONESIAIDENTITYCARDRESULT_H_

ocr/include/alibabacloud/ocr/model/RecognizeMalaysiaIdentityCardRequest.h

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

ocr/include/alibabacloud/ocr/model/RecognizeMalaysiaIdentityCardResult.h

@@ -1,238 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEMALAYSIAIDENTITYCARDRESULT_H_
-#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEMALAYSIAIDENTITYCARDRESULT_H_
-
-#include <string>
-#include <vector>
-#include <utility>
-#include <alibabacloud/core/ServiceResult.h>
-#include <alibabacloud/ocr/OcrExport.h>
-
-namespace AlibabaCloud
-{
-	namespace Ocr
-	{
-		namespace Model
-		{
-			class ALIBABACLOUD_OCR_EXPORT RecognizeMalaysiaIdentityCardResult : public ServiceResult
-			{
-			public:
-				struct Data
-				{
-					struct AddressFirstLine
-					{
-						struct KeyPointsItem
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem> keyPoints;
-						std::string text;
-					};
-					struct AddressSecondLine
-					{
-						struct KeyPointsItem2
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem2> keyPoints1;
-						std::string text;
-					};
-					struct AddressThirdLine
-					{
-						struct KeyPointsItem4
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem4> keyPoints3;
-						std::string text;
-					};
-					struct AddressFourthLine
-					{
-						struct KeyPointsItem6
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem6> keyPoints5;
-						std::string text;
-					};
-					struct AddressFifthLine
-					{
-						struct KeyPointsItem8
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::string text;
-						std::vector<KeyPointsItem8> keyPoints7;
-					};
-					struct CardBox
-					{
-						struct KeyPointsItem10
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::string text;
-						std::vector<KeyPointsItem10> keyPoints9;
-					};
-					struct DriveClass
-					{
-						struct KeyPointsItem12
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::vector<KeyPointsItem12> keyPoints11;
-						std::string text;
-					};
-					struct ExpiryDate
-					{
-						struct KeyPointsItem14
-						{
-							float x;
-							float y;
-						};
-						std::vector<KeyPointsItem14> keyPoints13;
-						std::string score;
-						std::string text;
-					};
-					struct IdNumber
-					{
-						struct KeyPointsItem16
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::vector<KeyPointsItem16> keyPoints15;
-						std::string text;
-					};
-					struct IssueDate
-					{
-						struct KeyPointsItem18
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::string text;
-						std::vector<KeyPointsItem18> keyPoints17;
-					};
-					struct NameFirstLine
-					{
-						struct KeyPointsItem20
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::string text;
-						std::vector<KeyPointsItem20> keyPoints19;
-					};
-					struct NameSecondLine
-					{
-						struct KeyPointsItem22
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::vector<KeyPointsItem22> keyPoints21;
-						std::string text;
-					};
-					struct Nationality
-					{
-						struct KeyPointsItem24
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::vector<KeyPointsItem24> keyPoints23;
-						std::string text;
-					};
-					struct PortraitBox
-					{
-						struct KeyPointsItem26
-						{
-							float x;
-							float y;
-						};
-						std::vector<KeyPointsItem26> keyPoints25;
-						std::string score;
-						std::string text;
-					};
-					struct Sex
-					{
-						struct KeyPointsItem28
-						{
-							float x;
-							float y;
-						};
-						std::vector<KeyPointsItem28> keyPoints27;
-						std::string score;
-						std::string text;
-					};
-					ExpiryDate expiryDate;
-					IdNumber idNumber;
-					CardBox cardBox;
-					Sex sex;
-					NameFirstLine nameFirstLine;
-					IssueDate issueDate;
-					PortraitBox portraitBox;
-					Nationality nationality;
-					AddressThirdLine addressThirdLine;
-					AddressFourthLine addressFourthLine;
-					AddressFirstLine addressFirstLine;
-					NameSecondLine nameSecondLine;
-					DriveClass driveClass;
-					AddressSecondLine addressSecondLine;
-					AddressFifthLine addressFifthLine;
-				};
-
-
-				RecognizeMalaysiaIdentityCardResult();
-				explicit RecognizeMalaysiaIdentityCardResult(const std::string &payload);
-				~RecognizeMalaysiaIdentityCardResult();
-				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_OCR_MODEL_RECOGNIZEMALAYSIAIDENTITYCARDRESULT_H_

ocr/include/alibabacloud/ocr/model/RecognizeRussiaIdentityCardRequest.h

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

ocr/include/alibabacloud/ocr/model/RecognizeRussiaIdentityCardResult.h

@@ -1,202 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZERUSSIAIDENTITYCARDRESULT_H_
-#define ALIBABACLOUD_OCR_MODEL_RECOGNIZERUSSIAIDENTITYCARDRESULT_H_
-
-#include <string>
-#include <vector>
-#include <utility>
-#include <alibabacloud/core/ServiceResult.h>
-#include <alibabacloud/ocr/OcrExport.h>
-
-namespace AlibabaCloud
-{
-	namespace Ocr
-	{
-		namespace Model
-		{
-			class ALIBABACLOUD_OCR_EXPORT RecognizeRussiaIdentityCardResult : public ServiceResult
-			{
-			public:
-				struct Data
-				{
-					struct BirthDate
-					{
-						struct KeyPointsItem
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem> keyPoints;
-						std::string text;
-					};
-					struct BirthPlaceFirstLine
-					{
-						struct KeyPointsItem2
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem2> keyPoints1;
-						std::string text;
-					};
-					struct BirthPlaceSecondLine
-					{
-						struct KeyPointsItem4
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem4> keyPoints3;
-						std::string text;
-					};
-					struct BirthPlaceThirdLine
-					{
-						struct KeyPointsItem6
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem6> keyPoints5;
-						std::string text;
-					};
-					struct CardBox
-					{
-						struct KeyPointsItem8
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::string text;
-						std::vector<KeyPointsItem8> keyPoints7;
-					};
-					struct GivenName
-					{
-						struct KeyPointsItem10
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::string text;
-						std::vector<KeyPointsItem10> keyPoints9;
-					};
-					struct IdNumber
-					{
-						struct KeyPointsItem12
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::vector<KeyPointsItem12> keyPoints11;
-						std::string text;
-					};
-					struct PaternalName
-					{
-						struct KeyPointsItem14
-						{
-							float x;
-							float y;
-						};
-						std::vector<KeyPointsItem14> keyPoints13;
-						std::string score;
-						std::string text;
-					};
-					struct PortraitBox
-					{
-						struct KeyPointsItem16
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::vector<KeyPointsItem16> keyPoints15;
-						std::string text;
-					};
-					struct Sex
-					{
-						struct KeyPointsItem18
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::string text;
-						std::vector<KeyPointsItem18> keyPoints17;
-					};
-					struct SurnameFirstLine
-					{
-						struct KeyPointsItem20
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::string text;
-						std::vector<KeyPointsItem20> keyPoints19;
-					};
-					struct SurnameSecondLine
-					{
-						struct KeyPointsItem22
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::vector<KeyPointsItem22> keyPoints21;
-						std::string text;
-					};
-					SurnameFirstLine surnameFirstLine;
-					BirthPlaceFirstLine birthPlaceFirstLine;
-					BirthPlaceSecondLine birthPlaceSecondLine;
-					IdNumber idNumber;
-					PaternalName paternalName;
-					CardBox cardBox;
-					Sex sex;
-					SurnameSecondLine surnameSecondLine;
-					GivenName givenName;
-					PortraitBox portraitBox;
-					BirthPlaceThirdLine birthPlaceThirdLine;
-					BirthDate birthDate;
-				};
-
-
-				RecognizeRussiaIdentityCardResult();
-				explicit RecognizeRussiaIdentityCardResult(const std::string &payload);
-				~RecognizeRussiaIdentityCardResult();
-				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_OCR_MODEL_RECOGNIZERUSSIAIDENTITYCARDRESULT_H_

ocr/include/alibabacloud/ocr/model/RecognizeTurkeyIdentityCardRequest.h

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

ocr/include/alibabacloud/ocr/model/RecognizeTurkeyIdentityCardResult.h

@@ -1,586 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZETURKEYIDENTITYCARDRESULT_H_
-#define ALIBABACLOUD_OCR_MODEL_RECOGNIZETURKEYIDENTITYCARDRESULT_H_
-
-#include <string>
-#include <vector>
-#include <utility>
-#include <alibabacloud/core/ServiceResult.h>
-#include <alibabacloud/ocr/OcrExport.h>
-
-namespace AlibabaCloud
-{
-	namespace Ocr
-	{
-		namespace Model
-		{
-			class ALIBABACLOUD_OCR_EXPORT RecognizeTurkeyIdentityCardResult : public ServiceResult
-			{
-			public:
-				struct Data
-				{
-					struct AuxiliaryTools
-					{
-						struct KeyPointsItem
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem> keyPoints;
-						std::string text;
-					};
-					struct BirthDate
-					{
-						struct KeyPointsItem2
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem2> keyPoints1;
-						std::string text;
-					};
-					struct BirthPlace
-					{
-						struct KeyPointsItem4
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem4> keyPoints3;
-						std::string text;
-					};
-					struct BloodType
-					{
-						struct KeyPointsItem6
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem6> keyPoints5;
-						std::string text;
-					};
-					struct CardBox
-					{
-						struct KeyPointsItem8
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::string text;
-						std::vector<KeyPointsItem8> keyPoints7;
-					};
-					struct Cilt
-					{
-						struct KeyPointsItem10
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::string text;
-						std::vector<KeyPointsItem10> keyPoints9;
-					};
-					struct DocumentNumber
-					{
-						struct KeyPointsItem12
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem12> keyPoints11;
-						std::string text;
-					};
-					struct DriveClass
-					{
-						struct KeyPointsItem14
-						{
-							float x;
-							float y;
-						};
-						std::vector<KeyPointsItem14> keyPoints13;
-						float score;
-						std::string text;
-					};
-					struct DueDate
-					{
-						struct KeyPointsItem16
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem16> keyPoints15;
-						std::string text;
-					};
-					struct Duzenleyen
-					{
-						struct KeyPointsItem18
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::string text;
-						std::vector<KeyPointsItem18> keyPoints17;
-					};
-					struct EntryNumber
-					{
-						struct KeyPointsItem20
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::string text;
-						std::vector<KeyPointsItem20> keyPoints19;
-					};
-					struct ExpiryDate
-					{
-						struct KeyPointsItem22
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem22> keyPoints21;
-						std::string text;
-					};
-					struct FatherName
-					{
-						struct KeyPointsItem24
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem24> keyPoints23;
-						std::string text;
-					};
-					struct ForeignersId
-					{
-						struct KeyPointsItem26
-						{
-							float x;
-							float y;
-						};
-						std::vector<KeyPointsItem26> keyPoints25;
-						float score;
-						std::string text;
-					};
-					struct Gender
-					{
-						struct KeyPointsItem28
-						{
-							float x;
-							float y;
-						};
-						std::vector<KeyPointsItem28> keyPoints27;
-						float score;
-						std::string text;
-					};
-					struct GivenName
-					{
-						struct KeyPointsItem30
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::string text;
-						std::vector<KeyPointsItem30> keyPoints29;
-					};
-					struct IdNumber
-					{
-						struct KeyPointsItem32
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem32> keyPoints31;
-						std::string text;
-					};
-					struct IssueBy
-					{
-						struct KeyPointsItem34
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem34> keyPoints33;
-						std::string text;
-					};
-					struct IssueCounty
-					{
-						struct KeyPointsItem36
-						{
-							float x;
-							float y;
-						};
-						std::vector<KeyPointsItem36> keyPoints35;
-						float score;
-						std::string text;
-					};
-					struct IssueDate
-					{
-						struct KeyPointsItem38
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem38> keyPoints37;
-						std::string text;
-					};
-					struct IssuePlace
-					{
-						struct KeyPointsItem40
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::string text;
-						std::vector<KeyPointsItem40> keyPoints39;
-					};
-					struct Kutuk
-					{
-						struct KeyPointsItem42
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem42> keyPoints41;
-						std::string text;
-					};
-					struct LicenseNumber
-					{
-						struct KeyPointsItem44
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem44> keyPoints43;
-						std::string text;
-					};
-					struct MaritalStatus
-					{
-						struct KeyPointsItem46
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem46> keyPoints45;
-						std::string text;
-					};
-					struct MotherName
-					{
-						struct KeyPointsItem48
-						{
-							float x;
-							float y;
-						};
-						std::vector<KeyPointsItem48> keyPoints47;
-						float score;
-						std::string text;
-					};
-					struct Name
-					{
-						struct KeyPointsItem50
-						{
-							float x;
-							float y;
-						};
-						std::vector<KeyPointsItem50> keyPoints49;
-						float score;
-						std::string text;
-					};
-					struct Nationality
-					{
-						struct KeyPointsItem52
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::string text;
-						std::vector<KeyPointsItem52> keyPoints51;
-					};
-					struct NeighborhoodVillage
-					{
-						struct KeyPointsItem54
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem54> keyPoints53;
-						std::string text;
-					};
-					struct PageNumber
-					{
-						struct KeyPointsItem56
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem56> keyPoints55;
-						std::string text;
-					};
-					struct PassportNumber
-					{
-						struct KeyPointsItem58
-						{
-							float x;
-							float y;
-						};
-						std::vector<KeyPointsItem58> keyPoints57;
-						float score;
-						std::string text;
-					};
-					struct PortraitBox
-					{
-						struct KeyPointsItem60
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem60> keyPoints59;
-						std::string text;
-					};
-					struct Province
-					{
-						struct KeyPointsItem62
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem62> keyPoints61;
-						std::string text;
-					};
-					struct ProvinceOfResidence
-					{
-						struct KeyPointsItem64
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem64> keyPoints63;
-						std::string text;
-					};
-					struct ReasonOfIssue
-					{
-						struct KeyPointsItem66
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem66> keyPoints65;
-						std::string text;
-					};
-					struct RegisterNumber
-					{
-						struct KeyPointsItem68
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem68> keyPoints67;
-						std::string text;
-					};
-					struct Religion
-					{
-						struct KeyPointsItem70
-						{
-							float x;
-							float y;
-						};
-						std::vector<KeyPointsItem70> keyPoints69;
-						float score;
-						std::string text;
-					};
-					struct Sayfa
-					{
-						struct KeyPointsItem72
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem72> keyPoints71;
-						std::string text;
-					};
-					struct Seri
-					{
-						struct KeyPointsItem74
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::string text;
-						std::vector<KeyPointsItem74> keyPoints73;
-					};
-					struct Surname
-					{
-						struct KeyPointsItem76
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem76> keyPoints75;
-						std::string text;
-					};
-					struct TypeOfResidencePermit
-					{
-						struct KeyPointsItem78
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem78> keyPoints77;
-						std::string text;
-					};
-					struct ValidUntil
-					{
-						struct KeyPointsItem80
-						{
-							float x;
-							float y;
-						};
-						std::vector<KeyPointsItem80> keyPoints79;
-						float score;
-						std::string text;
-					};
-					struct Village
-					{
-						struct KeyPointsItem82
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::string text;
-						std::vector<KeyPointsItem82> keyPoints81;
-					};
-					struct VolumeNumber
-					{
-						struct KeyPointsItem84
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem84> keyPoints83;
-						std::string text;
-					};
-					struct Sex
-					{
-						struct KeyPointsItem86
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem86> keyPoints85;
-						std::string text;
-					};
-					ExpiryDate expiryDate;
-					BirthPlace birthPlace;
-					ForeignersId foreignersId;
-					LicenseNumber licenseNumber;
-					IdNumber idNumber;
-					CardBox cardBox;
-					Sex sex;
-					ReasonOfIssue reasonOfIssue;
-					GivenName givenName;
-					Gender gender;
-					NeighborhoodVillage neighborhoodVillage;
-					PortraitBox portraitBox;
-					IssuePlace issuePlace;
-					TypeOfResidencePermit typeOfResidencePermit;
-					Seri seri;
-					Name name;
-					PageNumber pageNumber;
-					MotherName motherName;
-					Kutuk kutuk;
-					DriveClass driveClass;
-					DueDate dueDate;
-					IssueBy issueBy;
-					Village village;
-					Religion religion;
-					IssueDate issueDate;
-					DocumentNumber documentNumber;
-					AuxiliaryTools auxiliaryTools;
-					Cilt cilt;
-					Nationality nationality;
-					Province province;
-					ValidUntil validUntil;
-					VolumeNumber volumeNumber;
-					EntryNumber entryNumber;
-					MaritalStatus maritalStatus;
-					RegisterNumber registerNumber;
-					Duzenleyen duzenleyen;
-					ProvinceOfResidence provinceOfResidence;
-					PassportNumber passportNumber;
-					Sayfa sayfa;
-					IssueCounty issueCounty;
-					Surname surname;
-					BloodType bloodType;
-					BirthDate birthDate;
-					FatherName fatherName;
-				};
-
-
-				RecognizeTurkeyIdentityCardResult();
-				explicit RecognizeTurkeyIdentityCardResult(const std::string &payload);
-				~RecognizeTurkeyIdentityCardResult();
-				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_OCR_MODEL_RECOGNIZETURKEYIDENTITYCARDRESULT_H_

ocr/include/alibabacloud/ocr/model/RecognizeUkraineIdentityCardRequest.h

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

ocr/include/alibabacloud/ocr/model/RecognizeUkraineIdentityCardResult.h

@@ -1,214 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEUKRAINEIDENTITYCARDRESULT_H_
-#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEUKRAINEIDENTITYCARDRESULT_H_
-
-#include <string>
-#include <vector>
-#include <utility>
-#include <alibabacloud/core/ServiceResult.h>
-#include <alibabacloud/ocr/OcrExport.h>
-
-namespace AlibabaCloud
-{
-	namespace Ocr
-	{
-		namespace Model
-		{
-			class ALIBABACLOUD_OCR_EXPORT RecognizeUkraineIdentityCardResult : public ServiceResult
-			{
-			public:
-				struct Data
-				{
-					struct BirthDate
-					{
-						struct KeyPointsItem
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem> keyPoints;
-						std::string text;
-					};
-					struct CardBox
-					{
-						struct KeyPointsItem2
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem2> keyPoints1;
-						std::string text;
-					};
-					struct DocumentNumber
-					{
-						struct KeyPointsItem4
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem4> keyPoints3;
-						std::string text;
-					};
-					struct ExpiryDate
-					{
-						struct KeyPointsItem6
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem6> keyPoints5;
-						std::string text;
-					};
-					struct NameEnglish
-					{
-						struct KeyPointsItem8
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::string text;
-						std::vector<KeyPointsItem8> keyPoints7;
-					};
-					struct NameUkraine
-					{
-						struct KeyPointsItem10
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::string text;
-						std::vector<KeyPointsItem10> keyPoints9;
-					};
-					struct Nationality
-					{
-						struct KeyPointsItem12
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem12> keyPoints11;
-						std::string text;
-					};
-					struct Patronymic
-					{
-						struct KeyPointsItem14
-						{
-							float x;
-							float y;
-						};
-						std::vector<KeyPointsItem14> keyPoints13;
-						float score;
-						std::string text;
-					};
-					struct PortraitBox
-					{
-						struct KeyPointsItem16
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem16> keyPoints15;
-						std::string text;
-					};
-					struct RecordNumber
-					{
-						struct KeyPointsItem18
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::string text;
-						std::vector<KeyPointsItem18> keyPoints17;
-					};
-					struct Sex
-					{
-						struct KeyPointsItem20
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::string text;
-						std::vector<KeyPointsItem20> keyPoints19;
-					};
-					struct SurnameEnglish
-					{
-						struct KeyPointsItem22
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem22> keyPoints21;
-						std::string text;
-					};
-					struct SurnameUkraine
-					{
-						struct KeyPointsItem24
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem24> keyPoints23;
-						std::string text;
-					};
-					ExpiryDate expiryDate;
-					CardBox cardBox;
-					Sex sex;
-					NameUkraine nameUkraine;
-					PortraitBox portraitBox;
-					DocumentNumber documentNumber;
-					SurnameEnglish surnameEnglish;
-					Nationality nationality;
-					SurnameUkraine surnameUkraine;
-					NameEnglish nameEnglish;
-					Patronymic patronymic;
-					RecordNumber recordNumber;
-					BirthDate birthDate;
-				};
-
-
-				RecognizeUkraineIdentityCardResult();
-				explicit RecognizeUkraineIdentityCardResult(const std::string &payload);
-				~RecognizeUkraineIdentityCardResult();
-				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_OCR_MODEL_RECOGNIZEUKRAINEIDENTITYCARDRESULT_H_

ocr/include/alibabacloud/ocr/model/RecognizeVideoCastCrewListRequest.h

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

ocr/include/alibabacloud/ocr/model/RecognizeVideoCastCrewListResult.h

@@ -1,49 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEVIDEOCASTCREWLISTRESULT_H_
-#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEVIDEOCASTCREWLISTRESULT_H_
-
-#include <string>
-#include <vector>
-#include <utility>
-#include <alibabacloud/core/ServiceResult.h>
-#include <alibabacloud/ocr/OcrExport.h>
-
-namespace AlibabaCloud
-{
-	namespace Ocr
-	{
-		namespace Model
-		{
-			class ALIBABACLOUD_OCR_EXPORT RecognizeVideoCastCrewListResult : public ServiceResult
-			{
-			public:
-
-
-				RecognizeVideoCastCrewListResult();
-				explicit RecognizeVideoCastCrewListResult(const std::string &payload);
-				~RecognizeVideoCastCrewListResult();
-
-			protected:
-				void parse(const std::string &payload);
-			private:
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEVIDEOCASTCREWLISTRESULT_H_

ocr/include/alibabacloud/ocr/model/RecognizeVietnamIdentityCardRequest.h

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

ocr/include/alibabacloud/ocr/model/RecognizeVietnamIdentityCardResult.h

@@ -1,238 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEVIETNAMIDENTITYCARDRESULT_H_
-#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEVIETNAMIDENTITYCARDRESULT_H_
-
-#include <string>
-#include <vector>
-#include <utility>
-#include <alibabacloud/core/ServiceResult.h>
-#include <alibabacloud/ocr/OcrExport.h>
-
-namespace AlibabaCloud
-{
-	namespace Ocr
-	{
-		namespace Model
-		{
-			class ALIBABACLOUD_OCR_EXPORT RecognizeVietnamIdentityCardResult : public ServiceResult
-			{
-			public:
-				struct Data
-				{
-					struct AddressFirstLine
-					{
-						struct KeyPointsItem
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem> keyPoints;
-						std::string text;
-					};
-					struct AddressSecondLine
-					{
-						struct KeyPointsItem2
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem2> keyPoints1;
-						std::string text;
-					};
-					struct BirthDate
-					{
-						struct KeyPointsItem4
-						{
-							float x;
-							float y;
-						};
-						float score;
-						std::vector<KeyPointsItem4> keyPoints3;
-						std::string text;
-					};
-					struct CardBox
-					{
-						struct KeyPointsItem6
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::vector<KeyPointsItem6> keyPoints5;
-						std::string text;
-					};
-					struct DriveClass
-					{
-						struct KeyPointsItem8
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::string text;
-						std::vector<KeyPointsItem8> keyPoints7;
-					};
-					struct ExpiryDate
-					{
-						struct KeyPointsItem10
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::string text;
-						std::vector<KeyPointsItem10> keyPoints9;
-					};
-					struct FullName
-					{
-						struct KeyPointsItem12
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::vector<KeyPointsItem12> keyPoints11;
-						std::string text;
-					};
-					struct IdNumber
-					{
-						struct KeyPointsItem14
-						{
-							float x;
-							float y;
-						};
-						std::vector<KeyPointsItem14> keyPoints13;
-						std::string score;
-						std::string text;
-					};
-					struct Nationality
-					{
-						struct KeyPointsItem16
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::vector<KeyPointsItem16> keyPoints15;
-						std::string text;
-					};
-					struct OriginPlaceFirstLine
-					{
-						struct KeyPointsItem18
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::string text;
-						std::vector<KeyPointsItem18> keyPoints17;
-					};
-					struct OriginPlaceSecondLine
-					{
-						struct KeyPointsItem20
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::string text;
-						std::vector<KeyPointsItem20> keyPoints19;
-					};
-					struct PortraitBox
-					{
-						struct KeyPointsItem22
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::vector<KeyPointsItem22> keyPoints21;
-						std::string text;
-					};
-					struct ResidencePlaceFirstLine
-					{
-						struct KeyPointsItem24
-						{
-							float x;
-							float y;
-						};
-						std::string score;
-						std::vector<KeyPointsItem24> keyPoints23;
-						std::string text;
-					};
-					struct ResidencePlaceSecondLine
-					{
-						struct KeyPointsItem26
-						{
-							float x;
-							float y;
-						};
-						std::vector<KeyPointsItem26> keyPoints25;
-						std::string score;
-						std::string text;
-					};
-					struct Sex
-					{
-						struct KeyPointsItem28
-						{
-							float x;
-							float y;
-						};
-						std::vector<KeyPointsItem28> keyPoints27;
-						std::string score;
-						std::string text;
-					};
-					ExpiryDate expiryDate;
-					OriginPlaceFirstLine originPlaceFirstLine;
-					IdNumber idNumber;
-					CardBox cardBox;
-					Sex sex;
-					PortraitBox portraitBox;
-					ResidencePlaceSecondLine residencePlaceSecondLine;
-					Nationality nationality;
-					OriginPlaceSecondLine originPlaceSecondLine;
-					AddressFirstLine addressFirstLine;
-					FullName fullName;
-					DriveClass driveClass;
-					AddressSecondLine addressSecondLine;
-					BirthDate birthDate;
-					ResidencePlaceFirstLine residencePlaceFirstLine;
-				};
-
-
-				RecognizeVietnamIdentityCardResult();
-				explicit RecognizeVietnamIdentityCardResult(const std::string &payload);
-				~RecognizeVietnamIdentityCardResult();
-				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_OCR_MODEL_RECOGNIZEVIETNAMIDENTITYCARDRESULT_H_

ocr/src/OcrClient.cc

@@ -447,42 +447,6 @@ OcrClient::RecognizeIdentityCardOutcomeCallable OcrClient::recognizeIdentityCard
 	return task->get_future();
 }
 
-OcrClient::RecognizeIndonesiaIdentityCardOutcome OcrClient::recognizeIndonesiaIdentityCard(const RecognizeIndonesiaIdentityCardRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return RecognizeIndonesiaIdentityCardOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return RecognizeIndonesiaIdentityCardOutcome(RecognizeIndonesiaIdentityCardResult(outcome.result()));
-	else
-		return RecognizeIndonesiaIdentityCardOutcome(outcome.error());
-}
-
-void OcrClient::recognizeIndonesiaIdentityCardAsync(const RecognizeIndonesiaIdentityCardRequest& request, const RecognizeIndonesiaIdentityCardAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, recognizeIndonesiaIdentityCard(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-OcrClient::RecognizeIndonesiaIdentityCardOutcomeCallable OcrClient::recognizeIndonesiaIdentityCardCallable(const RecognizeIndonesiaIdentityCardRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<RecognizeIndonesiaIdentityCardOutcome()>>(
-			[this, request]()
-			{
-			return this->recognizeIndonesiaIdentityCard(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 OcrClient::RecognizeLicensePlateOutcome OcrClient::recognizeLicensePlate(const RecognizeLicensePlateRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -519,42 +483,6 @@ OcrClient::RecognizeLicensePlateOutcomeCallable OcrClient::recognizeLicensePlate
 	return task->get_future();
 }
 
-OcrClient::RecognizeMalaysiaIdentityCardOutcome OcrClient::recognizeMalaysiaIdentityCard(const RecognizeMalaysiaIdentityCardRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return RecognizeMalaysiaIdentityCardOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return RecognizeMalaysiaIdentityCardOutcome(RecognizeMalaysiaIdentityCardResult(outcome.result()));
-	else
-		return RecognizeMalaysiaIdentityCardOutcome(outcome.error());
-}
-
-void OcrClient::recognizeMalaysiaIdentityCardAsync(const RecognizeMalaysiaIdentityCardRequest& request, const RecognizeMalaysiaIdentityCardAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, recognizeMalaysiaIdentityCard(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-OcrClient::RecognizeMalaysiaIdentityCardOutcomeCallable OcrClient::recognizeMalaysiaIdentityCardCallable(const RecognizeMalaysiaIdentityCardRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<RecognizeMalaysiaIdentityCardOutcome()>>(
-			[this, request]()
-			{
-			return this->recognizeMalaysiaIdentityCard(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 OcrClient::RecognizePassportMRZOutcome OcrClient::recognizePassportMRZ(const RecognizePassportMRZRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -735,42 +663,6 @@ OcrClient::RecognizeQuotaInvoiceOutcomeCallable OcrClient::recognizeQuotaInvoice
 	return task->get_future();
 }
 
-OcrClient::RecognizeRussiaIdentityCardOutcome OcrClient::recognizeRussiaIdentityCard(const RecognizeRussiaIdentityCardRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return RecognizeRussiaIdentityCardOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return RecognizeRussiaIdentityCardOutcome(RecognizeRussiaIdentityCardResult(outcome.result()));
-	else
-		return RecognizeRussiaIdentityCardOutcome(outcome.error());
-}
-
-void OcrClient::recognizeRussiaIdentityCardAsync(const RecognizeRussiaIdentityCardRequest& request, const RecognizeRussiaIdentityCardAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, recognizeRussiaIdentityCard(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-OcrClient::RecognizeRussiaIdentityCardOutcomeCallable OcrClient::recognizeRussiaIdentityCardCallable(const RecognizeRussiaIdentityCardRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<RecognizeRussiaIdentityCardOutcome()>>(
-			[this, request]()
-			{
-			return this->recognizeRussiaIdentityCard(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 OcrClient::RecognizeStampOutcome OcrClient::recognizeStamp(const RecognizeStampRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -987,78 +879,6 @@ OcrClient::RecognizeTrainTicketOutcomeCallable OcrClient::recognizeTrainTicketCa
 	return task->get_future();
 }
 
-OcrClient::RecognizeTurkeyIdentityCardOutcome OcrClient::recognizeTurkeyIdentityCard(const RecognizeTurkeyIdentityCardRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return RecognizeTurkeyIdentityCardOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return RecognizeTurkeyIdentityCardOutcome(RecognizeTurkeyIdentityCardResult(outcome.result()));
-	else
-		return RecognizeTurkeyIdentityCardOutcome(outcome.error());
-}
-
-void OcrClient::recognizeTurkeyIdentityCardAsync(const RecognizeTurkeyIdentityCardRequest& request, const RecognizeTurkeyIdentityCardAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, recognizeTurkeyIdentityCard(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-OcrClient::RecognizeTurkeyIdentityCardOutcomeCallable OcrClient::recognizeTurkeyIdentityCardCallable(const RecognizeTurkeyIdentityCardRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<RecognizeTurkeyIdentityCardOutcome()>>(
-			[this, request]()
-			{
-			return this->recognizeTurkeyIdentityCard(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
-OcrClient::RecognizeUkraineIdentityCardOutcome OcrClient::recognizeUkraineIdentityCard(const RecognizeUkraineIdentityCardRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return RecognizeUkraineIdentityCardOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return RecognizeUkraineIdentityCardOutcome(RecognizeUkraineIdentityCardResult(outcome.result()));
-	else
-		return RecognizeUkraineIdentityCardOutcome(outcome.error());
-}
-
-void OcrClient::recognizeUkraineIdentityCardAsync(const RecognizeUkraineIdentityCardRequest& request, const RecognizeUkraineIdentityCardAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, recognizeUkraineIdentityCard(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-OcrClient::RecognizeUkraineIdentityCardOutcomeCallable OcrClient::recognizeUkraineIdentityCardCallable(const RecognizeUkraineIdentityCardRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<RecognizeUkraineIdentityCardOutcome()>>(
-			[this, request]()
-			{
-			return this->recognizeUkraineIdentityCard(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 OcrClient::RecognizeVATInvoiceOutcome OcrClient::recognizeVATInvoice(const RecognizeVATInvoiceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1167,42 +987,6 @@ OcrClient::RecognizeVerificationcodeOutcomeCallable OcrClient::recognizeVerifica
 	return task->get_future();
 }
 
-OcrClient::RecognizeVideoCastCrewListOutcome OcrClient::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 OcrClient::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));
-}
-
-OcrClient::RecognizeVideoCastCrewListOutcomeCallable OcrClient::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();
-}
-
 OcrClient::RecognizeVideoCharacterOutcome OcrClient::recognizeVideoCharacter(const RecognizeVideoCharacterRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1239,42 +1023,6 @@ OcrClient::RecognizeVideoCharacterOutcomeCallable OcrClient::recognizeVideoChara
 	return task->get_future();
 }
 
-OcrClient::RecognizeVietnamIdentityCardOutcome OcrClient::recognizeVietnamIdentityCard(const RecognizeVietnamIdentityCardRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return RecognizeVietnamIdentityCardOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return RecognizeVietnamIdentityCardOutcome(RecognizeVietnamIdentityCardResult(outcome.result()));
-	else
-		return RecognizeVietnamIdentityCardOutcome(outcome.error());
-}
-
-void OcrClient::recognizeVietnamIdentityCardAsync(const RecognizeVietnamIdentityCardRequest& request, const RecognizeVietnamIdentityCardAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, recognizeVietnamIdentityCard(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-OcrClient::RecognizeVietnamIdentityCardOutcomeCallable OcrClient::recognizeVietnamIdentityCardCallable(const RecognizeVietnamIdentityCardRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<RecognizeVietnamIdentityCardOutcome()>>(
-			[this, request]()
-			{
-			return this->recognizeVietnamIdentityCard(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 OcrClient::TrimDocumentOutcome OcrClient::trimDocument(const TrimDocumentRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

ocr/src/model/RecognizeIndonesiaIdentityCardRequest.cc

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

ocr/src/model/RecognizeIndonesiaIdentityCardResult.cc

@@ -1,394 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/ocr/model/RecognizeIndonesiaIdentityCardResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Ocr;
-using namespace AlibabaCloud::Ocr::Model;
-
-RecognizeIndonesiaIdentityCardResult::RecognizeIndonesiaIdentityCardResult() :
-	ServiceResult()
-{}
-
-RecognizeIndonesiaIdentityCardResult::RecognizeIndonesiaIdentityCardResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-RecognizeIndonesiaIdentityCardResult::~RecognizeIndonesiaIdentityCardResult()
-{}
-
-void RecognizeIndonesiaIdentityCardResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto dataNode = value["Data"];
-	auto addressFirstLineNode = dataNode["AddressFirstLine"];
-	if(!addressFirstLineNode["Text"].isNull())
-		data_.addressFirstLine.text = addressFirstLineNode["Text"].asString();
-	if(!addressFirstLineNode["Score"].isNull())
-		data_.addressFirstLine.score = std::stof(addressFirstLineNode["Score"].asString());
-	auto allKeyPointsNode = addressFirstLineNode["KeyPoints"]["keyPointsItem"];
-	for (auto addressFirstLineNodeKeyPointskeyPointsItem : allKeyPointsNode)
-	{
-		Data::AddressFirstLine::KeyPointsItem keyPointsItemObject;
-		if(!addressFirstLineNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItemObject.x = std::stof(addressFirstLineNodeKeyPointskeyPointsItem["X"].asString());
-		if(!addressFirstLineNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItemObject.y = std::stof(addressFirstLineNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.addressFirstLine.keyPoints.push_back(keyPointsItemObject);
-	}
-	auto addressSecondLineNode = dataNode["AddressSecondLine"];
-	if(!addressSecondLineNode["Text"].isNull())
-		data_.addressSecondLine.text = addressSecondLineNode["Text"].asString();
-	if(!addressSecondLineNode["Score"].isNull())
-		data_.addressSecondLine.score = std::stof(addressSecondLineNode["Score"].asString());
-	auto allKeyPoints1Node = addressSecondLineNode["KeyPoints"]["keyPointsItem"];
-	for (auto addressSecondLineNodeKeyPointskeyPointsItem : allKeyPoints1Node)
-	{
-		Data::AddressSecondLine::KeyPointsItem2 keyPointsItem2Object;
-		if(!addressSecondLineNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem2Object.x = std::stof(addressSecondLineNodeKeyPointskeyPointsItem["X"].asString());
-		if(!addressSecondLineNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem2Object.y = std::stof(addressSecondLineNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.addressSecondLine.keyPoints1.push_back(keyPointsItem2Object);
-	}
-	auto addressThirdLineNode = dataNode["AddressThirdLine"];
-	if(!addressThirdLineNode["Text"].isNull())
-		data_.addressThirdLine.text = addressThirdLineNode["Text"].asString();
-	if(!addressThirdLineNode["Score"].isNull())
-		data_.addressThirdLine.score = std::stof(addressThirdLineNode["Score"].asString());
-	auto allKeyPoints3Node = addressThirdLineNode["KeyPoints"]["keyPointsItem"];
-	for (auto addressThirdLineNodeKeyPointskeyPointsItem : allKeyPoints3Node)
-	{
-		Data::AddressThirdLine::KeyPointsItem4 keyPointsItem4Object;
-		if(!addressThirdLineNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem4Object.x = std::stof(addressThirdLineNodeKeyPointskeyPointsItem["X"].asString());
-		if(!addressThirdLineNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem4Object.y = std::stof(addressThirdLineNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.addressThirdLine.keyPoints3.push_back(keyPointsItem4Object);
-	}
-	auto addressFourthLineNode = dataNode["AddressFourthLine"];
-	if(!addressFourthLineNode["Text"].isNull())
-		data_.addressFourthLine.text = addressFourthLineNode["Text"].asString();
-	if(!addressFourthLineNode["Score"].isNull())
-		data_.addressFourthLine.score = std::stof(addressFourthLineNode["Score"].asString());
-	auto allKeyPoints5Node = addressFourthLineNode["KeyPoints"]["keyPointsItem"];
-	for (auto addressFourthLineNodeKeyPointskeyPointsItem : allKeyPoints5Node)
-	{
-		Data::AddressFourthLine::KeyPointsItem6 keyPointsItem6Object;
-		if(!addressFourthLineNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem6Object.x = std::stof(addressFourthLineNodeKeyPointskeyPointsItem["X"].asString());
-		if(!addressFourthLineNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem6Object.y = std::stof(addressFourthLineNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.addressFourthLine.keyPoints5.push_back(keyPointsItem6Object);
-	}
-	auto addressFifthLineNode = dataNode["AddressFifthLine"];
-	if(!addressFifthLineNode["Text"].isNull())
-		data_.addressFifthLine.text = addressFifthLineNode["Text"].asString();
-	if(!addressFifthLineNode["Score"].isNull())
-		data_.addressFifthLine.score = std::stof(addressFifthLineNode["Score"].asString());
-	auto allKeyPoints7Node = addressFifthLineNode["KeyPoints"]["keyPointsItem"];
-	for (auto addressFifthLineNodeKeyPointskeyPointsItem : allKeyPoints7Node)
-	{
-		Data::AddressFifthLine::KeyPointsItem8 keyPointsItem8Object;
-		if(!addressFifthLineNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem8Object.x = std::stof(addressFifthLineNodeKeyPointskeyPointsItem["X"].asString());
-		if(!addressFifthLineNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem8Object.y = std::stof(addressFifthLineNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.addressFifthLine.keyPoints7.push_back(keyPointsItem8Object);
-	}
-	auto birthDateNode = dataNode["BirthDate"];
-	if(!birthDateNode["Text"].isNull())
-		data_.birthDate.text = birthDateNode["Text"].asString();
-	if(!birthDateNode["Score"].isNull())
-		data_.birthDate.score = birthDateNode["Score"].asString();
-	auto allKeyPoints9Node = birthDateNode["KeyPoints"]["keyPointsItem"];
-	for (auto birthDateNodeKeyPointskeyPointsItem : allKeyPoints9Node)
-	{
-		Data::BirthDate::KeyPointsItem10 keyPointsItem10Object;
-		if(!birthDateNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem10Object.x = std::stof(birthDateNodeKeyPointskeyPointsItem["X"].asString());
-		if(!birthDateNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem10Object.y = std::stof(birthDateNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.birthDate.keyPoints9.push_back(keyPointsItem10Object);
-	}
-	auto birthPlaceNode = dataNode["BirthPlace"];
-	if(!birthPlaceNode["Text"].isNull())
-		data_.birthPlace.text = birthPlaceNode["Text"].asString();
-	if(!birthPlaceNode["Score"].isNull())
-		data_.birthPlace.score = birthPlaceNode["Score"].asString();
-	auto allKeyPoints11Node = birthPlaceNode["KeyPoints"]["keyPointsItem"];
-	for (auto birthPlaceNodeKeyPointskeyPointsItem : allKeyPoints11Node)
-	{
-		Data::BirthPlace::KeyPointsItem12 keyPointsItem12Object;
-		if(!birthPlaceNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem12Object.x = std::stof(birthPlaceNodeKeyPointskeyPointsItem["X"].asString());
-		if(!birthPlaceNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem12Object.y = std::stof(birthPlaceNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.birthPlace.keyPoints11.push_back(keyPointsItem12Object);
-	}
-	auto cardBoxNode = dataNode["CardBox"];
-	if(!cardBoxNode["Text"].isNull())
-		data_.cardBox.text = cardBoxNode["Text"].asString();
-	if(!cardBoxNode["Score"].isNull())
-		data_.cardBox.score = cardBoxNode["Score"].asString();
-	auto allKeyPoints13Node = cardBoxNode["KeyPoints"]["keyPointsItem"];
-	for (auto cardBoxNodeKeyPointskeyPointsItem : allKeyPoints13Node)
-	{
-		Data::CardBox::KeyPointsItem14 keyPointsItem14Object;
-		if(!cardBoxNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem14Object.x = std::stof(cardBoxNodeKeyPointskeyPointsItem["X"].asString());
-		if(!cardBoxNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem14Object.y = std::stof(cardBoxNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.cardBox.keyPoints13.push_back(keyPointsItem14Object);
-	}
-	auto expiryDateNode = dataNode["ExpiryDate"];
-	if(!expiryDateNode["Text"].isNull())
-		data_.expiryDate.text = expiryDateNode["Text"].asString();
-	if(!expiryDateNode["Score"].isNull())
-		data_.expiryDate.score = expiryDateNode["Score"].asString();
-	auto allKeyPoints15Node = expiryDateNode["KeyPoints"]["keyPointsItem"];
-	for (auto expiryDateNodeKeyPointskeyPointsItem : allKeyPoints15Node)
-	{
-		Data::ExpiryDate::KeyPointsItem16 keyPointsItem16Object;
-		if(!expiryDateNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem16Object.x = std::stof(expiryDateNodeKeyPointskeyPointsItem["X"].asString());
-		if(!expiryDateNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem16Object.y = std::stof(expiryDateNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.expiryDate.keyPoints15.push_back(keyPointsItem16Object);
-	}
-	auto genderNode = dataNode["Gender"];
-	if(!genderNode["Text"].isNull())
-		data_.gender.text = genderNode["Text"].asString();
-	if(!genderNode["Score"].isNull())
-		data_.gender.score = genderNode["Score"].asString();
-	auto allKeyPoints17Node = genderNode["KeyPoints"]["keyPointsItem"];
-	for (auto genderNodeKeyPointskeyPointsItem : allKeyPoints17Node)
-	{
-		Data::Gender::KeyPointsItem18 keyPointsItem18Object;
-		if(!genderNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem18Object.x = std::stof(genderNodeKeyPointskeyPointsItem["X"].asString());
-		if(!genderNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem18Object.y = std::stof(genderNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.gender.keyPoints17.push_back(keyPointsItem18Object);
-	}
-	auto heightNode = dataNode["Height"];
-	if(!heightNode["Text"].isNull())
-		data_.height.text = heightNode["Text"].asString();
-	if(!heightNode["Score"].isNull())
-		data_.height.score = heightNode["Score"].asString();
-	auto allKeyPoints19Node = heightNode["KeyPoints"]["keyPointsItem"];
-	for (auto heightNodeKeyPointskeyPointsItem : allKeyPoints19Node)
-	{
-		Data::Height::KeyPointsItem20 keyPointsItem20Object;
-		if(!heightNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem20Object.x = std::stof(heightNodeKeyPointskeyPointsItem["X"].asString());
-		if(!heightNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem20Object.y = std::stof(heightNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.height.keyPoints19.push_back(keyPointsItem20Object);
-	}
-	auto idNumberNode = dataNode["IdNumber"];
-	if(!idNumberNode["Text"].isNull())
-		data_.idNumber.text = idNumberNode["Text"].asString();
-	if(!idNumberNode["Score"].isNull())
-		data_.idNumber.score = idNumberNode["Score"].asString();
-	auto allKeyPoints21Node = idNumberNode["KeyPoints"]["keyPointsItem"];
-	for (auto idNumberNodeKeyPointskeyPointsItem : allKeyPoints21Node)
-	{
-		Data::IdNumber::KeyPointsItem22 keyPointsItem22Object;
-		if(!idNumberNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem22Object.x = std::stof(idNumberNodeKeyPointskeyPointsItem["X"].asString());
-		if(!idNumberNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem22Object.y = std::stof(idNumberNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.idNumber.keyPoints21.push_back(keyPointsItem22Object);
-	}
-	auto licenseNumberNode = dataNode["LicenseNumber"];
-	if(!licenseNumberNode["Text"].isNull())
-		data_.licenseNumber.text = licenseNumberNode["Text"].asString();
-	if(!licenseNumberNode["Score"].isNull())
-		data_.licenseNumber.score = licenseNumberNode["Score"].asString();
-	auto allKeyPoints23Node = licenseNumberNode["KeyPoints"]["keyPointsItem"];
-	for (auto licenseNumberNodeKeyPointskeyPointsItem : allKeyPoints23Node)
-	{
-		Data::LicenseNumber::KeyPointsItem24 keyPointsItem24Object;
-		if(!licenseNumberNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem24Object.x = std::stof(licenseNumberNodeKeyPointskeyPointsItem["X"].asString());
-		if(!licenseNumberNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem24Object.y = std::stof(licenseNumberNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.licenseNumber.keyPoints23.push_back(keyPointsItem24Object);
-	}
-	auto maritalStatusNode = dataNode["MaritalStatus"];
-	if(!maritalStatusNode["Text"].isNull())
-		data_.maritalStatus.text = maritalStatusNode["Text"].asString();
-	if(!maritalStatusNode["Score"].isNull())
-		data_.maritalStatus.score = maritalStatusNode["Score"].asString();
-	auto allKeyPoints25Node = maritalStatusNode["KeyPoints"]["keyPointsItem"];
-	for (auto maritalStatusNodeKeyPointskeyPointsItem : allKeyPoints25Node)
-	{
-		Data::MaritalStatus::KeyPointsItem26 keyPointsItem26Object;
-		if(!maritalStatusNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem26Object.x = std::stof(maritalStatusNodeKeyPointskeyPointsItem["X"].asString());
-		if(!maritalStatusNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem26Object.y = std::stof(maritalStatusNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.maritalStatus.keyPoints25.push_back(keyPointsItem26Object);
-	}
-	auto nameFirstLineNode = dataNode["NameFirstLine"];
-	if(!nameFirstLineNode["Text"].isNull())
-		data_.nameFirstLine.text = nameFirstLineNode["Text"].asString();
-	if(!nameFirstLineNode["Score"].isNull())
-		data_.nameFirstLine.score = nameFirstLineNode["Score"].asString();
-	auto allKeyPoints27Node = nameFirstLineNode["KeyPoints"]["keyPointsItem"];
-	for (auto nameFirstLineNodeKeyPointskeyPointsItem : allKeyPoints27Node)
-	{
-		Data::NameFirstLine::KeyPointsItem28 keyPointsItem28Object;
-		if(!nameFirstLineNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem28Object.x = std::stof(nameFirstLineNodeKeyPointskeyPointsItem["X"].asString());
-		if(!nameFirstLineNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem28Object.y = std::stof(nameFirstLineNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.nameFirstLine.keyPoints27.push_back(keyPointsItem28Object);
-	}
-	auto nameSecondLineNode = dataNode["NameSecondLine"];
-	if(!nameSecondLineNode["Text"].isNull())
-		data_.nameSecondLine.text = nameSecondLineNode["Text"].asString();
-	if(!nameSecondLineNode["Score"].isNull())
-		data_.nameSecondLine.score = nameSecondLineNode["Score"].asString();
-	auto allKeyPoints29Node = nameSecondLineNode["KeyPoints"]["keyPointsItem"];
-	for (auto nameSecondLineNodeKeyPointskeyPointsItem : allKeyPoints29Node)
-	{
-		Data::NameSecondLine::KeyPointsItem30 keyPointsItem30Object;
-		if(!nameSecondLineNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem30Object.x = std::stof(nameSecondLineNodeKeyPointskeyPointsItem["X"].asString());
-		if(!nameSecondLineNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem30Object.y = std::stof(nameSecondLineNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.nameSecondLine.keyPoints29.push_back(keyPointsItem30Object);
-	}
-	auto nationalityNode = dataNode["Nationality"];
-	if(!nationalityNode["Text"].isNull())
-		data_.nationality.text = nationalityNode["Text"].asString();
-	if(!nationalityNode["Score"].isNull())
-		data_.nationality.score = nationalityNode["Score"].asString();
-	auto allKeyPoints31Node = nationalityNode["KeyPoints"]["keyPointsItem"];
-	for (auto nationalityNodeKeyPointskeyPointsItem : allKeyPoints31Node)
-	{
-		Data::Nationality::KeyPointsItem32 keyPointsItem32Object;
-		if(!nationalityNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem32Object.x = std::stof(nationalityNodeKeyPointskeyPointsItem["X"].asString());
-		if(!nationalityNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem32Object.y = std::stof(nationalityNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.nationality.keyPoints31.push_back(keyPointsItem32Object);
-	}
-	auto occupationNode = dataNode["Occupation"];
-	if(!occupationNode["Text"].isNull())
-		data_.occupation.text = occupationNode["Text"].asString();
-	if(!occupationNode["Score"].isNull())
-		data_.occupation.score = occupationNode["Score"].asString();
-	auto allKeyPoints33Node = occupationNode["KeyPoints"]["keyPointsItem"];
-	for (auto occupationNodeKeyPointskeyPointsItem : allKeyPoints33Node)
-	{
-		Data::Occupation::KeyPointsItem34 keyPointsItem34Object;
-		if(!occupationNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem34Object.x = std::stof(occupationNodeKeyPointskeyPointsItem["X"].asString());
-		if(!occupationNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem34Object.y = std::stof(occupationNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.occupation.keyPoints33.push_back(keyPointsItem34Object);
-	}
-	auto portraitBoxNode = dataNode["PortraitBox"];
-	if(!portraitBoxNode["Text"].isNull())
-		data_.portraitBox.text = portraitBoxNode["Text"].asString();
-	if(!portraitBoxNode["Score"].isNull())
-		data_.portraitBox.score = portraitBoxNode["Score"].asString();
-	auto allKeyPoints35Node = portraitBoxNode["KeyPoints"]["keyPointsItem"];
-	for (auto portraitBoxNodeKeyPointskeyPointsItem : allKeyPoints35Node)
-	{
-		Data::PortraitBox::KeyPointsItem36 keyPointsItem36Object;
-		if(!portraitBoxNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem36Object.x = std::stof(portraitBoxNodeKeyPointskeyPointsItem["X"].asString());
-		if(!portraitBoxNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem36Object.y = std::stof(portraitBoxNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.portraitBox.keyPoints35.push_back(keyPointsItem36Object);
-	}
-	auto provinceNode = dataNode["Province"];
-	if(!provinceNode["Text"].isNull())
-		data_.province.text = provinceNode["Text"].asString();
-	if(!provinceNode["Score"].isNull())
-		data_.province.score = provinceNode["Score"].asString();
-	auto allKeyPoints37Node = provinceNode["KeyPoints"]["keyPointsItem"];
-	for (auto provinceNodeKeyPointskeyPointsItem : allKeyPoints37Node)
-	{
-		Data::Province::KeyPointsItem38 keyPointsItem38Object;
-		if(!provinceNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem38Object.x = std::stof(provinceNodeKeyPointskeyPointsItem["X"].asString());
-		if(!provinceNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem38Object.y = std::stof(provinceNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.province.keyPoints37.push_back(keyPointsItem38Object);
-	}
-	auto religionNode = dataNode["Religion"];
-	if(!religionNode["Text"].isNull())
-		data_.religion.text = religionNode["Text"].asString();
-	if(!religionNode["Score"].isNull())
-		data_.religion.score = religionNode["Score"].asString();
-	auto allKeyPoints39Node = religionNode["KeyPoints"]["keyPointsItem"];
-	for (auto religionNodeKeyPointskeyPointsItem : allKeyPoints39Node)
-	{
-		Data::Religion::KeyPointsItem40 keyPointsItem40Object;
-		if(!religionNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem40Object.x = std::stof(religionNodeKeyPointskeyPointsItem["X"].asString());
-		if(!religionNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem40Object.y = std::stof(religionNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.religion.keyPoints39.push_back(keyPointsItem40Object);
-	}
-	auto sexNode = dataNode["Sex"];
-	if(!sexNode["Text"].isNull())
-		data_.sex.text = sexNode["Text"].asString();
-	if(!sexNode["Score"].isNull())
-		data_.sex.score = sexNode["Score"].asString();
-	auto allKeyPoints41Node = sexNode["KeyPoints"]["keyPointsItem"];
-	for (auto sexNodeKeyPointskeyPointsItem : allKeyPoints41Node)
-	{
-		Data::Sex::KeyPointsItem42 keyPointsItem42Object;
-		if(!sexNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem42Object.x = std::stof(sexNodeKeyPointskeyPointsItem["X"].asString());
-		if(!sexNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem42Object.y = std::stof(sexNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.sex.keyPoints41.push_back(keyPointsItem42Object);
-	}
-	if(!value["Code"].isNull())
-		code_ = value["Code"].asString();
-	if(!value["Message"].isNull())
-		message_ = value["Message"].asString();
-
-}
-
-std::string RecognizeIndonesiaIdentityCardResult::getMessage()const
-{
-	return message_;
-}
-
-RecognizeIndonesiaIdentityCardResult::Data RecognizeIndonesiaIdentityCardResult::getData()const
-{
-	return data_;
-}
-
-std::string RecognizeIndonesiaIdentityCardResult::getCode()const
-{
-	return code_;
-}
-

ocr/src/model/RecognizeMalaysiaIdentityCardRequest.cc

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

ocr/src/model/RecognizeMalaysiaIdentityCardResult.cc

@@ -1,289 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/ocr/model/RecognizeMalaysiaIdentityCardResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Ocr;
-using namespace AlibabaCloud::Ocr::Model;
-
-RecognizeMalaysiaIdentityCardResult::RecognizeMalaysiaIdentityCardResult() :
-	ServiceResult()
-{}
-
-RecognizeMalaysiaIdentityCardResult::RecognizeMalaysiaIdentityCardResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-RecognizeMalaysiaIdentityCardResult::~RecognizeMalaysiaIdentityCardResult()
-{}
-
-void RecognizeMalaysiaIdentityCardResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto dataNode = value["Data"];
-	auto addressFirstLineNode = dataNode["AddressFirstLine"];
-	if(!addressFirstLineNode["Text"].isNull())
-		data_.addressFirstLine.text = addressFirstLineNode["Text"].asString();
-	if(!addressFirstLineNode["Score"].isNull())
-		data_.addressFirstLine.score = std::stof(addressFirstLineNode["Score"].asString());
-	auto allKeyPointsNode = addressFirstLineNode["KeyPoints"]["keyPointsItem"];
-	for (auto addressFirstLineNodeKeyPointskeyPointsItem : allKeyPointsNode)
-	{
-		Data::AddressFirstLine::KeyPointsItem keyPointsItemObject;
-		if(!addressFirstLineNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItemObject.x = std::stof(addressFirstLineNodeKeyPointskeyPointsItem["X"].asString());
-		if(!addressFirstLineNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItemObject.y = std::stof(addressFirstLineNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.addressFirstLine.keyPoints.push_back(keyPointsItemObject);
-	}
-	auto addressSecondLineNode = dataNode["AddressSecondLine"];
-	if(!addressSecondLineNode["Text"].isNull())
-		data_.addressSecondLine.text = addressSecondLineNode["Text"].asString();
-	if(!addressSecondLineNode["Score"].isNull())
-		data_.addressSecondLine.score = std::stof(addressSecondLineNode["Score"].asString());
-	auto allKeyPoints1Node = addressSecondLineNode["KeyPoints"]["keyPointsItem"];
-	for (auto addressSecondLineNodeKeyPointskeyPointsItem : allKeyPoints1Node)
-	{
-		Data::AddressSecondLine::KeyPointsItem2 keyPointsItem2Object;
-		if(!addressSecondLineNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem2Object.x = std::stof(addressSecondLineNodeKeyPointskeyPointsItem["X"].asString());
-		if(!addressSecondLineNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem2Object.y = std::stof(addressSecondLineNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.addressSecondLine.keyPoints1.push_back(keyPointsItem2Object);
-	}
-	auto addressThirdLineNode = dataNode["AddressThirdLine"];
-	if(!addressThirdLineNode["Text"].isNull())
-		data_.addressThirdLine.text = addressThirdLineNode["Text"].asString();
-	if(!addressThirdLineNode["Score"].isNull())
-		data_.addressThirdLine.score = std::stof(addressThirdLineNode["Score"].asString());
-	auto allKeyPoints3Node = addressThirdLineNode["KeyPoints"]["keyPointsItem"];
-	for (auto addressThirdLineNodeKeyPointskeyPointsItem : allKeyPoints3Node)
-	{
-		Data::AddressThirdLine::KeyPointsItem4 keyPointsItem4Object;
-		if(!addressThirdLineNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem4Object.x = std::stof(addressThirdLineNodeKeyPointskeyPointsItem["X"].asString());
-		if(!addressThirdLineNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem4Object.y = std::stof(addressThirdLineNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.addressThirdLine.keyPoints3.push_back(keyPointsItem4Object);
-	}
-	auto addressFourthLineNode = dataNode["AddressFourthLine"];
-	if(!addressFourthLineNode["Text"].isNull())
-		data_.addressFourthLine.text = addressFourthLineNode["Text"].asString();
-	if(!addressFourthLineNode["Score"].isNull())
-		data_.addressFourthLine.score = std::stof(addressFourthLineNode["Score"].asString());
-	auto allKeyPoints5Node = addressFourthLineNode["KeyPoints"]["keyPointsItem"];
-	for (auto addressFourthLineNodeKeyPointskeyPointsItem : allKeyPoints5Node)
-	{
-		Data::AddressFourthLine::KeyPointsItem6 keyPointsItem6Object;
-		if(!addressFourthLineNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem6Object.x = std::stof(addressFourthLineNodeKeyPointskeyPointsItem["X"].asString());
-		if(!addressFourthLineNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem6Object.y = std::stof(addressFourthLineNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.addressFourthLine.keyPoints5.push_back(keyPointsItem6Object);
-	}
-	auto addressFifthLineNode = dataNode["AddressFifthLine"];
-	if(!addressFifthLineNode["Text"].isNull())
-		data_.addressFifthLine.text = addressFifthLineNode["Text"].asString();
-	if(!addressFifthLineNode["Score"].isNull())
-		data_.addressFifthLine.score = std::stof(addressFifthLineNode["Score"].asString());
-	auto allKeyPoints7Node = addressFifthLineNode["KeyPoints"]["keyPointsItem"];
-	for (auto addressFifthLineNodeKeyPointskeyPointsItem : allKeyPoints7Node)
-	{
-		Data::AddressFifthLine::KeyPointsItem8 keyPointsItem8Object;
-		if(!addressFifthLineNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem8Object.x = std::stof(addressFifthLineNodeKeyPointskeyPointsItem["X"].asString());
-		if(!addressFifthLineNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem8Object.y = std::stof(addressFifthLineNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.addressFifthLine.keyPoints7.push_back(keyPointsItem8Object);
-	}
-	auto cardBoxNode = dataNode["CardBox"];
-	if(!cardBoxNode["Text"].isNull())
-		data_.cardBox.text = cardBoxNode["Text"].asString();
-	if(!cardBoxNode["Score"].isNull())
-		data_.cardBox.score = cardBoxNode["Score"].asString();
-	auto allKeyPoints9Node = cardBoxNode["KeyPoints"]["keyPointsItem"];
-	for (auto cardBoxNodeKeyPointskeyPointsItem : allKeyPoints9Node)
-	{
-		Data::CardBox::KeyPointsItem10 keyPointsItem10Object;
-		if(!cardBoxNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem10Object.x = std::stof(cardBoxNodeKeyPointskeyPointsItem["X"].asString());
-		if(!cardBoxNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem10Object.y = std::stof(cardBoxNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.cardBox.keyPoints9.push_back(keyPointsItem10Object);
-	}
-	auto driveClassNode = dataNode["DriveClass"];
-	if(!driveClassNode["Text"].isNull())
-		data_.driveClass.text = driveClassNode["Text"].asString();
-	if(!driveClassNode["Score"].isNull())
-		data_.driveClass.score = driveClassNode["Score"].asString();
-	auto allKeyPoints11Node = driveClassNode["KeyPoints"]["keyPointsItem"];
-	for (auto driveClassNodeKeyPointskeyPointsItem : allKeyPoints11Node)
-	{
-		Data::DriveClass::KeyPointsItem12 keyPointsItem12Object;
-		if(!driveClassNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem12Object.x = std::stof(driveClassNodeKeyPointskeyPointsItem["X"].asString());
-		if(!driveClassNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem12Object.y = std::stof(driveClassNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.driveClass.keyPoints11.push_back(keyPointsItem12Object);
-	}
-	auto expiryDateNode = dataNode["ExpiryDate"];
-	if(!expiryDateNode["Text"].isNull())
-		data_.expiryDate.text = expiryDateNode["Text"].asString();
-	if(!expiryDateNode["Score"].isNull())
-		data_.expiryDate.score = expiryDateNode["Score"].asString();
-	auto allKeyPoints13Node = expiryDateNode["KeyPoints"]["keyPointsItem"];
-	for (auto expiryDateNodeKeyPointskeyPointsItem : allKeyPoints13Node)
-	{
-		Data::ExpiryDate::KeyPointsItem14 keyPointsItem14Object;
-		if(!expiryDateNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem14Object.x = std::stof(expiryDateNodeKeyPointskeyPointsItem["X"].asString());
-		if(!expiryDateNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem14Object.y = std::stof(expiryDateNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.expiryDate.keyPoints13.push_back(keyPointsItem14Object);
-	}
-	auto idNumberNode = dataNode["IdNumber"];
-	if(!idNumberNode["Text"].isNull())
-		data_.idNumber.text = idNumberNode["Text"].asString();
-	if(!idNumberNode["Score"].isNull())
-		data_.idNumber.score = idNumberNode["Score"].asString();
-	auto allKeyPoints15Node = idNumberNode["KeyPoints"]["keyPointsItem"];
-	for (auto idNumberNodeKeyPointskeyPointsItem : allKeyPoints15Node)
-	{
-		Data::IdNumber::KeyPointsItem16 keyPointsItem16Object;
-		if(!idNumberNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem16Object.x = std::stof(idNumberNodeKeyPointskeyPointsItem["X"].asString());
-		if(!idNumberNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem16Object.y = std::stof(idNumberNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.idNumber.keyPoints15.push_back(keyPointsItem16Object);
-	}
-	auto issueDateNode = dataNode["IssueDate"];
-	if(!issueDateNode["Text"].isNull())
-		data_.issueDate.text = issueDateNode["Text"].asString();
-	if(!issueDateNode["Score"].isNull())
-		data_.issueDate.score = issueDateNode["Score"].asString();
-	auto allKeyPoints17Node = issueDateNode["KeyPoints"]["keyPointsItem"];
-	for (auto issueDateNodeKeyPointskeyPointsItem : allKeyPoints17Node)
-	{
-		Data::IssueDate::KeyPointsItem18 keyPointsItem18Object;
-		if(!issueDateNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem18Object.x = std::stof(issueDateNodeKeyPointskeyPointsItem["X"].asString());
-		if(!issueDateNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem18Object.y = std::stof(issueDateNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.issueDate.keyPoints17.push_back(keyPointsItem18Object);
-	}
-	auto nameFirstLineNode = dataNode["NameFirstLine"];
-	if(!nameFirstLineNode["Text"].isNull())
-		data_.nameFirstLine.text = nameFirstLineNode["Text"].asString();
-	if(!nameFirstLineNode["Score"].isNull())
-		data_.nameFirstLine.score = nameFirstLineNode["Score"].asString();
-	auto allKeyPoints19Node = nameFirstLineNode["KeyPoints"]["keyPointsItem"];
-	for (auto nameFirstLineNodeKeyPointskeyPointsItem : allKeyPoints19Node)
-	{
-		Data::NameFirstLine::KeyPointsItem20 keyPointsItem20Object;
-		if(!nameFirstLineNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem20Object.x = std::stof(nameFirstLineNodeKeyPointskeyPointsItem["X"].asString());
-		if(!nameFirstLineNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem20Object.y = std::stof(nameFirstLineNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.nameFirstLine.keyPoints19.push_back(keyPointsItem20Object);
-	}
-	auto nameSecondLineNode = dataNode["NameSecondLine"];
-	if(!nameSecondLineNode["Text"].isNull())
-		data_.nameSecondLine.text = nameSecondLineNode["Text"].asString();
-	if(!nameSecondLineNode["Score"].isNull())
-		data_.nameSecondLine.score = nameSecondLineNode["Score"].asString();
-	auto allKeyPoints21Node = nameSecondLineNode["KeyPoints"]["keyPointsItem"];
-	for (auto nameSecondLineNodeKeyPointskeyPointsItem : allKeyPoints21Node)
-	{
-		Data::NameSecondLine::KeyPointsItem22 keyPointsItem22Object;
-		if(!nameSecondLineNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem22Object.x = std::stof(nameSecondLineNodeKeyPointskeyPointsItem["X"].asString());
-		if(!nameSecondLineNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem22Object.y = std::stof(nameSecondLineNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.nameSecondLine.keyPoints21.push_back(keyPointsItem22Object);
-	}
-	auto nationalityNode = dataNode["Nationality"];
-	if(!nationalityNode["Text"].isNull())
-		data_.nationality.text = nationalityNode["Text"].asString();
-	if(!nationalityNode["Score"].isNull())
-		data_.nationality.score = nationalityNode["Score"].asString();
-	auto allKeyPoints23Node = nationalityNode["KeyPoints"]["keyPointsItem"];
-	for (auto nationalityNodeKeyPointskeyPointsItem : allKeyPoints23Node)
-	{
-		Data::Nationality::KeyPointsItem24 keyPointsItem24Object;
-		if(!nationalityNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem24Object.x = std::stof(nationalityNodeKeyPointskeyPointsItem["X"].asString());
-		if(!nationalityNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem24Object.y = std::stof(nationalityNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.nationality.keyPoints23.push_back(keyPointsItem24Object);
-	}
-	auto portraitBoxNode = dataNode["PortraitBox"];
-	if(!portraitBoxNode["Text"].isNull())
-		data_.portraitBox.text = portraitBoxNode["Text"].asString();
-	if(!portraitBoxNode["Score"].isNull())
-		data_.portraitBox.score = portraitBoxNode["Score"].asString();
-	auto allKeyPoints25Node = portraitBoxNode["KeyPoints"]["keyPointsItem"];
-	for (auto portraitBoxNodeKeyPointskeyPointsItem : allKeyPoints25Node)
-	{
-		Data::PortraitBox::KeyPointsItem26 keyPointsItem26Object;
-		if(!portraitBoxNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem26Object.x = std::stof(portraitBoxNodeKeyPointskeyPointsItem["X"].asString());
-		if(!portraitBoxNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem26Object.y = std::stof(portraitBoxNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.portraitBox.keyPoints25.push_back(keyPointsItem26Object);
-	}
-	auto sexNode = dataNode["Sex"];
-	if(!sexNode["Text"].isNull())
-		data_.sex.text = sexNode["Text"].asString();
-	if(!sexNode["Score"].isNull())
-		data_.sex.score = sexNode["Score"].asString();
-	auto allKeyPoints27Node = sexNode["KeyPoints"]["keyPointsItem"];
-	for (auto sexNodeKeyPointskeyPointsItem : allKeyPoints27Node)
-	{
-		Data::Sex::KeyPointsItem28 keyPointsItem28Object;
-		if(!sexNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem28Object.x = std::stof(sexNodeKeyPointskeyPointsItem["X"].asString());
-		if(!sexNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem28Object.y = std::stof(sexNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.sex.keyPoints27.push_back(keyPointsItem28Object);
-	}
-	if(!value["Code"].isNull())
-		code_ = value["Code"].asString();
-	if(!value["Message"].isNull())
-		message_ = value["Message"].asString();
-
-}
-
-std::string RecognizeMalaysiaIdentityCardResult::getMessage()const
-{
-	return message_;
-}
-
-RecognizeMalaysiaIdentityCardResult::Data RecognizeMalaysiaIdentityCardResult::getData()const
-{
-	return data_;
-}
-
-std::string RecognizeMalaysiaIdentityCardResult::getCode()const
-{
-	return code_;
-}
-

ocr/src/model/RecognizeRussiaIdentityCardRequest.cc

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

ocr/src/model/RecognizeRussiaIdentityCardResult.cc

@@ -1,244 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/ocr/model/RecognizeRussiaIdentityCardResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Ocr;
-using namespace AlibabaCloud::Ocr::Model;
-
-RecognizeRussiaIdentityCardResult::RecognizeRussiaIdentityCardResult() :
-	ServiceResult()
-{}
-
-RecognizeRussiaIdentityCardResult::RecognizeRussiaIdentityCardResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-RecognizeRussiaIdentityCardResult::~RecognizeRussiaIdentityCardResult()
-{}
-
-void RecognizeRussiaIdentityCardResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto dataNode = value["Data"];
-	auto birthDateNode = dataNode["BirthDate"];
-	if(!birthDateNode["Text"].isNull())
-		data_.birthDate.text = birthDateNode["Text"].asString();
-	if(!birthDateNode["Score"].isNull())
-		data_.birthDate.score = std::stof(birthDateNode["Score"].asString());
-	auto allKeyPointsNode = birthDateNode["KeyPoints"]["keyPointsItem"];
-	for (auto birthDateNodeKeyPointskeyPointsItem : allKeyPointsNode)
-	{
-		Data::BirthDate::KeyPointsItem keyPointsItemObject;
-		if(!birthDateNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItemObject.x = std::stof(birthDateNodeKeyPointskeyPointsItem["X"].asString());
-		if(!birthDateNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItemObject.y = std::stof(birthDateNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.birthDate.keyPoints.push_back(keyPointsItemObject);
-	}
-	auto birthPlaceFirstLineNode = dataNode["BirthPlaceFirstLine"];
-	if(!birthPlaceFirstLineNode["Text"].isNull())
-		data_.birthPlaceFirstLine.text = birthPlaceFirstLineNode["Text"].asString();
-	if(!birthPlaceFirstLineNode["Score"].isNull())
-		data_.birthPlaceFirstLine.score = std::stof(birthPlaceFirstLineNode["Score"].asString());
-	auto allKeyPoints1Node = birthPlaceFirstLineNode["KeyPoints"]["keyPointsItem"];
-	for (auto birthPlaceFirstLineNodeKeyPointskeyPointsItem : allKeyPoints1Node)
-	{
-		Data::BirthPlaceFirstLine::KeyPointsItem2 keyPointsItem2Object;
-		if(!birthPlaceFirstLineNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem2Object.x = std::stof(birthPlaceFirstLineNodeKeyPointskeyPointsItem["X"].asString());
-		if(!birthPlaceFirstLineNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem2Object.y = std::stof(birthPlaceFirstLineNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.birthPlaceFirstLine.keyPoints1.push_back(keyPointsItem2Object);
-	}
-	auto birthPlaceSecondLineNode = dataNode["BirthPlaceSecondLine"];
-	if(!birthPlaceSecondLineNode["Text"].isNull())
-		data_.birthPlaceSecondLine.text = birthPlaceSecondLineNode["Text"].asString();
-	if(!birthPlaceSecondLineNode["Score"].isNull())
-		data_.birthPlaceSecondLine.score = std::stof(birthPlaceSecondLineNode["Score"].asString());
-	auto allKeyPoints3Node = birthPlaceSecondLineNode["KeyPoints"]["keyPointsItem"];
-	for (auto birthPlaceSecondLineNodeKeyPointskeyPointsItem : allKeyPoints3Node)
-	{
-		Data::BirthPlaceSecondLine::KeyPointsItem4 keyPointsItem4Object;
-		if(!birthPlaceSecondLineNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem4Object.x = std::stof(birthPlaceSecondLineNodeKeyPointskeyPointsItem["X"].asString());
-		if(!birthPlaceSecondLineNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem4Object.y = std::stof(birthPlaceSecondLineNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.birthPlaceSecondLine.keyPoints3.push_back(keyPointsItem4Object);
-	}
-	auto birthPlaceThirdLineNode = dataNode["BirthPlaceThirdLine"];
-	if(!birthPlaceThirdLineNode["Text"].isNull())
-		data_.birthPlaceThirdLine.text = birthPlaceThirdLineNode["Text"].asString();
-	if(!birthPlaceThirdLineNode["Score"].isNull())
-		data_.birthPlaceThirdLine.score = std::stof(birthPlaceThirdLineNode["Score"].asString());
-	auto allKeyPoints5Node = birthPlaceThirdLineNode["KeyPoints"]["keyPointsItem"];
-	for (auto birthPlaceThirdLineNodeKeyPointskeyPointsItem : allKeyPoints5Node)
-	{
-		Data::BirthPlaceThirdLine::KeyPointsItem6 keyPointsItem6Object;
-		if(!birthPlaceThirdLineNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem6Object.x = std::stof(birthPlaceThirdLineNodeKeyPointskeyPointsItem["X"].asString());
-		if(!birthPlaceThirdLineNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem6Object.y = std::stof(birthPlaceThirdLineNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.birthPlaceThirdLine.keyPoints5.push_back(keyPointsItem6Object);
-	}
-	auto cardBoxNode = dataNode["CardBox"];
-	if(!cardBoxNode["Text"].isNull())
-		data_.cardBox.text = cardBoxNode["Text"].asString();
-	if(!cardBoxNode["Score"].isNull())
-		data_.cardBox.score = cardBoxNode["Score"].asString();
-	auto allKeyPoints7Node = cardBoxNode["KeyPoints"]["keyPointsItem"];
-	for (auto cardBoxNodeKeyPointskeyPointsItem : allKeyPoints7Node)
-	{
-		Data::CardBox::KeyPointsItem8 keyPointsItem8Object;
-		if(!cardBoxNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem8Object.x = std::stof(cardBoxNodeKeyPointskeyPointsItem["X"].asString());
-		if(!cardBoxNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem8Object.y = std::stof(cardBoxNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.cardBox.keyPoints7.push_back(keyPointsItem8Object);
-	}
-	auto givenNameNode = dataNode["GivenName"];
-	if(!givenNameNode["Text"].isNull())
-		data_.givenName.text = givenNameNode["Text"].asString();
-	if(!givenNameNode["Score"].isNull())
-		data_.givenName.score = givenNameNode["Score"].asString();
-	auto allKeyPoints9Node = givenNameNode["KeyPoints"]["keyPointsItem"];
-	for (auto givenNameNodeKeyPointskeyPointsItem : allKeyPoints9Node)
-	{
-		Data::GivenName::KeyPointsItem10 keyPointsItem10Object;
-		if(!givenNameNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem10Object.x = std::stof(givenNameNodeKeyPointskeyPointsItem["X"].asString());
-		if(!givenNameNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem10Object.y = std::stof(givenNameNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.givenName.keyPoints9.push_back(keyPointsItem10Object);
-	}
-	auto idNumberNode = dataNode["IdNumber"];
-	if(!idNumberNode["Text"].isNull())
-		data_.idNumber.text = idNumberNode["Text"].asString();
-	if(!idNumberNode["Score"].isNull())
-		data_.idNumber.score = idNumberNode["Score"].asString();
-	auto allKeyPoints11Node = idNumberNode["KeyPoints"]["keyPointsItem"];
-	for (auto idNumberNodeKeyPointskeyPointsItem : allKeyPoints11Node)
-	{
-		Data::IdNumber::KeyPointsItem12 keyPointsItem12Object;
-		if(!idNumberNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem12Object.x = std::stof(idNumberNodeKeyPointskeyPointsItem["X"].asString());
-		if(!idNumberNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem12Object.y = std::stof(idNumberNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.idNumber.keyPoints11.push_back(keyPointsItem12Object);
-	}
-	auto paternalNameNode = dataNode["PaternalName"];
-	if(!paternalNameNode["Text"].isNull())
-		data_.paternalName.text = paternalNameNode["Text"].asString();
-	if(!paternalNameNode["Score"].isNull())
-		data_.paternalName.score = paternalNameNode["Score"].asString();
-	auto allKeyPoints13Node = paternalNameNode["KeyPoints"]["keyPointsItem"];
-	for (auto paternalNameNodeKeyPointskeyPointsItem : allKeyPoints13Node)
-	{
-		Data::PaternalName::KeyPointsItem14 keyPointsItem14Object;
-		if(!paternalNameNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem14Object.x = std::stof(paternalNameNodeKeyPointskeyPointsItem["X"].asString());
-		if(!paternalNameNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem14Object.y = std::stof(paternalNameNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.paternalName.keyPoints13.push_back(keyPointsItem14Object);
-	}
-	auto portraitBoxNode = dataNode["PortraitBox"];
-	if(!portraitBoxNode["Text"].isNull())
-		data_.portraitBox.text = portraitBoxNode["Text"].asString();
-	if(!portraitBoxNode["Score"].isNull())
-		data_.portraitBox.score = portraitBoxNode["Score"].asString();
-	auto allKeyPoints15Node = portraitBoxNode["KeyPoints"]["keyPointsItem"];
-	for (auto portraitBoxNodeKeyPointskeyPointsItem : allKeyPoints15Node)
-	{
-		Data::PortraitBox::KeyPointsItem16 keyPointsItem16Object;
-		if(!portraitBoxNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem16Object.x = std::stof(portraitBoxNodeKeyPointskeyPointsItem["X"].asString());
-		if(!portraitBoxNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem16Object.y = std::stof(portraitBoxNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.portraitBox.keyPoints15.push_back(keyPointsItem16Object);
-	}
-	auto sexNode = dataNode["Sex"];
-	if(!sexNode["Text"].isNull())
-		data_.sex.text = sexNode["Text"].asString();
-	if(!sexNode["Score"].isNull())
-		data_.sex.score = sexNode["Score"].asString();
-	auto allKeyPoints17Node = sexNode["KeyPoints"]["keyPointsItem"];
-	for (auto sexNodeKeyPointskeyPointsItem : allKeyPoints17Node)
-	{
-		Data::Sex::KeyPointsItem18 keyPointsItem18Object;
-		if(!sexNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem18Object.x = std::stof(sexNodeKeyPointskeyPointsItem["X"].asString());
-		if(!sexNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem18Object.y = std::stof(sexNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.sex.keyPoints17.push_back(keyPointsItem18Object);
-	}
-	auto surnameFirstLineNode = dataNode["SurnameFirstLine"];
-	if(!surnameFirstLineNode["Text"].isNull())
-		data_.surnameFirstLine.text = surnameFirstLineNode["Text"].asString();
-	if(!surnameFirstLineNode["Score"].isNull())
-		data_.surnameFirstLine.score = surnameFirstLineNode["Score"].asString();
-	auto allKeyPoints19Node = surnameFirstLineNode["KeyPoints"]["keyPointsItem"];
-	for (auto surnameFirstLineNodeKeyPointskeyPointsItem : allKeyPoints19Node)
-	{
-		Data::SurnameFirstLine::KeyPointsItem20 keyPointsItem20Object;
-		if(!surnameFirstLineNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem20Object.x = std::stof(surnameFirstLineNodeKeyPointskeyPointsItem["X"].asString());
-		if(!surnameFirstLineNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem20Object.y = std::stof(surnameFirstLineNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.surnameFirstLine.keyPoints19.push_back(keyPointsItem20Object);
-	}
-	auto surnameSecondLineNode = dataNode["SurnameSecondLine"];
-	if(!surnameSecondLineNode["Text"].isNull())
-		data_.surnameSecondLine.text = surnameSecondLineNode["Text"].asString();
-	if(!surnameSecondLineNode["Score"].isNull())
-		data_.surnameSecondLine.score = surnameSecondLineNode["Score"].asString();
-	auto allKeyPoints21Node = surnameSecondLineNode["KeyPoints"]["keyPointsItem"];
-	for (auto surnameSecondLineNodeKeyPointskeyPointsItem : allKeyPoints21Node)
-	{
-		Data::SurnameSecondLine::KeyPointsItem22 keyPointsItem22Object;
-		if(!surnameSecondLineNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem22Object.x = std::stof(surnameSecondLineNodeKeyPointskeyPointsItem["X"].asString());
-		if(!surnameSecondLineNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem22Object.y = std::stof(surnameSecondLineNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.surnameSecondLine.keyPoints21.push_back(keyPointsItem22Object);
-	}
-	if(!value["Code"].isNull())
-		code_ = value["Code"].asString();
-	if(!value["Message"].isNull())
-		message_ = value["Message"].asString();
-
-}
-
-std::string RecognizeRussiaIdentityCardResult::getMessage()const
-{
-	return message_;
-}
-
-RecognizeRussiaIdentityCardResult::Data RecognizeRussiaIdentityCardResult::getData()const
-{
-	return data_;
-}
-
-std::string RecognizeRussiaIdentityCardResult::getCode()const
-{
-	return code_;
-}
-

ocr/src/model/RecognizeTurkeyIdentityCardRequest.cc

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

ocr/src/model/RecognizeTurkeyIdentityCardResult.cc

@@ -1,724 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/ocr/model/RecognizeTurkeyIdentityCardResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Ocr;
-using namespace AlibabaCloud::Ocr::Model;
-
-RecognizeTurkeyIdentityCardResult::RecognizeTurkeyIdentityCardResult() :
-	ServiceResult()
-{}
-
-RecognizeTurkeyIdentityCardResult::RecognizeTurkeyIdentityCardResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-RecognizeTurkeyIdentityCardResult::~RecognizeTurkeyIdentityCardResult()
-{}
-
-void RecognizeTurkeyIdentityCardResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto dataNode = value["Data"];
-	auto auxiliaryToolsNode = dataNode["AuxiliaryTools"];
-	if(!auxiliaryToolsNode["Text"].isNull())
-		data_.auxiliaryTools.text = auxiliaryToolsNode["Text"].asString();
-	if(!auxiliaryToolsNode["Score"].isNull())
-		data_.auxiliaryTools.score = std::stof(auxiliaryToolsNode["Score"].asString());
-	auto allKeyPointsNode = auxiliaryToolsNode["KeyPoints"]["keyPointsItem"];
-	for (auto auxiliaryToolsNodeKeyPointskeyPointsItem : allKeyPointsNode)
-	{
-		Data::AuxiliaryTools::KeyPointsItem keyPointsItemObject;
-		if(!auxiliaryToolsNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItemObject.x = std::stof(auxiliaryToolsNodeKeyPointskeyPointsItem["X"].asString());
-		if(!auxiliaryToolsNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItemObject.y = std::stof(auxiliaryToolsNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.auxiliaryTools.keyPoints.push_back(keyPointsItemObject);
-	}
-	auto birthDateNode = dataNode["BirthDate"];
-	if(!birthDateNode["Text"].isNull())
-		data_.birthDate.text = birthDateNode["Text"].asString();
-	if(!birthDateNode["Score"].isNull())
-		data_.birthDate.score = std::stof(birthDateNode["Score"].asString());
-	auto allKeyPoints1Node = birthDateNode["KeyPoints"]["keyPointsItem"];
-	for (auto birthDateNodeKeyPointskeyPointsItem : allKeyPoints1Node)
-	{
-		Data::BirthDate::KeyPointsItem2 keyPointsItem2Object;
-		if(!birthDateNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem2Object.x = std::stof(birthDateNodeKeyPointskeyPointsItem["X"].asString());
-		if(!birthDateNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem2Object.y = std::stof(birthDateNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.birthDate.keyPoints1.push_back(keyPointsItem2Object);
-	}
-	auto birthPlaceNode = dataNode["BirthPlace"];
-	if(!birthPlaceNode["Text"].isNull())
-		data_.birthPlace.text = birthPlaceNode["Text"].asString();
-	if(!birthPlaceNode["Score"].isNull())
-		data_.birthPlace.score = std::stof(birthPlaceNode["Score"].asString());
-	auto allKeyPoints3Node = birthPlaceNode["KeyPoints"]["keyPointsItem"];
-	for (auto birthPlaceNodeKeyPointskeyPointsItem : allKeyPoints3Node)
-	{
-		Data::BirthPlace::KeyPointsItem4 keyPointsItem4Object;
-		if(!birthPlaceNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem4Object.x = std::stof(birthPlaceNodeKeyPointskeyPointsItem["X"].asString());
-		if(!birthPlaceNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem4Object.y = std::stof(birthPlaceNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.birthPlace.keyPoints3.push_back(keyPointsItem4Object);
-	}
-	auto bloodTypeNode = dataNode["BloodType"];
-	if(!bloodTypeNode["Text"].isNull())
-		data_.bloodType.text = bloodTypeNode["Text"].asString();
-	if(!bloodTypeNode["Score"].isNull())
-		data_.bloodType.score = std::stof(bloodTypeNode["Score"].asString());
-	auto allKeyPoints5Node = bloodTypeNode["KeyPoints"]["keyPointsItem"];
-	for (auto bloodTypeNodeKeyPointskeyPointsItem : allKeyPoints5Node)
-	{
-		Data::BloodType::KeyPointsItem6 keyPointsItem6Object;
-		if(!bloodTypeNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem6Object.x = std::stof(bloodTypeNodeKeyPointskeyPointsItem["X"].asString());
-		if(!bloodTypeNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem6Object.y = std::stof(bloodTypeNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.bloodType.keyPoints5.push_back(keyPointsItem6Object);
-	}
-	auto cardBoxNode = dataNode["CardBox"];
-	if(!cardBoxNode["Text"].isNull())
-		data_.cardBox.text = cardBoxNode["Text"].asString();
-	if(!cardBoxNode["Score"].isNull())
-		data_.cardBox.score = std::stof(cardBoxNode["Score"].asString());
-	auto allKeyPoints7Node = cardBoxNode["KeyPoints"]["keyPointsItem"];
-	for (auto cardBoxNodeKeyPointskeyPointsItem : allKeyPoints7Node)
-	{
-		Data::CardBox::KeyPointsItem8 keyPointsItem8Object;
-		if(!cardBoxNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem8Object.x = std::stof(cardBoxNodeKeyPointskeyPointsItem["X"].asString());
-		if(!cardBoxNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem8Object.y = std::stof(cardBoxNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.cardBox.keyPoints7.push_back(keyPointsItem8Object);
-	}
-	auto ciltNode = dataNode["Cilt"];
-	if(!ciltNode["Text"].isNull())
-		data_.cilt.text = ciltNode["Text"].asString();
-	if(!ciltNode["Score"].isNull())
-		data_.cilt.score = std::stof(ciltNode["Score"].asString());
-	auto allKeyPoints9Node = ciltNode["KeyPoints"]["keyPointsItem"];
-	for (auto ciltNodeKeyPointskeyPointsItem : allKeyPoints9Node)
-	{
-		Data::Cilt::KeyPointsItem10 keyPointsItem10Object;
-		if(!ciltNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem10Object.x = std::stof(ciltNodeKeyPointskeyPointsItem["X"].asString());
-		if(!ciltNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem10Object.y = std::stof(ciltNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.cilt.keyPoints9.push_back(keyPointsItem10Object);
-	}
-	auto documentNumberNode = dataNode["DocumentNumber"];
-	if(!documentNumberNode["Text"].isNull())
-		data_.documentNumber.text = documentNumberNode["Text"].asString();
-	if(!documentNumberNode["Score"].isNull())
-		data_.documentNumber.score = std::stof(documentNumberNode["Score"].asString());
-	auto allKeyPoints11Node = documentNumberNode["KeyPoints"]["keyPointsItem"];
-	for (auto documentNumberNodeKeyPointskeyPointsItem : allKeyPoints11Node)
-	{
-		Data::DocumentNumber::KeyPointsItem12 keyPointsItem12Object;
-		if(!documentNumberNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem12Object.x = std::stof(documentNumberNodeKeyPointskeyPointsItem["X"].asString());
-		if(!documentNumberNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem12Object.y = std::stof(documentNumberNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.documentNumber.keyPoints11.push_back(keyPointsItem12Object);
-	}
-	auto driveClassNode = dataNode["DriveClass"];
-	if(!driveClassNode["Text"].isNull())
-		data_.driveClass.text = driveClassNode["Text"].asString();
-	if(!driveClassNode["Score"].isNull())
-		data_.driveClass.score = std::stof(driveClassNode["Score"].asString());
-	auto allKeyPoints13Node = driveClassNode["KeyPoints"]["keyPointsItem"];
-	for (auto driveClassNodeKeyPointskeyPointsItem : allKeyPoints13Node)
-	{
-		Data::DriveClass::KeyPointsItem14 keyPointsItem14Object;
-		if(!driveClassNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem14Object.x = std::stof(driveClassNodeKeyPointskeyPointsItem["X"].asString());
-		if(!driveClassNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem14Object.y = std::stof(driveClassNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.driveClass.keyPoints13.push_back(keyPointsItem14Object);
-	}
-	auto dueDateNode = dataNode["DueDate"];
-	if(!dueDateNode["Text"].isNull())
-		data_.dueDate.text = dueDateNode["Text"].asString();
-	if(!dueDateNode["Score"].isNull())
-		data_.dueDate.score = std::stof(dueDateNode["Score"].asString());
-	auto allKeyPoints15Node = dueDateNode["KeyPoints"]["keyPointsItem"];
-	for (auto dueDateNodeKeyPointskeyPointsItem : allKeyPoints15Node)
-	{
-		Data::DueDate::KeyPointsItem16 keyPointsItem16Object;
-		if(!dueDateNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem16Object.x = std::stof(dueDateNodeKeyPointskeyPointsItem["X"].asString());
-		if(!dueDateNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem16Object.y = std::stof(dueDateNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.dueDate.keyPoints15.push_back(keyPointsItem16Object);
-	}
-	auto duzenleyenNode = dataNode["Duzenleyen"];
-	if(!duzenleyenNode["Text"].isNull())
-		data_.duzenleyen.text = duzenleyenNode["Text"].asString();
-	if(!duzenleyenNode["Score"].isNull())
-		data_.duzenleyen.score = std::stof(duzenleyenNode["Score"].asString());
-	auto allKeyPoints17Node = duzenleyenNode["KeyPoints"]["keyPointsItem"];
-	for (auto duzenleyenNodeKeyPointskeyPointsItem : allKeyPoints17Node)
-	{
-		Data::Duzenleyen::KeyPointsItem18 keyPointsItem18Object;
-		if(!duzenleyenNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem18Object.x = std::stof(duzenleyenNodeKeyPointskeyPointsItem["X"].asString());
-		if(!duzenleyenNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem18Object.y = std::stof(duzenleyenNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.duzenleyen.keyPoints17.push_back(keyPointsItem18Object);
-	}
-	auto entryNumberNode = dataNode["EntryNumber"];
-	if(!entryNumberNode["Text"].isNull())
-		data_.entryNumber.text = entryNumberNode["Text"].asString();
-	if(!entryNumberNode["Score"].isNull())
-		data_.entryNumber.score = std::stof(entryNumberNode["Score"].asString());
-	auto allKeyPoints19Node = entryNumberNode["KeyPoints"]["keyPointsItem"];
-	for (auto entryNumberNodeKeyPointskeyPointsItem : allKeyPoints19Node)
-	{
-		Data::EntryNumber::KeyPointsItem20 keyPointsItem20Object;
-		if(!entryNumberNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem20Object.x = std::stof(entryNumberNodeKeyPointskeyPointsItem["X"].asString());
-		if(!entryNumberNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem20Object.y = std::stof(entryNumberNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.entryNumber.keyPoints19.push_back(keyPointsItem20Object);
-	}
-	auto expiryDateNode = dataNode["ExpiryDate"];
-	if(!expiryDateNode["Text"].isNull())
-		data_.expiryDate.text = expiryDateNode["Text"].asString();
-	if(!expiryDateNode["Score"].isNull())
-		data_.expiryDate.score = std::stof(expiryDateNode["Score"].asString());
-	auto allKeyPoints21Node = expiryDateNode["KeyPoints"]["keyPointsItem"];
-	for (auto expiryDateNodeKeyPointskeyPointsItem : allKeyPoints21Node)
-	{
-		Data::ExpiryDate::KeyPointsItem22 keyPointsItem22Object;
-		if(!expiryDateNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem22Object.x = std::stof(expiryDateNodeKeyPointskeyPointsItem["X"].asString());
-		if(!expiryDateNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem22Object.y = std::stof(expiryDateNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.expiryDate.keyPoints21.push_back(keyPointsItem22Object);
-	}
-	auto fatherNameNode = dataNode["FatherName"];
-	if(!fatherNameNode["Text"].isNull())
-		data_.fatherName.text = fatherNameNode["Text"].asString();
-	if(!fatherNameNode["Score"].isNull())
-		data_.fatherName.score = std::stof(fatherNameNode["Score"].asString());
-	auto allKeyPoints23Node = fatherNameNode["KeyPoints"]["keyPointsItem"];
-	for (auto fatherNameNodeKeyPointskeyPointsItem : allKeyPoints23Node)
-	{
-		Data::FatherName::KeyPointsItem24 keyPointsItem24Object;
-		if(!fatherNameNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem24Object.x = std::stof(fatherNameNodeKeyPointskeyPointsItem["X"].asString());
-		if(!fatherNameNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem24Object.y = std::stof(fatherNameNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.fatherName.keyPoints23.push_back(keyPointsItem24Object);
-	}
-	auto foreignersIdNode = dataNode["ForeignersId"];
-	if(!foreignersIdNode["Text"].isNull())
-		data_.foreignersId.text = foreignersIdNode["Text"].asString();
-	if(!foreignersIdNode["Score"].isNull())
-		data_.foreignersId.score = std::stof(foreignersIdNode["Score"].asString());
-	auto allKeyPoints25Node = foreignersIdNode["KeyPoints"]["keyPointsItem"];
-	for (auto foreignersIdNodeKeyPointskeyPointsItem : allKeyPoints25Node)
-	{
-		Data::ForeignersId::KeyPointsItem26 keyPointsItem26Object;
-		if(!foreignersIdNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem26Object.x = std::stof(foreignersIdNodeKeyPointskeyPointsItem["X"].asString());
-		if(!foreignersIdNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem26Object.y = std::stof(foreignersIdNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.foreignersId.keyPoints25.push_back(keyPointsItem26Object);
-	}
-	auto genderNode = dataNode["Gender"];
-	if(!genderNode["Text"].isNull())
-		data_.gender.text = genderNode["Text"].asString();
-	if(!genderNode["Score"].isNull())
-		data_.gender.score = std::stof(genderNode["Score"].asString());
-	auto allKeyPoints27Node = genderNode["KeyPoints"]["keyPointsItem"];
-	for (auto genderNodeKeyPointskeyPointsItem : allKeyPoints27Node)
-	{
-		Data::Gender::KeyPointsItem28 keyPointsItem28Object;
-		if(!genderNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem28Object.x = std::stof(genderNodeKeyPointskeyPointsItem["X"].asString());
-		if(!genderNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem28Object.y = std::stof(genderNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.gender.keyPoints27.push_back(keyPointsItem28Object);
-	}
-	auto givenNameNode = dataNode["GivenName"];
-	if(!givenNameNode["Text"].isNull())
-		data_.givenName.text = givenNameNode["Text"].asString();
-	if(!givenNameNode["Score"].isNull())
-		data_.givenName.score = std::stof(givenNameNode["Score"].asString());
-	auto allKeyPoints29Node = givenNameNode["KeyPoints"]["keyPointsItem"];
-	for (auto givenNameNodeKeyPointskeyPointsItem : allKeyPoints29Node)
-	{
-		Data::GivenName::KeyPointsItem30 keyPointsItem30Object;
-		if(!givenNameNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem30Object.x = std::stof(givenNameNodeKeyPointskeyPointsItem["X"].asString());
-		if(!givenNameNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem30Object.y = std::stof(givenNameNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.givenName.keyPoints29.push_back(keyPointsItem30Object);
-	}
-	auto idNumberNode = dataNode["IdNumber"];
-	if(!idNumberNode["Text"].isNull())
-		data_.idNumber.text = idNumberNode["Text"].asString();
-	if(!idNumberNode["Score"].isNull())
-		data_.idNumber.score = std::stof(idNumberNode["Score"].asString());
-	auto allKeyPoints31Node = idNumberNode["KeyPoints"]["keyPointsItem"];
-	for (auto idNumberNodeKeyPointskeyPointsItem : allKeyPoints31Node)
-	{
-		Data::IdNumber::KeyPointsItem32 keyPointsItem32Object;
-		if(!idNumberNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem32Object.x = std::stof(idNumberNodeKeyPointskeyPointsItem["X"].asString());
-		if(!idNumberNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem32Object.y = std::stof(idNumberNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.idNumber.keyPoints31.push_back(keyPointsItem32Object);
-	}
-	auto issueByNode = dataNode["IssueBy"];
-	if(!issueByNode["Text"].isNull())
-		data_.issueBy.text = issueByNode["Text"].asString();
-	if(!issueByNode["Score"].isNull())
-		data_.issueBy.score = std::stof(issueByNode["Score"].asString());
-	auto allKeyPoints33Node = issueByNode["KeyPoints"]["keyPointsItem"];
-	for (auto issueByNodeKeyPointskeyPointsItem : allKeyPoints33Node)
-	{
-		Data::IssueBy::KeyPointsItem34 keyPointsItem34Object;
-		if(!issueByNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem34Object.x = std::stof(issueByNodeKeyPointskeyPointsItem["X"].asString());
-		if(!issueByNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem34Object.y = std::stof(issueByNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.issueBy.keyPoints33.push_back(keyPointsItem34Object);
-	}
-	auto issueCountyNode = dataNode["IssueCounty"];
-	if(!issueCountyNode["Text"].isNull())
-		data_.issueCounty.text = issueCountyNode["Text"].asString();
-	if(!issueCountyNode["Score"].isNull())
-		data_.issueCounty.score = std::stof(issueCountyNode["Score"].asString());
-	auto allKeyPoints35Node = issueCountyNode["KeyPoints"]["keyPointsItem"];
-	for (auto issueCountyNodeKeyPointskeyPointsItem : allKeyPoints35Node)
-	{
-		Data::IssueCounty::KeyPointsItem36 keyPointsItem36Object;
-		if(!issueCountyNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem36Object.x = std::stof(issueCountyNodeKeyPointskeyPointsItem["X"].asString());
-		if(!issueCountyNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem36Object.y = std::stof(issueCountyNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.issueCounty.keyPoints35.push_back(keyPointsItem36Object);
-	}
-	auto issueDateNode = dataNode["IssueDate"];
-	if(!issueDateNode["Text"].isNull())
-		data_.issueDate.text = issueDateNode["Text"].asString();
-	if(!issueDateNode["Score"].isNull())
-		data_.issueDate.score = std::stof(issueDateNode["Score"].asString());
-	auto allKeyPoints37Node = issueDateNode["KeyPoints"]["keyPointsItem"];
-	for (auto issueDateNodeKeyPointskeyPointsItem : allKeyPoints37Node)
-	{
-		Data::IssueDate::KeyPointsItem38 keyPointsItem38Object;
-		if(!issueDateNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem38Object.x = std::stof(issueDateNodeKeyPointskeyPointsItem["X"].asString());
-		if(!issueDateNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem38Object.y = std::stof(issueDateNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.issueDate.keyPoints37.push_back(keyPointsItem38Object);
-	}
-	auto issuePlaceNode = dataNode["IssuePlace"];
-	if(!issuePlaceNode["Text"].isNull())
-		data_.issuePlace.text = issuePlaceNode["Text"].asString();
-	if(!issuePlaceNode["Score"].isNull())
-		data_.issuePlace.score = std::stof(issuePlaceNode["Score"].asString());
-	auto allKeyPoints39Node = issuePlaceNode["KeyPoints"]["keyPointsItem"];
-	for (auto issuePlaceNodeKeyPointskeyPointsItem : allKeyPoints39Node)
-	{
-		Data::IssuePlace::KeyPointsItem40 keyPointsItem40Object;
-		if(!issuePlaceNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem40Object.x = std::stof(issuePlaceNodeKeyPointskeyPointsItem["X"].asString());
-		if(!issuePlaceNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem40Object.y = std::stof(issuePlaceNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.issuePlace.keyPoints39.push_back(keyPointsItem40Object);
-	}
-	auto kutukNode = dataNode["Kutuk"];
-	if(!kutukNode["Text"].isNull())
-		data_.kutuk.text = kutukNode["Text"].asString();
-	if(!kutukNode["Score"].isNull())
-		data_.kutuk.score = std::stof(kutukNode["Score"].asString());
-	auto allKeyPoints41Node = kutukNode["KeyPoints"]["keyPointsItem"];
-	for (auto kutukNodeKeyPointskeyPointsItem : allKeyPoints41Node)
-	{
-		Data::Kutuk::KeyPointsItem42 keyPointsItem42Object;
-		if(!kutukNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem42Object.x = std::stof(kutukNodeKeyPointskeyPointsItem["X"].asString());
-		if(!kutukNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem42Object.y = std::stof(kutukNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.kutuk.keyPoints41.push_back(keyPointsItem42Object);
-	}
-	auto licenseNumberNode = dataNode["LicenseNumber"];
-	if(!licenseNumberNode["Text"].isNull())
-		data_.licenseNumber.text = licenseNumberNode["Text"].asString();
-	if(!licenseNumberNode["Score"].isNull())
-		data_.licenseNumber.score = std::stof(licenseNumberNode["Score"].asString());
-	auto allKeyPoints43Node = licenseNumberNode["KeyPoints"]["keyPointsItem"];
-	for (auto licenseNumberNodeKeyPointskeyPointsItem : allKeyPoints43Node)
-	{
-		Data::LicenseNumber::KeyPointsItem44 keyPointsItem44Object;
-		if(!licenseNumberNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem44Object.x = std::stof(licenseNumberNodeKeyPointskeyPointsItem["X"].asString());
-		if(!licenseNumberNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem44Object.y = std::stof(licenseNumberNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.licenseNumber.keyPoints43.push_back(keyPointsItem44Object);
-	}
-	auto maritalStatusNode = dataNode["MaritalStatus"];
-	if(!maritalStatusNode["Text"].isNull())
-		data_.maritalStatus.text = maritalStatusNode["Text"].asString();
-	if(!maritalStatusNode["Score"].isNull())
-		data_.maritalStatus.score = std::stof(maritalStatusNode["Score"].asString());
-	auto allKeyPoints45Node = maritalStatusNode["KeyPoints"]["keyPointsItem"];
-	for (auto maritalStatusNodeKeyPointskeyPointsItem : allKeyPoints45Node)
-	{
-		Data::MaritalStatus::KeyPointsItem46 keyPointsItem46Object;
-		if(!maritalStatusNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem46Object.x = std::stof(maritalStatusNodeKeyPointskeyPointsItem["X"].asString());
-		if(!maritalStatusNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem46Object.y = std::stof(maritalStatusNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.maritalStatus.keyPoints45.push_back(keyPointsItem46Object);
-	}
-	auto motherNameNode = dataNode["MotherName"];
-	if(!motherNameNode["Text"].isNull())
-		data_.motherName.text = motherNameNode["Text"].asString();
-	if(!motherNameNode["Score"].isNull())
-		data_.motherName.score = std::stof(motherNameNode["Score"].asString());
-	auto allKeyPoints47Node = motherNameNode["KeyPoints"]["keyPointsItem"];
-	for (auto motherNameNodeKeyPointskeyPointsItem : allKeyPoints47Node)
-	{
-		Data::MotherName::KeyPointsItem48 keyPointsItem48Object;
-		if(!motherNameNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem48Object.x = std::stof(motherNameNodeKeyPointskeyPointsItem["X"].asString());
-		if(!motherNameNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem48Object.y = std::stof(motherNameNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.motherName.keyPoints47.push_back(keyPointsItem48Object);
-	}
-	auto nameNode = dataNode["Name"];
-	if(!nameNode["Text"].isNull())
-		data_.name.text = nameNode["Text"].asString();
-	if(!nameNode["Score"].isNull())
-		data_.name.score = std::stof(nameNode["Score"].asString());
-	auto allKeyPoints49Node = nameNode["KeyPoints"]["keyPointsItem"];
-	for (auto nameNodeKeyPointskeyPointsItem : allKeyPoints49Node)
-	{
-		Data::Name::KeyPointsItem50 keyPointsItem50Object;
-		if(!nameNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem50Object.x = std::stof(nameNodeKeyPointskeyPointsItem["X"].asString());
-		if(!nameNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem50Object.y = std::stof(nameNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.name.keyPoints49.push_back(keyPointsItem50Object);
-	}
-	auto nationalityNode = dataNode["Nationality"];
-	if(!nationalityNode["Text"].isNull())
-		data_.nationality.text = nationalityNode["Text"].asString();
-	if(!nationalityNode["Score"].isNull())
-		data_.nationality.score = std::stof(nationalityNode["Score"].asString());
-	auto allKeyPoints51Node = nationalityNode["KeyPoints"]["keyPointsItem"];
-	for (auto nationalityNodeKeyPointskeyPointsItem : allKeyPoints51Node)
-	{
-		Data::Nationality::KeyPointsItem52 keyPointsItem52Object;
-		if(!nationalityNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem52Object.x = std::stof(nationalityNodeKeyPointskeyPointsItem["X"].asString());
-		if(!nationalityNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem52Object.y = std::stof(nationalityNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.nationality.keyPoints51.push_back(keyPointsItem52Object);
-	}
-	auto neighborhoodVillageNode = dataNode["NeighborhoodVillage"];
-	if(!neighborhoodVillageNode["Text"].isNull())
-		data_.neighborhoodVillage.text = neighborhoodVillageNode["Text"].asString();
-	if(!neighborhoodVillageNode["Score"].isNull())
-		data_.neighborhoodVillage.score = std::stof(neighborhoodVillageNode["Score"].asString());
-	auto allKeyPoints53Node = neighborhoodVillageNode["KeyPoints"]["keyPointsItem"];
-	for (auto neighborhoodVillageNodeKeyPointskeyPointsItem : allKeyPoints53Node)
-	{
-		Data::NeighborhoodVillage::KeyPointsItem54 keyPointsItem54Object;
-		if(!neighborhoodVillageNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem54Object.x = std::stof(neighborhoodVillageNodeKeyPointskeyPointsItem["X"].asString());
-		if(!neighborhoodVillageNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem54Object.y = std::stof(neighborhoodVillageNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.neighborhoodVillage.keyPoints53.push_back(keyPointsItem54Object);
-	}
-	auto pageNumberNode = dataNode["PageNumber"];
-	if(!pageNumberNode["Text"].isNull())
-		data_.pageNumber.text = pageNumberNode["Text"].asString();
-	if(!pageNumberNode["Score"].isNull())
-		data_.pageNumber.score = std::stof(pageNumberNode["Score"].asString());
-	auto allKeyPoints55Node = pageNumberNode["KeyPoints"]["keyPointsItem"];
-	for (auto pageNumberNodeKeyPointskeyPointsItem : allKeyPoints55Node)
-	{
-		Data::PageNumber::KeyPointsItem56 keyPointsItem56Object;
-		if(!pageNumberNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem56Object.x = std::stof(pageNumberNodeKeyPointskeyPointsItem["X"].asString());
-		if(!pageNumberNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem56Object.y = std::stof(pageNumberNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.pageNumber.keyPoints55.push_back(keyPointsItem56Object);
-	}
-	auto passportNumberNode = dataNode["PassportNumber"];
-	if(!passportNumberNode["Text"].isNull())
-		data_.passportNumber.text = passportNumberNode["Text"].asString();
-	if(!passportNumberNode["Score"].isNull())
-		data_.passportNumber.score = std::stof(passportNumberNode["Score"].asString());
-	auto allKeyPoints57Node = passportNumberNode["KeyPoints"]["keyPointsItem"];
-	for (auto passportNumberNodeKeyPointskeyPointsItem : allKeyPoints57Node)
-	{
-		Data::PassportNumber::KeyPointsItem58 keyPointsItem58Object;
-		if(!passportNumberNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem58Object.x = std::stof(passportNumberNodeKeyPointskeyPointsItem["X"].asString());
-		if(!passportNumberNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem58Object.y = std::stof(passportNumberNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.passportNumber.keyPoints57.push_back(keyPointsItem58Object);
-	}
-	auto portraitBoxNode = dataNode["PortraitBox"];
-	if(!portraitBoxNode["Text"].isNull())
-		data_.portraitBox.text = portraitBoxNode["Text"].asString();
-	if(!portraitBoxNode["Score"].isNull())
-		data_.portraitBox.score = std::stof(portraitBoxNode["Score"].asString());
-	auto allKeyPoints59Node = portraitBoxNode["KeyPoints"]["keyPointsItem"];
-	for (auto portraitBoxNodeKeyPointskeyPointsItem : allKeyPoints59Node)
-	{
-		Data::PortraitBox::KeyPointsItem60 keyPointsItem60Object;
-		if(!portraitBoxNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem60Object.x = std::stof(portraitBoxNodeKeyPointskeyPointsItem["X"].asString());
-		if(!portraitBoxNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem60Object.y = std::stof(portraitBoxNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.portraitBox.keyPoints59.push_back(keyPointsItem60Object);
-	}
-	auto provinceNode = dataNode["Province"];
-	if(!provinceNode["Text"].isNull())
-		data_.province.text = provinceNode["Text"].asString();
-	if(!provinceNode["Score"].isNull())
-		data_.province.score = std::stof(provinceNode["Score"].asString());
-	auto allKeyPoints61Node = provinceNode["KeyPoints"]["keyPointsItem"];
-	for (auto provinceNodeKeyPointskeyPointsItem : allKeyPoints61Node)
-	{
-		Data::Province::KeyPointsItem62 keyPointsItem62Object;
-		if(!provinceNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem62Object.x = std::stof(provinceNodeKeyPointskeyPointsItem["X"].asString());
-		if(!provinceNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem62Object.y = std::stof(provinceNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.province.keyPoints61.push_back(keyPointsItem62Object);
-	}
-	auto provinceOfResidenceNode = dataNode["ProvinceOfResidence"];
-	if(!provinceOfResidenceNode["Text"].isNull())
-		data_.provinceOfResidence.text = provinceOfResidenceNode["Text"].asString();
-	if(!provinceOfResidenceNode["Score"].isNull())
-		data_.provinceOfResidence.score = std::stof(provinceOfResidenceNode["Score"].asString());
-	auto allKeyPoints63Node = provinceOfResidenceNode["KeyPoints"]["keyPointsItem"];
-	for (auto provinceOfResidenceNodeKeyPointskeyPointsItem : allKeyPoints63Node)
-	{
-		Data::ProvinceOfResidence::KeyPointsItem64 keyPointsItem64Object;
-		if(!provinceOfResidenceNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem64Object.x = std::stof(provinceOfResidenceNodeKeyPointskeyPointsItem["X"].asString());
-		if(!provinceOfResidenceNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem64Object.y = std::stof(provinceOfResidenceNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.provinceOfResidence.keyPoints63.push_back(keyPointsItem64Object);
-	}
-	auto reasonOfIssueNode = dataNode["ReasonOfIssue"];
-	if(!reasonOfIssueNode["Text"].isNull())
-		data_.reasonOfIssue.text = reasonOfIssueNode["Text"].asString();
-	if(!reasonOfIssueNode["Score"].isNull())
-		data_.reasonOfIssue.score = std::stof(reasonOfIssueNode["Score"].asString());
-	auto allKeyPoints65Node = reasonOfIssueNode["KeyPoints"]["keyPointsItem"];
-	for (auto reasonOfIssueNodeKeyPointskeyPointsItem : allKeyPoints65Node)
-	{
-		Data::ReasonOfIssue::KeyPointsItem66 keyPointsItem66Object;
-		if(!reasonOfIssueNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem66Object.x = std::stof(reasonOfIssueNodeKeyPointskeyPointsItem["X"].asString());
-		if(!reasonOfIssueNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem66Object.y = std::stof(reasonOfIssueNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.reasonOfIssue.keyPoints65.push_back(keyPointsItem66Object);
-	}
-	auto registerNumberNode = dataNode["RegisterNumber"];
-	if(!registerNumberNode["Text"].isNull())
-		data_.registerNumber.text = registerNumberNode["Text"].asString();
-	if(!registerNumberNode["Score"].isNull())
-		data_.registerNumber.score = std::stof(registerNumberNode["Score"].asString());
-	auto allKeyPoints67Node = registerNumberNode["KeyPoints"]["keyPointsItem"];
-	for (auto registerNumberNodeKeyPointskeyPointsItem : allKeyPoints67Node)
-	{
-		Data::RegisterNumber::KeyPointsItem68 keyPointsItem68Object;
-		if(!registerNumberNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem68Object.x = std::stof(registerNumberNodeKeyPointskeyPointsItem["X"].asString());
-		if(!registerNumberNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem68Object.y = std::stof(registerNumberNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.registerNumber.keyPoints67.push_back(keyPointsItem68Object);
-	}
-	auto religionNode = dataNode["Religion"];
-	if(!religionNode["Text"].isNull())
-		data_.religion.text = religionNode["Text"].asString();
-	if(!religionNode["Score"].isNull())
-		data_.religion.score = std::stof(religionNode["Score"].asString());
-	auto allKeyPoints69Node = religionNode["KeyPoints"]["keyPointsItem"];
-	for (auto religionNodeKeyPointskeyPointsItem : allKeyPoints69Node)
-	{
-		Data::Religion::KeyPointsItem70 keyPointsItem70Object;
-		if(!religionNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem70Object.x = std::stof(religionNodeKeyPointskeyPointsItem["X"].asString());
-		if(!religionNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem70Object.y = std::stof(religionNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.religion.keyPoints69.push_back(keyPointsItem70Object);
-	}
-	auto sayfaNode = dataNode["Sayfa"];
-	if(!sayfaNode["Text"].isNull())
-		data_.sayfa.text = sayfaNode["Text"].asString();
-	if(!sayfaNode["Score"].isNull())
-		data_.sayfa.score = std::stof(sayfaNode["Score"].asString());
-	auto allKeyPoints71Node = sayfaNode["KeyPoints"]["keyPointsItem"];
-	for (auto sayfaNodeKeyPointskeyPointsItem : allKeyPoints71Node)
-	{
-		Data::Sayfa::KeyPointsItem72 keyPointsItem72Object;
-		if(!sayfaNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem72Object.x = std::stof(sayfaNodeKeyPointskeyPointsItem["X"].asString());
-		if(!sayfaNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem72Object.y = std::stof(sayfaNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.sayfa.keyPoints71.push_back(keyPointsItem72Object);
-	}
-	auto seriNode = dataNode["Seri"];
-	if(!seriNode["Text"].isNull())
-		data_.seri.text = seriNode["Text"].asString();
-	if(!seriNode["Score"].isNull())
-		data_.seri.score = std::stof(seriNode["Score"].asString());
-	auto allKeyPoints73Node = seriNode["KeyPoints"]["keyPointsItem"];
-	for (auto seriNodeKeyPointskeyPointsItem : allKeyPoints73Node)
-	{
-		Data::Seri::KeyPointsItem74 keyPointsItem74Object;
-		if(!seriNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem74Object.x = std::stof(seriNodeKeyPointskeyPointsItem["X"].asString());
-		if(!seriNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem74Object.y = std::stof(seriNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.seri.keyPoints73.push_back(keyPointsItem74Object);
-	}
-	auto surnameNode = dataNode["Surname"];
-	if(!surnameNode["Text"].isNull())
-		data_.surname.text = surnameNode["Text"].asString();
-	if(!surnameNode["Score"].isNull())
-		data_.surname.score = std::stof(surnameNode["Score"].asString());
-	auto allKeyPoints75Node = surnameNode["KeyPoints"]["keyPointsItem"];
-	for (auto surnameNodeKeyPointskeyPointsItem : allKeyPoints75Node)
-	{
-		Data::Surname::KeyPointsItem76 keyPointsItem76Object;
-		if(!surnameNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem76Object.x = std::stof(surnameNodeKeyPointskeyPointsItem["X"].asString());
-		if(!surnameNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem76Object.y = std::stof(surnameNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.surname.keyPoints75.push_back(keyPointsItem76Object);
-	}
-	auto typeOfResidencePermitNode = dataNode["TypeOfResidencePermit"];
-	if(!typeOfResidencePermitNode["Text"].isNull())
-		data_.typeOfResidencePermit.text = typeOfResidencePermitNode["Text"].asString();
-	if(!typeOfResidencePermitNode["Score"].isNull())
-		data_.typeOfResidencePermit.score = std::stof(typeOfResidencePermitNode["Score"].asString());
-	auto allKeyPoints77Node = typeOfResidencePermitNode["KeyPoints"]["keyPointsItem"];
-	for (auto typeOfResidencePermitNodeKeyPointskeyPointsItem : allKeyPoints77Node)
-	{
-		Data::TypeOfResidencePermit::KeyPointsItem78 keyPointsItem78Object;
-		if(!typeOfResidencePermitNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem78Object.x = std::stof(typeOfResidencePermitNodeKeyPointskeyPointsItem["X"].asString());
-		if(!typeOfResidencePermitNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem78Object.y = std::stof(typeOfResidencePermitNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.typeOfResidencePermit.keyPoints77.push_back(keyPointsItem78Object);
-	}
-	auto validUntilNode = dataNode["ValidUntil"];
-	if(!validUntilNode["Text"].isNull())
-		data_.validUntil.text = validUntilNode["Text"].asString();
-	if(!validUntilNode["Score"].isNull())
-		data_.validUntil.score = std::stof(validUntilNode["Score"].asString());
-	auto allKeyPoints79Node = validUntilNode["KeyPoints"]["keyPointsItem"];
-	for (auto validUntilNodeKeyPointskeyPointsItem : allKeyPoints79Node)
-	{
-		Data::ValidUntil::KeyPointsItem80 keyPointsItem80Object;
-		if(!validUntilNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem80Object.x = std::stof(validUntilNodeKeyPointskeyPointsItem["X"].asString());
-		if(!validUntilNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem80Object.y = std::stof(validUntilNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.validUntil.keyPoints79.push_back(keyPointsItem80Object);
-	}
-	auto villageNode = dataNode["Village"];
-	if(!villageNode["Text"].isNull())
-		data_.village.text = villageNode["Text"].asString();
-	if(!villageNode["Score"].isNull())
-		data_.village.score = std::stof(villageNode["Score"].asString());
-	auto allKeyPoints81Node = villageNode["KeyPoints"]["keyPointsItem"];
-	for (auto villageNodeKeyPointskeyPointsItem : allKeyPoints81Node)
-	{
-		Data::Village::KeyPointsItem82 keyPointsItem82Object;
-		if(!villageNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem82Object.x = std::stof(villageNodeKeyPointskeyPointsItem["X"].asString());
-		if(!villageNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem82Object.y = std::stof(villageNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.village.keyPoints81.push_back(keyPointsItem82Object);
-	}
-	auto volumeNumberNode = dataNode["VolumeNumber"];
-	if(!volumeNumberNode["Text"].isNull())
-		data_.volumeNumber.text = volumeNumberNode["Text"].asString();
-	if(!volumeNumberNode["Score"].isNull())
-		data_.volumeNumber.score = std::stof(volumeNumberNode["Score"].asString());
-	auto allKeyPoints83Node = volumeNumberNode["KeyPoints"]["keyPointsItem"];
-	for (auto volumeNumberNodeKeyPointskeyPointsItem : allKeyPoints83Node)
-	{
-		Data::VolumeNumber::KeyPointsItem84 keyPointsItem84Object;
-		if(!volumeNumberNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem84Object.x = std::stof(volumeNumberNodeKeyPointskeyPointsItem["X"].asString());
-		if(!volumeNumberNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem84Object.y = std::stof(volumeNumberNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.volumeNumber.keyPoints83.push_back(keyPointsItem84Object);
-	}
-	auto sexNode = dataNode["Sex"];
-	if(!sexNode["Text"].isNull())
-		data_.sex.text = sexNode["Text"].asString();
-	if(!sexNode["Score"].isNull())
-		data_.sex.score = std::stof(sexNode["Score"].asString());
-	auto allKeyPoints85Node = sexNode["KeyPoints"]["keyPointsItem"];
-	for (auto sexNodeKeyPointskeyPointsItem : allKeyPoints85Node)
-	{
-		Data::Sex::KeyPointsItem86 keyPointsItem86Object;
-		if(!sexNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem86Object.x = std::stof(sexNodeKeyPointskeyPointsItem["X"].asString());
-		if(!sexNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem86Object.y = std::stof(sexNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.sex.keyPoints85.push_back(keyPointsItem86Object);
-	}
-	if(!value["Code"].isNull())
-		code_ = value["Code"].asString();
-	if(!value["Message"].isNull())
-		message_ = value["Message"].asString();
-
-}
-
-std::string RecognizeTurkeyIdentityCardResult::getMessage()const
-{
-	return message_;
-}
-
-RecognizeTurkeyIdentityCardResult::Data RecognizeTurkeyIdentityCardResult::getData()const
-{
-	return data_;
-}
-
-std::string RecognizeTurkeyIdentityCardResult::getCode()const
-{
-	return code_;
-}
-

ocr/src/model/RecognizeUkraineIdentityCardRequest.cc

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

ocr/src/model/RecognizeUkraineIdentityCardResult.cc

@@ -1,259 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/ocr/model/RecognizeUkraineIdentityCardResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Ocr;
-using namespace AlibabaCloud::Ocr::Model;
-
-RecognizeUkraineIdentityCardResult::RecognizeUkraineIdentityCardResult() :
-	ServiceResult()
-{}
-
-RecognizeUkraineIdentityCardResult::RecognizeUkraineIdentityCardResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-RecognizeUkraineIdentityCardResult::~RecognizeUkraineIdentityCardResult()
-{}
-
-void RecognizeUkraineIdentityCardResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto dataNode = value["Data"];
-	auto birthDateNode = dataNode["BirthDate"];
-	if(!birthDateNode["Text"].isNull())
-		data_.birthDate.text = birthDateNode["Text"].asString();
-	if(!birthDateNode["Score"].isNull())
-		data_.birthDate.score = std::stof(birthDateNode["Score"].asString());
-	auto allKeyPointsNode = birthDateNode["KeyPoints"]["keyPointsItem"];
-	for (auto birthDateNodeKeyPointskeyPointsItem : allKeyPointsNode)
-	{
-		Data::BirthDate::KeyPointsItem keyPointsItemObject;
-		if(!birthDateNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItemObject.x = std::stof(birthDateNodeKeyPointskeyPointsItem["X"].asString());
-		if(!birthDateNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItemObject.y = std::stof(birthDateNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.birthDate.keyPoints.push_back(keyPointsItemObject);
-	}
-	auto cardBoxNode = dataNode["CardBox"];
-	if(!cardBoxNode["Text"].isNull())
-		data_.cardBox.text = cardBoxNode["Text"].asString();
-	if(!cardBoxNode["Score"].isNull())
-		data_.cardBox.score = std::stof(cardBoxNode["Score"].asString());
-	auto allKeyPoints1Node = cardBoxNode["KeyPoints"]["keyPointsItem"];
-	for (auto cardBoxNodeKeyPointskeyPointsItem : allKeyPoints1Node)
-	{
-		Data::CardBox::KeyPointsItem2 keyPointsItem2Object;
-		if(!cardBoxNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem2Object.x = std::stof(cardBoxNodeKeyPointskeyPointsItem["X"].asString());
-		if(!cardBoxNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem2Object.y = std::stof(cardBoxNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.cardBox.keyPoints1.push_back(keyPointsItem2Object);
-	}
-	auto documentNumberNode = dataNode["DocumentNumber"];
-	if(!documentNumberNode["Text"].isNull())
-		data_.documentNumber.text = documentNumberNode["Text"].asString();
-	if(!documentNumberNode["Score"].isNull())
-		data_.documentNumber.score = std::stof(documentNumberNode["Score"].asString());
-	auto allKeyPoints3Node = documentNumberNode["KeyPoints"]["keyPointsItem"];
-	for (auto documentNumberNodeKeyPointskeyPointsItem : allKeyPoints3Node)
-	{
-		Data::DocumentNumber::KeyPointsItem4 keyPointsItem4Object;
-		if(!documentNumberNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem4Object.x = std::stof(documentNumberNodeKeyPointskeyPointsItem["X"].asString());
-		if(!documentNumberNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem4Object.y = std::stof(documentNumberNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.documentNumber.keyPoints3.push_back(keyPointsItem4Object);
-	}
-	auto expiryDateNode = dataNode["ExpiryDate"];
-	if(!expiryDateNode["Text"].isNull())
-		data_.expiryDate.text = expiryDateNode["Text"].asString();
-	if(!expiryDateNode["Score"].isNull())
-		data_.expiryDate.score = std::stof(expiryDateNode["Score"].asString());
-	auto allKeyPoints5Node = expiryDateNode["KeyPoints"]["keyPointsItem"];
-	for (auto expiryDateNodeKeyPointskeyPointsItem : allKeyPoints5Node)
-	{
-		Data::ExpiryDate::KeyPointsItem6 keyPointsItem6Object;
-		if(!expiryDateNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem6Object.x = std::stof(expiryDateNodeKeyPointskeyPointsItem["X"].asString());
-		if(!expiryDateNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem6Object.y = std::stof(expiryDateNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.expiryDate.keyPoints5.push_back(keyPointsItem6Object);
-	}
-	auto nameEnglishNode = dataNode["NameEnglish"];
-	if(!nameEnglishNode["Text"].isNull())
-		data_.nameEnglish.text = nameEnglishNode["Text"].asString();
-	if(!nameEnglishNode["Score"].isNull())
-		data_.nameEnglish.score = std::stof(nameEnglishNode["Score"].asString());
-	auto allKeyPoints7Node = nameEnglishNode["KeyPoints"]["keyPointsItem"];
-	for (auto nameEnglishNodeKeyPointskeyPointsItem : allKeyPoints7Node)
-	{
-		Data::NameEnglish::KeyPointsItem8 keyPointsItem8Object;
-		if(!nameEnglishNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem8Object.x = std::stof(nameEnglishNodeKeyPointskeyPointsItem["X"].asString());
-		if(!nameEnglishNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem8Object.y = std::stof(nameEnglishNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.nameEnglish.keyPoints7.push_back(keyPointsItem8Object);
-	}
-	auto nameUkraineNode = dataNode["NameUkraine"];
-	if(!nameUkraineNode["Text"].isNull())
-		data_.nameUkraine.text = nameUkraineNode["Text"].asString();
-	if(!nameUkraineNode["Score"].isNull())
-		data_.nameUkraine.score = std::stof(nameUkraineNode["Score"].asString());
-	auto allKeyPoints9Node = nameUkraineNode["KeyPoints"]["keyPointsItem"];
-	for (auto nameUkraineNodeKeyPointskeyPointsItem : allKeyPoints9Node)
-	{
-		Data::NameUkraine::KeyPointsItem10 keyPointsItem10Object;
-		if(!nameUkraineNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem10Object.x = std::stof(nameUkraineNodeKeyPointskeyPointsItem["X"].asString());
-		if(!nameUkraineNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem10Object.y = std::stof(nameUkraineNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.nameUkraine.keyPoints9.push_back(keyPointsItem10Object);
-	}
-	auto nationalityNode = dataNode["Nationality"];
-	if(!nationalityNode["Text"].isNull())
-		data_.nationality.text = nationalityNode["Text"].asString();
-	if(!nationalityNode["Score"].isNull())
-		data_.nationality.score = std::stof(nationalityNode["Score"].asString());
-	auto allKeyPoints11Node = nationalityNode["KeyPoints"]["keyPointsItem"];
-	for (auto nationalityNodeKeyPointskeyPointsItem : allKeyPoints11Node)
-	{
-		Data::Nationality::KeyPointsItem12 keyPointsItem12Object;
-		if(!nationalityNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem12Object.x = std::stof(nationalityNodeKeyPointskeyPointsItem["X"].asString());
-		if(!nationalityNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem12Object.y = std::stof(nationalityNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.nationality.keyPoints11.push_back(keyPointsItem12Object);
-	}
-	auto patronymicNode = dataNode["Patronymic"];
-	if(!patronymicNode["Text"].isNull())
-		data_.patronymic.text = patronymicNode["Text"].asString();
-	if(!patronymicNode["Score"].isNull())
-		data_.patronymic.score = std::stof(patronymicNode["Score"].asString());
-	auto allKeyPoints13Node = patronymicNode["KeyPoints"]["keyPointsItem"];
-	for (auto patronymicNodeKeyPointskeyPointsItem : allKeyPoints13Node)
-	{
-		Data::Patronymic::KeyPointsItem14 keyPointsItem14Object;
-		if(!patronymicNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem14Object.x = std::stof(patronymicNodeKeyPointskeyPointsItem["X"].asString());
-		if(!patronymicNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem14Object.y = std::stof(patronymicNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.patronymic.keyPoints13.push_back(keyPointsItem14Object);
-	}
-	auto portraitBoxNode = dataNode["PortraitBox"];
-	if(!portraitBoxNode["Text"].isNull())
-		data_.portraitBox.text = portraitBoxNode["Text"].asString();
-	if(!portraitBoxNode["Score"].isNull())
-		data_.portraitBox.score = std::stof(portraitBoxNode["Score"].asString());
-	auto allKeyPoints15Node = portraitBoxNode["KeyPoints"]["keyPointsItem"];
-	for (auto portraitBoxNodeKeyPointskeyPointsItem : allKeyPoints15Node)
-	{
-		Data::PortraitBox::KeyPointsItem16 keyPointsItem16Object;
-		if(!portraitBoxNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem16Object.x = std::stof(portraitBoxNodeKeyPointskeyPointsItem["X"].asString());
-		if(!portraitBoxNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem16Object.y = std::stof(portraitBoxNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.portraitBox.keyPoints15.push_back(keyPointsItem16Object);
-	}
-	auto recordNumberNode = dataNode["RecordNumber"];
-	if(!recordNumberNode["Text"].isNull())
-		data_.recordNumber.text = recordNumberNode["Text"].asString();
-	if(!recordNumberNode["Score"].isNull())
-		data_.recordNumber.score = std::stof(recordNumberNode["Score"].asString());
-	auto allKeyPoints17Node = recordNumberNode["KeyPoints"]["keyPointsItem"];
-	for (auto recordNumberNodeKeyPointskeyPointsItem : allKeyPoints17Node)
-	{
-		Data::RecordNumber::KeyPointsItem18 keyPointsItem18Object;
-		if(!recordNumberNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem18Object.x = std::stof(recordNumberNodeKeyPointskeyPointsItem["X"].asString());
-		if(!recordNumberNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem18Object.y = std::stof(recordNumberNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.recordNumber.keyPoints17.push_back(keyPointsItem18Object);
-	}
-	auto sexNode = dataNode["Sex"];
-	if(!sexNode["Text"].isNull())
-		data_.sex.text = sexNode["Text"].asString();
-	if(!sexNode["Score"].isNull())
-		data_.sex.score = std::stof(sexNode["Score"].asString());
-	auto allKeyPoints19Node = sexNode["KeyPoints"]["keyPointsItem"];
-	for (auto sexNodeKeyPointskeyPointsItem : allKeyPoints19Node)
-	{
-		Data::Sex::KeyPointsItem20 keyPointsItem20Object;
-		if(!sexNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem20Object.x = std::stof(sexNodeKeyPointskeyPointsItem["X"].asString());
-		if(!sexNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem20Object.y = std::stof(sexNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.sex.keyPoints19.push_back(keyPointsItem20Object);
-	}
-	auto surnameEnglishNode = dataNode["SurnameEnglish"];
-	if(!surnameEnglishNode["Text"].isNull())
-		data_.surnameEnglish.text = surnameEnglishNode["Text"].asString();
-	if(!surnameEnglishNode["Score"].isNull())
-		data_.surnameEnglish.score = std::stof(surnameEnglishNode["Score"].asString());
-	auto allKeyPoints21Node = surnameEnglishNode["KeyPoints"]["keyPointsItem"];
-	for (auto surnameEnglishNodeKeyPointskeyPointsItem : allKeyPoints21Node)
-	{
-		Data::SurnameEnglish::KeyPointsItem22 keyPointsItem22Object;
-		if(!surnameEnglishNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem22Object.x = std::stof(surnameEnglishNodeKeyPointskeyPointsItem["X"].asString());
-		if(!surnameEnglishNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem22Object.y = std::stof(surnameEnglishNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.surnameEnglish.keyPoints21.push_back(keyPointsItem22Object);
-	}
-	auto surnameUkraineNode = dataNode["SurnameUkraine"];
-	if(!surnameUkraineNode["Text"].isNull())
-		data_.surnameUkraine.text = surnameUkraineNode["Text"].asString();
-	if(!surnameUkraineNode["Score"].isNull())
-		data_.surnameUkraine.score = std::stof(surnameUkraineNode["Score"].asString());
-	auto allKeyPoints23Node = surnameUkraineNode["KeyPoints"]["keyPointsItem"];
-	for (auto surnameUkraineNodeKeyPointskeyPointsItem : allKeyPoints23Node)
-	{
-		Data::SurnameUkraine::KeyPointsItem24 keyPointsItem24Object;
-		if(!surnameUkraineNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem24Object.x = std::stof(surnameUkraineNodeKeyPointskeyPointsItem["X"].asString());
-		if(!surnameUkraineNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem24Object.y = std::stof(surnameUkraineNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.surnameUkraine.keyPoints23.push_back(keyPointsItem24Object);
-	}
-	if(!value["Code"].isNull())
-		code_ = value["Code"].asString();
-	if(!value["Message"].isNull())
-		message_ = value["Message"].asString();
-
-}
-
-std::string RecognizeUkraineIdentityCardResult::getMessage()const
-{
-	return message_;
-}
-
-RecognizeUkraineIdentityCardResult::Data RecognizeUkraineIdentityCardResult::getData()const
-{
-	return data_;
-}
-
-std::string RecognizeUkraineIdentityCardResult::getCode()const
-{
-	return code_;
-}
-

ocr/src/model/RecognizeVideoCastCrewListRequest.cc

@@ -1,65 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/ocr/model/RecognizeVideoCastCrewListRequest.h>
-
-using AlibabaCloud::Ocr::Model::RecognizeVideoCastCrewListRequest;
-
-RecognizeVideoCastCrewListRequest::RecognizeVideoCastCrewListRequest()
-    : RpcServiceRequest("ocr", "2019-12-30", "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);
-}
-

ocr/src/model/RecognizeVideoCastCrewListResult.cc

@@ -1,44 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/ocr/model/RecognizeVideoCastCrewListResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Ocr;
-using namespace AlibabaCloud::Ocr::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());
-
-}
-

ocr/src/model/RecognizeVietnamIdentityCardRequest.cc

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

ocr/src/model/RecognizeVietnamIdentityCardResult.cc

@@ -1,289 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/ocr/model/RecognizeVietnamIdentityCardResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Ocr;
-using namespace AlibabaCloud::Ocr::Model;
-
-RecognizeVietnamIdentityCardResult::RecognizeVietnamIdentityCardResult() :
-	ServiceResult()
-{}
-
-RecognizeVietnamIdentityCardResult::RecognizeVietnamIdentityCardResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-RecognizeVietnamIdentityCardResult::~RecognizeVietnamIdentityCardResult()
-{}
-
-void RecognizeVietnamIdentityCardResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto dataNode = value["Data"];
-	auto addressFirstLineNode = dataNode["AddressFirstLine"];
-	if(!addressFirstLineNode["Text"].isNull())
-		data_.addressFirstLine.text = addressFirstLineNode["Text"].asString();
-	if(!addressFirstLineNode["Score"].isNull())
-		data_.addressFirstLine.score = std::stof(addressFirstLineNode["Score"].asString());
-	auto allKeyPointsNode = addressFirstLineNode["KeyPoints"]["keyPointsItem"];
-	for (auto addressFirstLineNodeKeyPointskeyPointsItem : allKeyPointsNode)
-	{
-		Data::AddressFirstLine::KeyPointsItem keyPointsItemObject;
-		if(!addressFirstLineNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItemObject.x = std::stof(addressFirstLineNodeKeyPointskeyPointsItem["X"].asString());
-		if(!addressFirstLineNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItemObject.y = std::stof(addressFirstLineNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.addressFirstLine.keyPoints.push_back(keyPointsItemObject);
-	}
-	auto addressSecondLineNode = dataNode["AddressSecondLine"];
-	if(!addressSecondLineNode["Text"].isNull())
-		data_.addressSecondLine.text = addressSecondLineNode["Text"].asString();
-	if(!addressSecondLineNode["Score"].isNull())
-		data_.addressSecondLine.score = std::stof(addressSecondLineNode["Score"].asString());
-	auto allKeyPoints1Node = addressSecondLineNode["KeyPoints"]["keyPointsItem"];
-	for (auto addressSecondLineNodeKeyPointskeyPointsItem : allKeyPoints1Node)
-	{
-		Data::AddressSecondLine::KeyPointsItem2 keyPointsItem2Object;
-		if(!addressSecondLineNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem2Object.x = std::stof(addressSecondLineNodeKeyPointskeyPointsItem["X"].asString());
-		if(!addressSecondLineNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem2Object.y = std::stof(addressSecondLineNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.addressSecondLine.keyPoints1.push_back(keyPointsItem2Object);
-	}
-	auto birthDateNode = dataNode["BirthDate"];
-	if(!birthDateNode["Text"].isNull())
-		data_.birthDate.text = birthDateNode["Text"].asString();
-	if(!birthDateNode["Score"].isNull())
-		data_.birthDate.score = std::stof(birthDateNode["Score"].asString());
-	auto allKeyPoints3Node = birthDateNode["KeyPoints"]["keyPointsItem"];
-	for (auto birthDateNodeKeyPointskeyPointsItem : allKeyPoints3Node)
-	{
-		Data::BirthDate::KeyPointsItem4 keyPointsItem4Object;
-		if(!birthDateNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem4Object.x = std::stof(birthDateNodeKeyPointskeyPointsItem["X"].asString());
-		if(!birthDateNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem4Object.y = std::stof(birthDateNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.birthDate.keyPoints3.push_back(keyPointsItem4Object);
-	}
-	auto cardBoxNode = dataNode["CardBox"];
-	if(!cardBoxNode["Text"].isNull())
-		data_.cardBox.text = cardBoxNode["Text"].asString();
-	if(!cardBoxNode["Score"].isNull())
-		data_.cardBox.score = cardBoxNode["Score"].asString();
-	auto allKeyPoints5Node = cardBoxNode["KeyPoints"]["keyPointsItem"];
-	for (auto cardBoxNodeKeyPointskeyPointsItem : allKeyPoints5Node)
-	{
-		Data::CardBox::KeyPointsItem6 keyPointsItem6Object;
-		if(!cardBoxNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem6Object.x = std::stof(cardBoxNodeKeyPointskeyPointsItem["X"].asString());
-		if(!cardBoxNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem6Object.y = std::stof(cardBoxNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.cardBox.keyPoints5.push_back(keyPointsItem6Object);
-	}
-	auto driveClassNode = dataNode["DriveClass"];
-	if(!driveClassNode["Text"].isNull())
-		data_.driveClass.text = driveClassNode["Text"].asString();
-	if(!driveClassNode["Score"].isNull())
-		data_.driveClass.score = driveClassNode["Score"].asString();
-	auto allKeyPoints7Node = driveClassNode["KeyPoints"]["keyPointsItem"];
-	for (auto driveClassNodeKeyPointskeyPointsItem : allKeyPoints7Node)
-	{
-		Data::DriveClass::KeyPointsItem8 keyPointsItem8Object;
-		if(!driveClassNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem8Object.x = std::stof(driveClassNodeKeyPointskeyPointsItem["X"].asString());
-		if(!driveClassNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem8Object.y = std::stof(driveClassNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.driveClass.keyPoints7.push_back(keyPointsItem8Object);
-	}
-	auto expiryDateNode = dataNode["ExpiryDate"];
-	if(!expiryDateNode["Text"].isNull())
-		data_.expiryDate.text = expiryDateNode["Text"].asString();
-	if(!expiryDateNode["Score"].isNull())
-		data_.expiryDate.score = expiryDateNode["Score"].asString();
-	auto allKeyPoints9Node = expiryDateNode["KeyPoints"]["keyPointsItem"];
-	for (auto expiryDateNodeKeyPointskeyPointsItem : allKeyPoints9Node)
-	{
-		Data::ExpiryDate::KeyPointsItem10 keyPointsItem10Object;
-		if(!expiryDateNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem10Object.x = std::stof(expiryDateNodeKeyPointskeyPointsItem["X"].asString());
-		if(!expiryDateNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem10Object.y = std::stof(expiryDateNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.expiryDate.keyPoints9.push_back(keyPointsItem10Object);
-	}
-	auto fullNameNode = dataNode["FullName"];
-	if(!fullNameNode["Text"].isNull())
-		data_.fullName.text = fullNameNode["Text"].asString();
-	if(!fullNameNode["Score"].isNull())
-		data_.fullName.score = fullNameNode["Score"].asString();
-	auto allKeyPoints11Node = fullNameNode["KeyPoints"]["keyPointsItem"];
-	for (auto fullNameNodeKeyPointskeyPointsItem : allKeyPoints11Node)
-	{
-		Data::FullName::KeyPointsItem12 keyPointsItem12Object;
-		if(!fullNameNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem12Object.x = std::stof(fullNameNodeKeyPointskeyPointsItem["X"].asString());
-		if(!fullNameNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem12Object.y = std::stof(fullNameNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.fullName.keyPoints11.push_back(keyPointsItem12Object);
-	}
-	auto idNumberNode = dataNode["IdNumber"];
-	if(!idNumberNode["Text"].isNull())
-		data_.idNumber.text = idNumberNode["Text"].asString();
-	if(!idNumberNode["Score"].isNull())
-		data_.idNumber.score = idNumberNode["Score"].asString();
-	auto allKeyPoints13Node = idNumberNode["KeyPoints"]["keyPointsItem"];
-	for (auto idNumberNodeKeyPointskeyPointsItem : allKeyPoints13Node)
-	{
-		Data::IdNumber::KeyPointsItem14 keyPointsItem14Object;
-		if(!idNumberNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem14Object.x = std::stof(idNumberNodeKeyPointskeyPointsItem["X"].asString());
-		if(!idNumberNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem14Object.y = std::stof(idNumberNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.idNumber.keyPoints13.push_back(keyPointsItem14Object);
-	}
-	auto nationalityNode = dataNode["Nationality"];
-	if(!nationalityNode["Text"].isNull())
-		data_.nationality.text = nationalityNode["Text"].asString();
-	if(!nationalityNode["Score"].isNull())
-		data_.nationality.score = nationalityNode["Score"].asString();
-	auto allKeyPoints15Node = nationalityNode["KeyPoints"]["keyPointsItem"];
-	for (auto nationalityNodeKeyPointskeyPointsItem : allKeyPoints15Node)
-	{
-		Data::Nationality::KeyPointsItem16 keyPointsItem16Object;
-		if(!nationalityNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem16Object.x = std::stof(nationalityNodeKeyPointskeyPointsItem["X"].asString());
-		if(!nationalityNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem16Object.y = std::stof(nationalityNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.nationality.keyPoints15.push_back(keyPointsItem16Object);
-	}
-	auto originPlaceFirstLineNode = dataNode["OriginPlaceFirstLine"];
-	if(!originPlaceFirstLineNode["Text"].isNull())
-		data_.originPlaceFirstLine.text = originPlaceFirstLineNode["Text"].asString();
-	if(!originPlaceFirstLineNode["Score"].isNull())
-		data_.originPlaceFirstLine.score = originPlaceFirstLineNode["Score"].asString();
-	auto allKeyPoints17Node = originPlaceFirstLineNode["KeyPoints"]["keyPointsItem"];
-	for (auto originPlaceFirstLineNodeKeyPointskeyPointsItem : allKeyPoints17Node)
-	{
-		Data::OriginPlaceFirstLine::KeyPointsItem18 keyPointsItem18Object;
-		if(!originPlaceFirstLineNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem18Object.x = std::stof(originPlaceFirstLineNodeKeyPointskeyPointsItem["X"].asString());
-		if(!originPlaceFirstLineNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem18Object.y = std::stof(originPlaceFirstLineNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.originPlaceFirstLine.keyPoints17.push_back(keyPointsItem18Object);
-	}
-	auto originPlaceSecondLineNode = dataNode["OriginPlaceSecondLine"];
-	if(!originPlaceSecondLineNode["Text"].isNull())
-		data_.originPlaceSecondLine.text = originPlaceSecondLineNode["Text"].asString();
-	if(!originPlaceSecondLineNode["Score"].isNull())
-		data_.originPlaceSecondLine.score = originPlaceSecondLineNode["Score"].asString();
-	auto allKeyPoints19Node = originPlaceSecondLineNode["KeyPoints"]["keyPointsItem"];
-	for (auto originPlaceSecondLineNodeKeyPointskeyPointsItem : allKeyPoints19Node)
-	{
-		Data::OriginPlaceSecondLine::KeyPointsItem20 keyPointsItem20Object;
-		if(!originPlaceSecondLineNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem20Object.x = std::stof(originPlaceSecondLineNodeKeyPointskeyPointsItem["X"].asString());
-		if(!originPlaceSecondLineNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem20Object.y = std::stof(originPlaceSecondLineNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.originPlaceSecondLine.keyPoints19.push_back(keyPointsItem20Object);
-	}
-	auto portraitBoxNode = dataNode["PortraitBox"];
-	if(!portraitBoxNode["Text"].isNull())
-		data_.portraitBox.text = portraitBoxNode["Text"].asString();
-	if(!portraitBoxNode["Score"].isNull())
-		data_.portraitBox.score = portraitBoxNode["Score"].asString();
-	auto allKeyPoints21Node = portraitBoxNode["KeyPoints"]["keyPointsItem"];
-	for (auto portraitBoxNodeKeyPointskeyPointsItem : allKeyPoints21Node)
-	{
-		Data::PortraitBox::KeyPointsItem22 keyPointsItem22Object;
-		if(!portraitBoxNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem22Object.x = std::stof(portraitBoxNodeKeyPointskeyPointsItem["X"].asString());
-		if(!portraitBoxNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem22Object.y = std::stof(portraitBoxNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.portraitBox.keyPoints21.push_back(keyPointsItem22Object);
-	}
-	auto residencePlaceFirstLineNode = dataNode["ResidencePlaceFirstLine"];
-	if(!residencePlaceFirstLineNode["Text"].isNull())
-		data_.residencePlaceFirstLine.text = residencePlaceFirstLineNode["Text"].asString();
-	if(!residencePlaceFirstLineNode["Score"].isNull())
-		data_.residencePlaceFirstLine.score = residencePlaceFirstLineNode["Score"].asString();
-	auto allKeyPoints23Node = residencePlaceFirstLineNode["KeyPoints"]["keyPointsItem"];
-	for (auto residencePlaceFirstLineNodeKeyPointskeyPointsItem : allKeyPoints23Node)
-	{
-		Data::ResidencePlaceFirstLine::KeyPointsItem24 keyPointsItem24Object;
-		if(!residencePlaceFirstLineNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem24Object.x = std::stof(residencePlaceFirstLineNodeKeyPointskeyPointsItem["X"].asString());
-		if(!residencePlaceFirstLineNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem24Object.y = std::stof(residencePlaceFirstLineNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.residencePlaceFirstLine.keyPoints23.push_back(keyPointsItem24Object);
-	}
-	auto residencePlaceSecondLineNode = dataNode["ResidencePlaceSecondLine"];
-	if(!residencePlaceSecondLineNode["Text"].isNull())
-		data_.residencePlaceSecondLine.text = residencePlaceSecondLineNode["Text"].asString();
-	if(!residencePlaceSecondLineNode["Score"].isNull())
-		data_.residencePlaceSecondLine.score = residencePlaceSecondLineNode["Score"].asString();
-	auto allKeyPoints25Node = residencePlaceSecondLineNode["KeyPoints"]["keyPointsItem"];
-	for (auto residencePlaceSecondLineNodeKeyPointskeyPointsItem : allKeyPoints25Node)
-	{
-		Data::ResidencePlaceSecondLine::KeyPointsItem26 keyPointsItem26Object;
-		if(!residencePlaceSecondLineNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem26Object.x = std::stof(residencePlaceSecondLineNodeKeyPointskeyPointsItem["X"].asString());
-		if(!residencePlaceSecondLineNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem26Object.y = std::stof(residencePlaceSecondLineNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.residencePlaceSecondLine.keyPoints25.push_back(keyPointsItem26Object);
-	}
-	auto sexNode = dataNode["Sex"];
-	if(!sexNode["Text"].isNull())
-		data_.sex.text = sexNode["Text"].asString();
-	if(!sexNode["Score"].isNull())
-		data_.sex.score = sexNode["Score"].asString();
-	auto allKeyPoints27Node = sexNode["KeyPoints"]["keyPointsItem"];
-	for (auto sexNodeKeyPointskeyPointsItem : allKeyPoints27Node)
-	{
-		Data::Sex::KeyPointsItem28 keyPointsItem28Object;
-		if(!sexNodeKeyPointskeyPointsItem["X"].isNull())
-			keyPointsItem28Object.x = std::stof(sexNodeKeyPointskeyPointsItem["X"].asString());
-		if(!sexNodeKeyPointskeyPointsItem["Y"].isNull())
-			keyPointsItem28Object.y = std::stof(sexNodeKeyPointskeyPointsItem["Y"].asString());
-		data_.sex.keyPoints27.push_back(keyPointsItem28Object);
-	}
-	if(!value["Code"].isNull())
-		code_ = value["Code"].asString();
-	if(!value["Message"].isNull())
-		message_ = value["Message"].asString();
-
-}
-
-std::string RecognizeVietnamIdentityCardResult::getMessage()const
-{
-	return message_;
-}
-
-RecognizeVietnamIdentityCardResult::Data RecognizeVietnamIdentityCardResult::getData()const
-{
-	return data_;
-}
-
-std::string RecognizeVietnamIdentityCardResult::getCode()const
-{
-	return code_;
-}
-