1585346868/aliyun-openapi-cpp-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Release RecognizeVATInvoice.

Browse Source
This commit is contained in:
sdk-team
2022-11-10 08:57:56 +00:00
parent dce3c27547
commit 7c4887171f
73 changed files with 2108 additions and 2605 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
ocr/src/model/DetectCardScreenshotRequest.cc
View File

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

58
ocr/src/model/GetAsyncJobResultRequest.cc
View File

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

58
ocr/src/model/RecognizeAccountPageRequest.cc
View File

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

58
ocr/src/model/RecognizeBankCardRequest.cc
View File

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

58
ocr/src/model/RecognizeBusinessCardRequest.cc
View File

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

58
ocr/src/model/RecognizeBusinessLicenseRequest.cc
View File

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

111
ocr/src/model/RecognizeCharacterRequest.cc
View File

@@ -1,106 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ocr/model/RecognizeCharacterRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeCharacterRequest;
RecognizeCharacterRequest::RecognizeCharacterRequest() :
RpcServiceRequest("ocr", "2019-12-30", "RecognizeCharacter")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeCharacterRequest::~RecognizeCharacterRequest()
{}
bool RecognizeCharacterRequest::getFormatResultToJson()const
{
return formatResultToJson_;
*/
#include <alibabacloud/ocr/model/RecognizeCharacterRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeCharacterRequest;
RecognizeCharacterRequest::RecognizeCharacterRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeCharacter") {
setMethod(HttpRequest::Method::Post);
}
void RecognizeCharacterRequest::setFormatResultToJson(bool formatResultToJson)
{
formatResultToJson_ = formatResultToJson;
setParameter("FormatResultToJson", formatResultToJson ? "true" : "false");
RecognizeCharacterRequest::~RecognizeCharacterRequest() {}
int RecognizeCharacterRequest::getMinHeight() const {
return minHeight_;
}
int RecognizeCharacterRequest::getMinHeight()const
{
return minHeight_;
void RecognizeCharacterRequest::setMinHeight(int minHeight) {
minHeight_ = minHeight;
setBodyParameter(std::string("MinHeight"), std::to_string(minHeight));
}
void RecognizeCharacterRequest::setMinHeight(int minHeight)
{
minHeight_ = minHeight;
setBodyParameter("MinHeight", std::to_string(minHeight));
int RecognizeCharacterRequest::getImageType() const {
return imageType_;
}
std::string RecognizeCharacterRequest::getOssFile()const
{
return ossFile_;
void RecognizeCharacterRequest::setImageType(int imageType) {
imageType_ = imageType;
setBodyParameter(std::string("ImageType"), std::to_string(imageType));
}
void RecognizeCharacterRequest::setOssFile(const std::string& ossFile)
{
ossFile_ = ossFile;
setParameter("OssFile", ossFile);
bool RecognizeCharacterRequest::getOutputProbability() const {
return outputProbability_;
}
int RecognizeCharacterRequest::getImageType()const
{
return imageType_;
void RecognizeCharacterRequest::setOutputProbability(bool outputProbability) {
outputProbability_ = outputProbability;
setBodyParameter(std::string("OutputProbability"), outputProbability ? "true" : "false");
}
void RecognizeCharacterRequest::setImageType(int imageType)
{
imageType_ = imageType;
setBodyParameter("ImageType", std::to_string(imageType));
std::string RecognizeCharacterRequest::getImageURL() const {
return imageURL_;
}
std::string RecognizeCharacterRequest::getRequestProxyBy()const
{
return requestProxyBy_;
}
void RecognizeCharacterRequest::setRequestProxyBy(const std::string& requestProxyBy)
{
requestProxyBy_ = requestProxyBy;
setParameter("RequestProxyBy", requestProxyBy);
}
bool RecognizeCharacterRequest::getOutputProbability()const
{
return outputProbability_;
}
void RecognizeCharacterRequest::setOutputProbability(bool outputProbability)
{
outputProbability_ = outputProbability;
setBodyParameter("OutputProbability", outputProbability ? "true" : "false");
}
std::string RecognizeCharacterRequest::getImageURL()const
{
return imageURL_;
}
void RecognizeCharacterRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
void RecognizeCharacterRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

46
ocr/src/model/RecognizeChinapassportRequest.cc
View File

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

70
ocr/src/model/RecognizeDriverLicenseRequest.cc
View File

@@ -1,62 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ocr/model/RecognizeDriverLicenseRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeDriverLicenseRequest;
RecognizeDriverLicenseRequest::RecognizeDriverLicenseRequest() :
RpcServiceRequest("ocr", "2019-12-30", "RecognizeDriverLicense")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeDriverLicenseRequest::~RecognizeDriverLicenseRequest()
{}
int RecognizeDriverLicenseRequest::getImageType()const
{
return imageType_;
*/
#include <alibabacloud/ocr/model/RecognizeDriverLicenseRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeDriverLicenseRequest;
RecognizeDriverLicenseRequest::RecognizeDriverLicenseRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeDriverLicense") {
setMethod(HttpRequest::Method::Post);
}
void RecognizeDriverLicenseRequest::setImageType(int imageType)
{
imageType_ = imageType;
setBodyParameter("ImageType", std::to_string(imageType));
RecognizeDriverLicenseRequest::~RecognizeDriverLicenseRequest() {}
int RecognizeDriverLicenseRequest::getImageType() const {
return imageType_;
}
std::string RecognizeDriverLicenseRequest::getSide()const
{
return side_;
void RecognizeDriverLicenseRequest::setImageType(int imageType) {
imageType_ = imageType;
setBodyParameter(std::string("ImageType"), std::to_string(imageType));
}
void RecognizeDriverLicenseRequest::setSide(const std::string& side)
{
side_ = side;
setBodyParameter("Side", side);
std::string RecognizeDriverLicenseRequest::getSide() const {
return side_;
}
std::string RecognizeDriverLicenseRequest::getImageURL()const
{
return imageURL_;
void RecognizeDriverLicenseRequest::setSide(const std::string &side) {
side_ = side;
setBodyParameter(std::string("Side"), side);
}
void RecognizeDriverLicenseRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
std::string RecognizeDriverLicenseRequest::getImageURL() const {
return imageURL_;
}
void RecognizeDriverLicenseRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

70
ocr/src/model/RecognizeDrivingLicenseRequest.cc
View File

@@ -1,62 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ocr/model/RecognizeDrivingLicenseRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeDrivingLicenseRequest;
RecognizeDrivingLicenseRequest::RecognizeDrivingLicenseRequest() :
RpcServiceRequest("ocr", "2019-12-30", "RecognizeDrivingLicense")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeDrivingLicenseRequest::~RecognizeDrivingLicenseRequest()
{}
int RecognizeDrivingLicenseRequest::getImageType()const
{
return imageType_;
*/
#include <alibabacloud/ocr/model/RecognizeDrivingLicenseRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeDrivingLicenseRequest;
RecognizeDrivingLicenseRequest::RecognizeDrivingLicenseRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeDrivingLicense") {
setMethod(HttpRequest::Method::Post);
}
void RecognizeDrivingLicenseRequest::setImageType(int imageType)
{
imageType_ = imageType;
setBodyParameter("ImageType", std::to_string(imageType));
RecognizeDrivingLicenseRequest::~RecognizeDrivingLicenseRequest() {}
int RecognizeDrivingLicenseRequest::getImageType() const {
return imageType_;
}
std::string RecognizeDrivingLicenseRequest::getSide()const
{
return side_;
void RecognizeDrivingLicenseRequest::setImageType(int imageType) {
imageType_ = imageType;
setBodyParameter(std::string("ImageType"), std::to_string(imageType));
}
void RecognizeDrivingLicenseRequest::setSide(const std::string& side)
{
side_ = side;
setBodyParameter("Side", side);
std::string RecognizeDrivingLicenseRequest::getSide() const {
return side_;
}
std::string RecognizeDrivingLicenseRequest::getImageURL()const
{
return imageURL_;
void RecognizeDrivingLicenseRequest::setSide(const std::string &side) {
side_ = side;
setBodyParameter(std::string("Side"), side);
}
void RecognizeDrivingLicenseRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
std::string RecognizeDrivingLicenseRequest::getImageURL() const {
return imageURL_;
}
void RecognizeDrivingLicenseRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

70
ocr/src/model/RecognizeIdentityCardRequest.cc
View File

@@ -1,62 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ocr/model/RecognizeIdentityCardRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeIdentityCardRequest;
RecognizeIdentityCardRequest::RecognizeIdentityCardRequest() :
RpcServiceRequest("ocr", "2019-12-30", "RecognizeIdentityCard")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeIdentityCardRequest::~RecognizeIdentityCardRequest()
{}
int RecognizeIdentityCardRequest::getImageType()const
{
return imageType_;
*/
#include <alibabacloud/ocr/model/RecognizeIdentityCardRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeIdentityCardRequest;
RecognizeIdentityCardRequest::RecognizeIdentityCardRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeIdentityCard") {
setMethod(HttpRequest::Method::Post);
}
void RecognizeIdentityCardRequest::setImageType(int imageType)
{
imageType_ = imageType;
setBodyParameter("ImageType", std::to_string(imageType));
RecognizeIdentityCardRequest::~RecognizeIdentityCardRequest() {}
int RecognizeIdentityCardRequest::getImageType() const {
return imageType_;
}
std::string RecognizeIdentityCardRequest::getSide()const
{
return side_;
void RecognizeIdentityCardRequest::setImageType(int imageType) {
imageType_ = imageType;
setBodyParameter(std::string("ImageType"), std::to_string(imageType));
}
void RecognizeIdentityCardRequest::setSide(const std::string& side)
{
side_ = side;
setBodyParameter("Side", side);
std::string RecognizeIdentityCardRequest::getSide() const {
return side_;
}
std::string RecognizeIdentityCardRequest::getImageURL()const
{
return imageURL_;
void RecognizeIdentityCardRequest::setSide(const std::string &side) {
side_ = side;
setBodyParameter(std::string("Side"), side);
}
void RecognizeIdentityCardRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
std::string RecognizeIdentityCardRequest::getImageURL() const {
return imageURL_;
}
void RecognizeIdentityCardRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

46
ocr/src/model/RecognizeIndonesiaIdentityCardRequest.cc
View File

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

58
ocr/src/model/RecognizeLicensePlateRequest.cc
View File

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

46
ocr/src/model/RecognizeMalaysiaIdentityCardRequest.cc
View File

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

46
ocr/src/model/RecognizePassportMRZRequest.cc
View File

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

46
ocr/src/model/RecognizePdfRequest.cc
View File

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

46
ocr/src/model/RecognizePoiNameRequest.cc
View File

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

83
ocr/src/model/RecognizeQrCodeRequest.cc
View File

@@ -1,77 +1,40 @@
/*
* 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/RecognizeQrCodeRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeQrCodeRequest;
RecognizeQrCodeRequest::RecognizeQrCodeRequest() :
RpcServiceRequest("ocr", "2019-12-30", "RecognizeQrCode")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeQrCodeRequest::~RecognizeQrCodeRequest()
{}
bool RecognizeQrCodeRequest::getFormatResultToJson()const
{
return formatResultToJson_;
*/
#include <alibabacloud/ocr/model/RecognizeQrCodeRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeQrCodeRequest;
RecognizeQrCodeRequest::RecognizeQrCodeRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeQrCode") {
setMethod(HttpRequest::Method::Post);
}
void RecognizeQrCodeRequest::setFormatResultToJson(bool formatResultToJson)
{
formatResultToJson_ = formatResultToJson;
setParameter("FormatResultToJson", formatResultToJson ? "true" : "false");
RecognizeQrCodeRequest::~RecognizeQrCodeRequest() {}
std::vector<RecognizeQrCodeRequest::Tasks> RecognizeQrCodeRequest::getTasks() const {
return tasks_;
}
std::string RecognizeQrCodeRequest::getOssFile()const
{
return ossFile_;
}
void RecognizeQrCodeRequest::setOssFile(const std::string& ossFile)
{
ossFile_ = ossFile;
setParameter("OssFile", ossFile);
}
std::vector<RecognizeQrCodeRequest::Tasks> RecognizeQrCodeRequest::getTasks()const
{
return tasks_;
}
void RecognizeQrCodeRequest::setTasks(const std::vector<Tasks>& tasks)
{
tasks_ = tasks;
for(int dep1 = 0; dep1!= tasks.size(); dep1++) {
auto tasksObj = tasks.at(dep1);
std::string tasksObjStr = "Tasks." + std::to_string(dep1 + 1);
setParameter(tasksObjStr + ".ImageURL", tasksObj.imageURL);
}
}
std::string RecognizeQrCodeRequest::getRequestProxyBy()const
{
return requestProxyBy_;
}
void RecognizeQrCodeRequest::setRequestProxyBy(const std::string& requestProxyBy)
{
requestProxyBy_ = requestProxyBy;
setParameter("RequestProxyBy", requestProxyBy);
void RecognizeQrCodeRequest::setTasks(const std::vector<RecognizeQrCodeRequest::Tasks> &tasks) {
tasks_ = tasks;
for(int dep1 = 0; dep1 != tasks.size(); dep1++) {
auto tasksObj = tasks.at(dep1);
std::string tasksObjStr = std::string("Tasks") + "." + std::to_string(dep1 + 1);
setBodyParameter(tasksObjStr + ".ImageURL", tasksObj.imageURL);
}
}

46
ocr/src/model/RecognizeQuotaInvoiceRequest.cc
View File

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

46
ocr/src/model/RecognizeRussiaIdentityCardRequest.cc
View File

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

58
ocr/src/model/RecognizeStampRequest.cc
View File

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

118
ocr/src/model/RecognizeTableRequest.cc
View File

@@ -1,106 +1,90 @@
/*
* 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/RecognizeTableRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeTableRequest;
RecognizeTableRequest::RecognizeTableRequest() :
RpcServiceRequest("ocr", "2019-12-30", "RecognizeTable")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeTableRequest::~RecognizeTableRequest()
{}
bool RecognizeTableRequest::getUseFinanceModel()const
{
return useFinanceModel_;
*/
#include <alibabacloud/ocr/model/RecognizeTableRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeTableRequest;
RecognizeTableRequest::RecognizeTableRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeTable") {
setMethod(HttpRequest::Method::Post);
}
void RecognizeTableRequest::setUseFinanceModel(bool useFinanceModel)
{
useFinanceModel_ = useFinanceModel;
setBodyParameter("UseFinanceModel", useFinanceModel ? "true" : "false");
RecognizeTableRequest::~RecognizeTableRequest() {}
bool RecognizeTableRequest::getUseFinanceModel() const {
return useFinanceModel_;
}
bool RecognizeTableRequest::getSkipDetection()const
{
return skipDetection_;
void RecognizeTableRequest::setUseFinanceModel(bool useFinanceModel) {
useFinanceModel_ = useFinanceModel;
setBodyParameter(std::string("UseFinanceModel"), useFinanceModel ? "true" : "false");
}
void RecognizeTableRequest::setSkipDetection(bool skipDetection)
{
skipDetection_ = skipDetection;
setBodyParameter("SkipDetection", skipDetection ? "true" : "false");
bool RecognizeTableRequest::getSkipDetection() const {
return skipDetection_;
}
std::string RecognizeTableRequest::getOutputFormat()const
{
return outputFormat_;
void RecognizeTableRequest::setSkipDetection(bool skipDetection) {
skipDetection_ = skipDetection;
setBodyParameter(std::string("SkipDetection"), skipDetection ? "true" : "false");
}
void RecognizeTableRequest::setOutputFormat(const std::string& outputFormat)
{
outputFormat_ = outputFormat;
setBodyParameter("OutputFormat", outputFormat);
std::string RecognizeTableRequest::getOutputFormat() const {
return outputFormat_;
}
bool RecognizeTableRequest::getAssureDirection()const
{
return assureDirection_;
void RecognizeTableRequest::setOutputFormat(const std::string &outputFormat) {
outputFormat_ = outputFormat;
setBodyParameter(std::string("OutputFormat"), outputFormat);
}
void RecognizeTableRequest::setAssureDirection(bool assureDirection)
{
assureDirection_ = assureDirection;
setBodyParameter("AssureDirection", assureDirection ? "true" : "false");
bool RecognizeTableRequest::getAssureDirection() const {
return assureDirection_;
}
bool RecognizeTableRequest::getHasLine()const
{
return hasLine_;
void RecognizeTableRequest::setAssureDirection(bool assureDirection) {
assureDirection_ = assureDirection;
setBodyParameter(std::string("AssureDirection"), assureDirection ? "true" : "false");
}
void RecognizeTableRequest::setHasLine(bool hasLine)
{
hasLine_ = hasLine;
setBodyParameter("HasLine", hasLine ? "true" : "false");
bool RecognizeTableRequest::getHasLine() const {
return hasLine_;
}
int RecognizeTableRequest::getImageType()const
{
return imageType_;
void RecognizeTableRequest::setHasLine(bool hasLine) {
hasLine_ = hasLine;
setBodyParameter(std::string("HasLine"), hasLine ? "true" : "false");
}
void RecognizeTableRequest::setImageType(int imageType)
{
imageType_ = imageType;
setBodyParameter("ImageType", std::to_string(imageType));
int RecognizeTableRequest::getImageType() const {
return imageType_;
}
std::string RecognizeTableRequest::getImageURL()const
{
return imageURL_;
void RecognizeTableRequest::setImageType(int imageType) {
imageType_ = imageType;
setBodyParameter(std::string("ImageType"), std::to_string(imageType));
}
void RecognizeTableRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
std::string RecognizeTableRequest::getImageURL() const {
return imageURL_;
}
void RecognizeTableRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

46
ocr/src/model/RecognizeTakeoutOrderRequest.cc
View File

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

58
ocr/src/model/RecognizeTaxiInvoiceRequest.cc
View File

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

46
ocr/src/model/RecognizeTicketInvoiceRequest.cc
View File

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

58
ocr/src/model/RecognizeTrainTicketRequest.cc
View File

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

28
ocr/src/model/RecognizeTrainTicketResult.cc
View File

@@ -40,22 +40,22 @@ void RecognizeTrainTicketResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["Date"].isNull())
data_.date = dataNode["Date"].asString();
if(!dataNode["Destination"].isNull())
data_.destination = dataNode["Destination"].asString();
if(!dataNode["Level"].isNull())
data_.level = dataNode["Level"].asString();
if(!dataNode["Number"].isNull())
data_.number = dataNode["Number"].asString();
if(!dataNode["Name"].isNull())
data_.name = dataNode["Name"].asString();
if(!dataNode["DepartureStation"].isNull())
data_.departureStation = dataNode["DepartureStation"].asString();
if(!dataNode["Seat"].isNull())
data_.seat = dataNode["Seat"].asString();
if(!dataNode["Price"].isNull())
data_.price = std::stof(dataNode["Price"].asString());
if(!dataNode["Destination"].isNull())
data_.destination = dataNode["Destination"].asString();
if(!dataNode["DepartureStation"].isNull())
data_.departureStation = dataNode["DepartureStation"].asString();
if(!dataNode["Date"].isNull())
data_.date = dataNode["Date"].asString();
if(!dataNode["Number"].isNull())
data_.number = dataNode["Number"].asString();
if(!dataNode["Seat"].isNull())
data_.seat = dataNode["Seat"].asString();
if(!dataNode["Name"].isNull())
data_.name = dataNode["Name"].asString();
if(!dataNode["Level"].isNull())
data_.level = dataNode["Level"].asString();
}

46
ocr/src/model/RecognizeTurkeyIdentityCardRequest.cc
View File

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

46
ocr/src/model/RecognizeUkraineIdentityCardRequest.cc
View File

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

58
ocr/src/model/RecognizeVATInvoiceRequest.cc
View File

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

58
ocr/src/model/RecognizeVINCodeRequest.cc
View File

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

46
ocr/src/model/RecognizeVerificationcodeRequest.cc
View File

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

84
ocr/src/model/RecognizeVideoCastCrewListRequest.cc
View File

@@ -1,73 +1,65 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ocr/model/RecognizeVideoCastCrewListRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeVideoCastCrewListRequest;
RecognizeVideoCastCrewListRequest::RecognizeVideoCastCrewListRequest() :
RpcServiceRequest("ocr", "2019-12-30", "RecognizeVideoCastCrewList")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeVideoCastCrewListRequest::~RecognizeVideoCastCrewListRequest()
{}
Array RecognizeVideoCastCrewListRequest::getParams()const
{
return params_;
*/
#include <alibabacloud/ocr/model/RecognizeVideoCastCrewListRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeVideoCastCrewListRequest;
RecognizeVideoCastCrewListRequest::RecognizeVideoCastCrewListRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeVideoCastCrewList") {
setMethod(HttpRequest::Method::Post);
}
void RecognizeVideoCastCrewListRequest::setParams(const Array& params)
{
params_ = params;
setBodyParameter("Params", std::to_string(params));
RecognizeVideoCastCrewListRequest::~RecognizeVideoCastCrewListRequest() {}
std::vector<RecognizeVideoCastCrewListRequest::Params> RecognizeVideoCastCrewListRequest::getParams() const {
return params_;
}
bool RecognizeVideoCastCrewListRequest::getAsync()const
{
return async_;
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);
}
}
void RecognizeVideoCastCrewListRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
bool RecognizeVideoCastCrewListRequest::getAsync() const {
return async_;
}
std::string RecognizeVideoCastCrewListRequest::getRegisterUrl()const
{
return registerUrl_;
void RecognizeVideoCastCrewListRequest::setAsync(bool async) {
async_ = async;
setBodyParameter(std::string("Async"), async ? "true" : "false");
}
void RecognizeVideoCastCrewListRequest::setRegisterUrl(const std::string& registerUrl)
{
registerUrl_ = registerUrl;
setBodyParameter("RegisterUrl", registerUrl);
std::string RecognizeVideoCastCrewListRequest::getRegisterUrl() const {
return registerUrl_;
}
std::string RecognizeVideoCastCrewListRequest::getVideoUrl()const
{
return videoUrl_;
void RecognizeVideoCastCrewListRequest::setRegisterUrl(const std::string &registerUrl) {
registerUrl_ = registerUrl;
setBodyParameter(std::string("RegisterUrl"), registerUrl);
}
void RecognizeVideoCastCrewListRequest::setVideoUrl(const std::string& videoUrl)
{
videoUrl_ = videoUrl;
setBodyParameter("VideoUrl", videoUrl);
std::string RecognizeVideoCastCrewListRequest::getVideoUrl() const {
return videoUrl_;
}
void RecognizeVideoCastCrewListRequest::setVideoUrl(const std::string &videoUrl) {
videoUrl_ = videoUrl;
setBodyParameter(std::string("VideoUrl"), videoUrl);
}

58
ocr/src/model/RecognizeVideoCharacterRequest.cc
View File

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

46
ocr/src/model/RecognizeVietnamIdentityCardRequest.cc
View File

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

82
ocr/src/model/TrimDocumentRequest.cc
View File

@@ -1,73 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ocr/model/TrimDocumentRequest.h>
using AlibabaCloud::Ocr::Model::TrimDocumentRequest;
TrimDocumentRequest::TrimDocumentRequest() :
RpcServiceRequest("ocr", "2019-12-30", "TrimDocument")
{
setMethod(HttpRequest::Method::Post);
}
TrimDocumentRequest::~TrimDocumentRequest()
{}
std::string TrimDocumentRequest::getFileType()const
{
return fileType_;
*/
#include <alibabacloud/ocr/model/TrimDocumentRequest.h>
using AlibabaCloud::Ocr::Model::TrimDocumentRequest;
TrimDocumentRequest::TrimDocumentRequest()
: RpcServiceRequest("ocr", "2019-12-30", "TrimDocument") {
setMethod(HttpRequest::Method::Post);
}
void TrimDocumentRequest::setFileType(const std::string& fileType)
{
fileType_ = fileType;
setBodyParameter("FileType", fileType);
TrimDocumentRequest::~TrimDocumentRequest() {}
std::string TrimDocumentRequest::getFileType() const {
return fileType_;
}
std::string TrimDocumentRequest::getOutputType()const
{
return outputType_;
void TrimDocumentRequest::setFileType(const std::string &fileType) {
fileType_ = fileType;
setBodyParameter(std::string("FileType"), fileType);
}
void TrimDocumentRequest::setOutputType(const std::string& outputType)
{
outputType_ = outputType;
setBodyParameter("OutputType", outputType);
std::string TrimDocumentRequest::getOutputType() const {
return outputType_;
}
bool TrimDocumentRequest::getAsync()const
{
return async_;
void TrimDocumentRequest::setOutputType(const std::string &outputType) {
outputType_ = outputType;
setBodyParameter(std::string("OutputType"), outputType);
}
void TrimDocumentRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
bool TrimDocumentRequest::getAsync() const {
return async_;
}
std::string TrimDocumentRequest::getFileURL()const
{
return fileURL_;
void TrimDocumentRequest::setAsync(bool async) {
async_ = async;
setBodyParameter(std::string("Async"), async ? "true" : "false");
}
void TrimDocumentRequest::setFileURL(const std::string& fileURL)
{
fileURL_ = fileURL;
setBodyParameter("FileURL", fileURL);
std::string TrimDocumentRequest::getFileURL() const {
return fileURL_;
}
void TrimDocumentRequest::setFileURL(const std::string &fileURL) {
fileURL_ = fileURL;
setBodyParameter(std::string("FileURL"), fileURL);
}