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-10-17 03:50:45 +00:00
parent a1bc2cb5af
commit e7cf03a9fd
77 changed files with 2639 additions and 2106 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
VERSION
View File

@@ -1 +1 @@
1.36.1298
1.36.1299

68
ocr/include/alibabacloud/ocr/model/DetectCardScreenshotRequest.h
View File

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

74
ocr/include/alibabacloud/ocr/model/GetAsyncJobResultRequest.h
View File

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

74
ocr/include/alibabacloud/ocr/model/RecognizeAccountPageRequest.h
View File

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

74
ocr/include/alibabacloud/ocr/model/RecognizeBankCardRequest.h
View File

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

74
ocr/include/alibabacloud/ocr/model/RecognizeBusinessCardRequest.h
View File

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

74
ocr/include/alibabacloud/ocr/model/RecognizeBusinessLicenseRequest.h
View File

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

95
ocr/include/alibabacloud/ocr/model/RecognizeCharacterRequest.h
View File

@@ -1,51 +1,66 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZECHARACTERREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZECHARACTERREQUEST_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 RecognizeCharacterRequest : public RpcServiceRequest {
public:
RecognizeCharacterRequest();
~RecognizeCharacterRequest();
int getMinHeight() const;
void setMinHeight(int minHeight);
int getImageType() const;
void setImageType(int imageType);
bool getOutputProbability() const;
void setOutputProbability(bool outputProbability);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
int minHeight_;
int imageType_;
bool outputProbability_;
std::string imageURL_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZECHARACTERREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZECHARACTERREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZECHARACTERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizeCharacterRequest : public RpcServiceRequest
{
public:
RecognizeCharacterRequest();
~RecognizeCharacterRequest();
bool getFormatResultToJson()const;
void setFormatResultToJson(bool formatResultToJson);
int getMinHeight()const;
void setMinHeight(int minHeight);
std::string getOssFile()const;
void setOssFile(const std::string& ossFile);
int getImageType()const;
void setImageType(int imageType);
std::string getRequestProxyBy()const;
void setRequestProxyBy(const std::string& requestProxyBy);
bool getOutputProbability()const;
void setOutputProbability(bool outputProbability);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
bool formatResultToJson_;
int minHeight_;
std::string ossFile_;
int imageType_;
std::string requestProxyBy_;
bool outputProbability_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZECHARACTERREQUEST_H_

68
ocr/include/alibabacloud/ocr/model/RecognizeChinapassportRequest.h
View File

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

80
ocr/include/alibabacloud/ocr/model/RecognizeDriverLicenseRequest.h
View File

@@ -1,48 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEDRIVERLICENSEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEDRIVERLICENSEREQUEST_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 RecognizeDriverLicenseRequest : public RpcServiceRequest {
public:
RecognizeDriverLicenseRequest();
~RecognizeDriverLicenseRequest();
int getImageType() const;
void setImageType(int imageType);
std::string getSide() const;
void setSide(const std::string &side);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
int imageType_;
std::string side_;
std::string imageURL_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEDRIVERLICENSEREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEDRIVERLICENSEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEDRIVERLICENSEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizeDriverLicenseRequest : public RpcServiceRequest
{
public:
RecognizeDriverLicenseRequest();
~RecognizeDriverLicenseRequest();
int getImageType()const;
void setImageType(int imageType);
std::string getSide()const;
void setSide(const std::string& side);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
int imageType_;
std::string side_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEDRIVERLICENSEREQUEST_H_

80
ocr/include/alibabacloud/ocr/model/RecognizeDrivingLicenseRequest.h
View File

@@ -1,48 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEDRIVINGLICENSEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEDRIVINGLICENSEREQUEST_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 RecognizeDrivingLicenseRequest : public RpcServiceRequest {
public:
RecognizeDrivingLicenseRequest();
~RecognizeDrivingLicenseRequest();
int getImageType() const;
void setImageType(int imageType);
std::string getSide() const;
void setSide(const std::string &side);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
int imageType_;
std::string side_;
std::string imageURL_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEDRIVINGLICENSEREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEDRIVINGLICENSEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEDRIVINGLICENSEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizeDrivingLicenseRequest : public RpcServiceRequest
{
public:
RecognizeDrivingLicenseRequest();
~RecognizeDrivingLicenseRequest();
int getImageType()const;
void setImageType(int imageType);
std::string getSide()const;
void setSide(const std::string& side);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
int imageType_;
std::string side_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEDRIVINGLICENSEREQUEST_H_

80
ocr/include/alibabacloud/ocr/model/RecognizeIdentityCardRequest.h
View File

@@ -1,48 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEIDENTITYCARDREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEIDENTITYCARDREQUEST_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 RecognizeIdentityCardRequest : public RpcServiceRequest {
public:
RecognizeIdentityCardRequest();
~RecognizeIdentityCardRequest();
int getImageType() const;
void setImageType(int imageType);
std::string getSide() const;
void setSide(const std::string &side);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
int imageType_;
std::string side_;
std::string imageURL_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEIDENTITYCARDREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEIDENTITYCARDREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEIDENTITYCARDREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizeIdentityCardRequest : public RpcServiceRequest
{
public:
RecognizeIdentityCardRequest();
~RecognizeIdentityCardRequest();
int getImageType()const;
void setImageType(int imageType);
std::string getSide()const;
void setSide(const std::string& side);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
int imageType_;
std::string side_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEIDENTITYCARDREQUEST_H_

68
ocr/include/alibabacloud/ocr/model/RecognizeIndonesiaIdentityCardRequest.h
View File

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

74
ocr/include/alibabacloud/ocr/model/RecognizeLicensePlateRequest.h
View File

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

68
ocr/include/alibabacloud/ocr/model/RecognizeMalaysiaIdentityCardRequest.h
View File

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

68
ocr/include/alibabacloud/ocr/model/RecognizePassportMRZRequest.h
View File

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

68
ocr/include/alibabacloud/ocr/model/RecognizePdfRequest.h
View File

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

68
ocr/include/alibabacloud/ocr/model/RecognizePoiNameRequest.h
View File

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

85
ocr/include/alibabacloud/ocr/model/RecognizeQrCodeRequest.h
View File

@@ -1,45 +1,62 @@
/*
* 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_RECOGNIZEQRCODEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEQRCODEREQUEST_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 RecognizeQrCodeRequest : public RpcServiceRequest {
public:
struct Tasks {
std::string imageURL;
};
RecognizeQrCodeRequest();
~RecognizeQrCodeRequest();
std::vector<Tasks> getTasks() const;
void setTasks(const std::vector<Tasks> &tasks);
private:
std::vector<Tasks> tasks_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEQRCODEREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEQRCODEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEQRCODEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizeQrCodeRequest : public RpcServiceRequest
{
public:
struct Tasks
{
std::string imageURL;
};
public:
RecognizeQrCodeRequest();
~RecognizeQrCodeRequest();
bool getFormatResultToJson()const;
void setFormatResultToJson(bool formatResultToJson);
std::string getOssFile()const;
void setOssFile(const std::string& ossFile);
std::vector<Tasks> getTasks()const;
void setTasks(const std::vector<Tasks>& tasks);
std::string getRequestProxyBy()const;
void setRequestProxyBy(const std::string& requestProxyBy);
private:
bool formatResultToJson_;
std::string ossFile_;
std::vector<Tasks> tasks_;
std::string requestProxyBy_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEQRCODEREQUEST_H_

68
ocr/include/alibabacloud/ocr/model/RecognizeQuotaInvoiceRequest.h
View File

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

68
ocr/include/alibabacloud/ocr/model/RecognizeRussiaIdentityCardRequest.h
View File

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

74
ocr/include/alibabacloud/ocr/model/RecognizeStampRequest.h
View File

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

104
ocr/include/alibabacloud/ocr/model/RecognizeTableRequest.h
View File

@@ -1,60 +1,66 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZETABLEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZETABLEREQUEST_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 RecognizeTableRequest : public RpcServiceRequest {
public:
RecognizeTableRequest();
~RecognizeTableRequest();
bool getUseFinanceModel() const;
void setUseFinanceModel(bool useFinanceModel);
bool getSkipDetection() const;
void setSkipDetection(bool skipDetection);
std::string getOutputFormat() const;
void setOutputFormat(const std::string &outputFormat);
bool getAssureDirection() const;
void setAssureDirection(bool assureDirection);
bool getHasLine() const;
void setHasLine(bool hasLine);
int getImageType() const;
void setImageType(int imageType);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
bool useFinanceModel_;
bool skipDetection_;
std::string outputFormat_;
bool assureDirection_;
bool hasLine_;
int imageType_;
std::string imageURL_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZETABLEREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZETABLEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZETABLEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizeTableRequest : public RpcServiceRequest
{
public:
RecognizeTableRequest();
~RecognizeTableRequest();
bool getUseFinanceModel()const;
void setUseFinanceModel(bool useFinanceModel);
bool getSkipDetection()const;
void setSkipDetection(bool skipDetection);
std::string getOutputFormat()const;
void setOutputFormat(const std::string& outputFormat);
bool getAssureDirection()const;
void setAssureDirection(bool assureDirection);
bool getHasLine()const;
void setHasLine(bool hasLine);
int getImageType()const;
void setImageType(int imageType);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
bool useFinanceModel_;
bool skipDetection_;
std::string outputFormat_;
bool assureDirection_;
bool hasLine_;
int imageType_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZETABLEREQUEST_H_

68
ocr/include/alibabacloud/ocr/model/RecognizeTakeoutOrderRequest.h
View File

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

74
ocr/include/alibabacloud/ocr/model/RecognizeTaxiInvoiceRequest.h
View File

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

68
ocr/include/alibabacloud/ocr/model/RecognizeTicketInvoiceRequest.h
View File

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

74
ocr/include/alibabacloud/ocr/model/RecognizeTrainTicketRequest.h
View File

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

2
ocr/include/alibabacloud/ocr/model/RecognizeTrainTicketResult.h
View File

@@ -40,8 +40,8 @@ namespace AlibabaCloud
float price;
std::string level;
std::string date;
std::string departureStation;
std::string name;
std::string departureStation;
};

68
ocr/include/alibabacloud/ocr/model/RecognizeTurkeyIdentityCardRequest.h
View File

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

68
ocr/include/alibabacloud/ocr/model/RecognizeUkraineIdentityCardRequest.h
View File

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

74
ocr/include/alibabacloud/ocr/model/RecognizeVATInvoiceRequest.h
View File

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

74
ocr/include/alibabacloud/ocr/model/RecognizeVINCodeRequest.h
View File

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

68
ocr/include/alibabacloud/ocr/model/RecognizeVerificationcodeRequest.h
View File

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

89
ocr/include/alibabacloud/ocr/model/RecognizeVideoCastCrewListRequest.h
View File

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

74
ocr/include/alibabacloud/ocr/model/RecognizeVideoCharacterRequest.h
View File

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

4
ocr/include/alibabacloud/ocr/model/RecognizeVideoCharacterResult.h
View File

@@ -63,12 +63,16 @@ namespace AlibabaCloud
RecognizeVideoCharacterResult();
explicit RecognizeVideoCharacterResult(const std::string &payload);
~RecognizeVideoCharacterResult();
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_;
};
}

68
ocr/include/alibabacloud/ocr/model/RecognizeVietnamIdentityCardRequest.h
View File

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

86
ocr/include/alibabacloud/ocr/model/TrimDocumentRequest.h
View File

@@ -1,51 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_TRIMDOCUMENTREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_TRIMDOCUMENTREQUEST_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 TrimDocumentRequest : public RpcServiceRequest {
public:
TrimDocumentRequest();
~TrimDocumentRequest();
std::string getFileType() const;
void setFileType(const std::string &fileType);
std::string getOutputType() const;
void setOutputType(const std::string &outputType);
bool getAsync() const;
void setAsync(bool async);
std::string getFileURL() const;
void setFileURL(const std::string &fileURL);
private:
std::string fileType_;
std::string outputType_;
bool async_;
std::string fileURL_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_TRIMDOCUMENTREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_TRIMDOCUMENTREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_TRIMDOCUMENTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT TrimDocumentRequest : public RpcServiceRequest
{
public:
TrimDocumentRequest();
~TrimDocumentRequest();
std::string getFileType()const;
void setFileType(const std::string& fileType);
std::string getOutputType()const;
void setOutputType(const std::string& outputType);
bool getAsync()const;
void setAsync(bool async);
std::string getFileURL()const;
void setFileURL(const std::string& fileURL);
private:
std::string fileType_;
std::string outputType_;
bool async_;
std::string fileURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_TRIMDOCUMENTREQUEST_H_

4
ocr/include/alibabacloud/ocr/model/TrimDocumentResult.h
View File

@@ -41,12 +41,16 @@ namespace AlibabaCloud
TrimDocumentResult();
explicit TrimDocumentResult(const std::string &payload);
~TrimDocumentResult();
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_;
};
}

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

@@ -1,36 +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/DetectCardScreenshotRequest.h>
using AlibabaCloud::Ocr::Model::DetectCardScreenshotRequest;
DetectCardScreenshotRequest::DetectCardScreenshotRequest()
: RpcServiceRequest("ocr", "2019-12-30", "DetectCardScreenshot") {
setMethod(HttpRequest::Method::Post);
*/
#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_;
}
DetectCardScreenshotRequest::~DetectCardScreenshotRequest() {}
std::string DetectCardScreenshotRequest::getImageURL() const {
return imageURL_;
}
void DetectCardScreenshotRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
void DetectCardScreenshotRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}

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

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

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

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

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

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

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

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

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

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

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

@@ -1,63 +1,106 @@
/*
* 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);
*/
#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_;
}
RecognizeCharacterRequest::~RecognizeCharacterRequest() {}
int RecognizeCharacterRequest::getMinHeight() const {
return minHeight_;
void RecognizeCharacterRequest::setFormatResultToJson(bool formatResultToJson)
{
formatResultToJson_ = formatResultToJson;
setParameter("FormatResultToJson", formatResultToJson ? "true" : "false");
}
void RecognizeCharacterRequest::setMinHeight(int minHeight) {
minHeight_ = minHeight;
setBodyParameter(std::string("MinHeight"), std::to_string(minHeight));
int RecognizeCharacterRequest::getMinHeight()const
{
return minHeight_;
}
int RecognizeCharacterRequest::getImageType() const {
return imageType_;
void RecognizeCharacterRequest::setMinHeight(int minHeight)
{
minHeight_ = minHeight;
setBodyParameter("MinHeight", std::to_string(minHeight));
}
void RecognizeCharacterRequest::setImageType(int imageType) {
imageType_ = imageType;
setBodyParameter(std::string("ImageType"), std::to_string(imageType));
std::string RecognizeCharacterRequest::getOssFile()const
{
return ossFile_;
}
bool RecognizeCharacterRequest::getOutputProbability() const {
return outputProbability_;
void RecognizeCharacterRequest::setOssFile(const std::string& ossFile)
{
ossFile_ = ossFile;
setParameter("OssFile", ossFile);
}
void RecognizeCharacterRequest::setOutputProbability(bool outputProbability) {
outputProbability_ = outputProbability;
setBodyParameter(std::string("OutputProbability"), outputProbability ? "true" : "false");
int RecognizeCharacterRequest::getImageType()const
{
return imageType_;
}
std::string RecognizeCharacterRequest::getImageURL() const {
return imageURL_;
void RecognizeCharacterRequest::setImageType(int imageType)
{
imageType_ = imageType;
setBodyParameter("ImageType", std::to_string(imageType));
}
void RecognizeCharacterRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), 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);
}

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

@@ -1,36 +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/RecognizeChinapassportRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeChinapassportRequest;
RecognizeChinapassportRequest::RecognizeChinapassportRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeChinapassport") {
setMethod(HttpRequest::Method::Post);
*/
#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_;
}
RecognizeChinapassportRequest::~RecognizeChinapassportRequest() {}
std::string RecognizeChinapassportRequest::getImageURL() const {
return imageURL_;
}
void RecognizeChinapassportRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
void RecognizeChinapassportRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}

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

@@ -1,54 +1,62 @@
/*
* 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);
*/
#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_;
}
RecognizeDriverLicenseRequest::~RecognizeDriverLicenseRequest() {}
int RecognizeDriverLicenseRequest::getImageType() const {
return imageType_;
void RecognizeDriverLicenseRequest::setImageType(int imageType)
{
imageType_ = imageType;
setBodyParameter("ImageType", std::to_string(imageType));
}
void RecognizeDriverLicenseRequest::setImageType(int imageType) {
imageType_ = imageType;
setBodyParameter(std::string("ImageType"), std::to_string(imageType));
std::string RecognizeDriverLicenseRequest::getSide()const
{
return side_;
}
std::string RecognizeDriverLicenseRequest::getSide() const {
return side_;
void RecognizeDriverLicenseRequest::setSide(const std::string& side)
{
side_ = side;
setBodyParameter("Side", side);
}
void RecognizeDriverLicenseRequest::setSide(const std::string &side) {
side_ = side;
setBodyParameter(std::string("Side"), side);
std::string RecognizeDriverLicenseRequest::getImageURL()const
{
return imageURL_;
}
std::string RecognizeDriverLicenseRequest::getImageURL() const {
return imageURL_;
}
void RecognizeDriverLicenseRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
void RecognizeDriverLicenseRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}

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

@@ -1,54 +1,62 @@
/*
* 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);
*/
#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_;
}
RecognizeDrivingLicenseRequest::~RecognizeDrivingLicenseRequest() {}
int RecognizeDrivingLicenseRequest::getImageType() const {
return imageType_;
void RecognizeDrivingLicenseRequest::setImageType(int imageType)
{
imageType_ = imageType;
setBodyParameter("ImageType", std::to_string(imageType));
}
void RecognizeDrivingLicenseRequest::setImageType(int imageType) {
imageType_ = imageType;
setBodyParameter(std::string("ImageType"), std::to_string(imageType));
std::string RecognizeDrivingLicenseRequest::getSide()const
{
return side_;
}
std::string RecognizeDrivingLicenseRequest::getSide() const {
return side_;
void RecognizeDrivingLicenseRequest::setSide(const std::string& side)
{
side_ = side;
setBodyParameter("Side", side);
}
void RecognizeDrivingLicenseRequest::setSide(const std::string &side) {
side_ = side;
setBodyParameter(std::string("Side"), side);
std::string RecognizeDrivingLicenseRequest::getImageURL()const
{
return imageURL_;
}
std::string RecognizeDrivingLicenseRequest::getImageURL() const {
return imageURL_;
}
void RecognizeDrivingLicenseRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
void RecognizeDrivingLicenseRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}

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

@@ -1,54 +1,62 @@
/*
* 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);
*/
#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_;
}
RecognizeIdentityCardRequest::~RecognizeIdentityCardRequest() {}
int RecognizeIdentityCardRequest::getImageType() const {
return imageType_;
void RecognizeIdentityCardRequest::setImageType(int imageType)
{
imageType_ = imageType;
setBodyParameter("ImageType", std::to_string(imageType));
}
void RecognizeIdentityCardRequest::setImageType(int imageType) {
imageType_ = imageType;
setBodyParameter(std::string("ImageType"), std::to_string(imageType));
std::string RecognizeIdentityCardRequest::getSide()const
{
return side_;
}
std::string RecognizeIdentityCardRequest::getSide() const {
return side_;
void RecognizeIdentityCardRequest::setSide(const std::string& side)
{
side_ = side;
setBodyParameter("Side", side);
}
void RecognizeIdentityCardRequest::setSide(const std::string &side) {
side_ = side;
setBodyParameter(std::string("Side"), side);
std::string RecognizeIdentityCardRequest::getImageURL()const
{
return imageURL_;
}
std::string RecognizeIdentityCardRequest::getImageURL() const {
return imageURL_;
}
void RecognizeIdentityCardRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
void RecognizeIdentityCardRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}

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

@@ -1,36 +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/RecognizeIndonesiaIdentityCardRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeIndonesiaIdentityCardRequest;
RecognizeIndonesiaIdentityCardRequest::RecognizeIndonesiaIdentityCardRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeIndonesiaIdentityCard") {
setMethod(HttpRequest::Method::Post);
*/
#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_;
}
RecognizeIndonesiaIdentityCardRequest::~RecognizeIndonesiaIdentityCardRequest() {}
std::string RecognizeIndonesiaIdentityCardRequest::getImageUrl() const {
return imageUrl_;
}
void RecognizeIndonesiaIdentityCardRequest::setImageUrl(const std::string &imageUrl) {
imageUrl_ = imageUrl;
setBodyParameter(std::string("ImageUrl"), imageUrl);
void RecognizeIndonesiaIdentityCardRequest::setImageUrl(const std::string& imageUrl)
{
imageUrl_ = imageUrl;
setBodyParameter("ImageUrl", imageUrl);
}

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

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

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

@@ -1,36 +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/RecognizeMalaysiaIdentityCardRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeMalaysiaIdentityCardRequest;
RecognizeMalaysiaIdentityCardRequest::RecognizeMalaysiaIdentityCardRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeMalaysiaIdentityCard") {
setMethod(HttpRequest::Method::Post);
*/
#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_;
}
RecognizeMalaysiaIdentityCardRequest::~RecognizeMalaysiaIdentityCardRequest() {}
std::string RecognizeMalaysiaIdentityCardRequest::getImageUrl() const {
return imageUrl_;
}
void RecognizeMalaysiaIdentityCardRequest::setImageUrl(const std::string &imageUrl) {
imageUrl_ = imageUrl;
setBodyParameter(std::string("ImageUrl"), imageUrl);
void RecognizeMalaysiaIdentityCardRequest::setImageUrl(const std::string& imageUrl)
{
imageUrl_ = imageUrl;
setBodyParameter("ImageUrl", imageUrl);
}

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

@@ -1,36 +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/RecognizePassportMRZRequest.h>
using AlibabaCloud::Ocr::Model::RecognizePassportMRZRequest;
RecognizePassportMRZRequest::RecognizePassportMRZRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizePassportMRZ") {
setMethod(HttpRequest::Method::Post);
*/
#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_;
}
RecognizePassportMRZRequest::~RecognizePassportMRZRequest() {}
std::string RecognizePassportMRZRequest::getImageURL() const {
return imageURL_;
}
void RecognizePassportMRZRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
void RecognizePassportMRZRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}

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

@@ -1,36 +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/RecognizePdfRequest.h>
using AlibabaCloud::Ocr::Model::RecognizePdfRequest;
RecognizePdfRequest::RecognizePdfRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizePdf") {
setMethod(HttpRequest::Method::Post);
*/
#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_;
}
RecognizePdfRequest::~RecognizePdfRequest() {}
std::string RecognizePdfRequest::getFileURL() const {
return fileURL_;
}
void RecognizePdfRequest::setFileURL(const std::string &fileURL) {
fileURL_ = fileURL;
setBodyParameter(std::string("FileURL"), fileURL);
void RecognizePdfRequest::setFileURL(const std::string& fileURL)
{
fileURL_ = fileURL;
setBodyParameter("FileURL", fileURL);
}

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

@@ -1,36 +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/RecognizePoiNameRequest.h>
using AlibabaCloud::Ocr::Model::RecognizePoiNameRequest;
RecognizePoiNameRequest::RecognizePoiNameRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizePoiName") {
setMethod(HttpRequest::Method::Post);
*/
#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_;
}
RecognizePoiNameRequest::~RecognizePoiNameRequest() {}
std::string RecognizePoiNameRequest::getImageURL() const {
return imageURL_;
}
void RecognizePoiNameRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
void RecognizePoiNameRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}

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

@@ -1,40 +1,77 @@
/*
* 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);
*/
#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_;
}
RecognizeQrCodeRequest::~RecognizeQrCodeRequest() {}
std::vector<RecognizeQrCodeRequest::Tasks> RecognizeQrCodeRequest::getTasks() const {
return tasks_;
void RecognizeQrCodeRequest::setFormatResultToJson(bool formatResultToJson)
{
formatResultToJson_ = formatResultToJson;
setParameter("FormatResultToJson", formatResultToJson ? "true" : "false");
}
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);
}
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);
}

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

@@ -1,36 +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/RecognizeQuotaInvoiceRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeQuotaInvoiceRequest;
RecognizeQuotaInvoiceRequest::RecognizeQuotaInvoiceRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeQuotaInvoice") {
setMethod(HttpRequest::Method::Post);
*/
#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_;
}
RecognizeQuotaInvoiceRequest::~RecognizeQuotaInvoiceRequest() {}
std::string RecognizeQuotaInvoiceRequest::getImageURL() const {
return imageURL_;
}
void RecognizeQuotaInvoiceRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
void RecognizeQuotaInvoiceRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}

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

@@ -1,36 +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/RecognizeRussiaIdentityCardRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeRussiaIdentityCardRequest;
RecognizeRussiaIdentityCardRequest::RecognizeRussiaIdentityCardRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeRussiaIdentityCard") {
setMethod(HttpRequest::Method::Post);
*/
#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_;
}
RecognizeRussiaIdentityCardRequest::~RecognizeRussiaIdentityCardRequest() {}
std::string RecognizeRussiaIdentityCardRequest::getImageUrl() const {
return imageUrl_;
}
void RecognizeRussiaIdentityCardRequest::setImageUrl(const std::string &imageUrl) {
imageUrl_ = imageUrl;
setBodyParameter(std::string("ImageUrl"), imageUrl);
void RecognizeRussiaIdentityCardRequest::setImageUrl(const std::string& imageUrl)
{
imageUrl_ = imageUrl;
setBodyParameter("ImageUrl", imageUrl);
}

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

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

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

@@ -1,90 +1,106 @@
/*
* 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);
*/
#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_;
}
RecognizeTableRequest::~RecognizeTableRequest() {}
bool RecognizeTableRequest::getUseFinanceModel() const {
return useFinanceModel_;
void RecognizeTableRequest::setUseFinanceModel(bool useFinanceModel)
{
useFinanceModel_ = useFinanceModel;
setBodyParameter("UseFinanceModel", useFinanceModel ? "true" : "false");
}
void RecognizeTableRequest::setUseFinanceModel(bool useFinanceModel) {
useFinanceModel_ = useFinanceModel;
setBodyParameter(std::string("UseFinanceModel"), useFinanceModel ? "true" : "false");
bool RecognizeTableRequest::getSkipDetection()const
{
return skipDetection_;
}
bool RecognizeTableRequest::getSkipDetection() const {
return skipDetection_;
void RecognizeTableRequest::setSkipDetection(bool skipDetection)
{
skipDetection_ = skipDetection;
setBodyParameter("SkipDetection", skipDetection ? "true" : "false");
}
void RecognizeTableRequest::setSkipDetection(bool skipDetection) {
skipDetection_ = skipDetection;
setBodyParameter(std::string("SkipDetection"), skipDetection ? "true" : "false");
std::string RecognizeTableRequest::getOutputFormat()const
{
return outputFormat_;
}
std::string RecognizeTableRequest::getOutputFormat() const {
return outputFormat_;
void RecognizeTableRequest::setOutputFormat(const std::string& outputFormat)
{
outputFormat_ = outputFormat;
setBodyParameter("OutputFormat", outputFormat);
}
void RecognizeTableRequest::setOutputFormat(const std::string &outputFormat) {
outputFormat_ = outputFormat;
setBodyParameter(std::string("OutputFormat"), outputFormat);
bool RecognizeTableRequest::getAssureDirection()const
{
return assureDirection_;
}
bool RecognizeTableRequest::getAssureDirection() const {
return assureDirection_;
void RecognizeTableRequest::setAssureDirection(bool assureDirection)
{
assureDirection_ = assureDirection;
setBodyParameter("AssureDirection", assureDirection ? "true" : "false");
}
void RecognizeTableRequest::setAssureDirection(bool assureDirection) {
assureDirection_ = assureDirection;
setBodyParameter(std::string("AssureDirection"), assureDirection ? "true" : "false");
bool RecognizeTableRequest::getHasLine()const
{
return hasLine_;
}
bool RecognizeTableRequest::getHasLine() const {
return hasLine_;
void RecognizeTableRequest::setHasLine(bool hasLine)
{
hasLine_ = hasLine;
setBodyParameter("HasLine", hasLine ? "true" : "false");
}
void RecognizeTableRequest::setHasLine(bool hasLine) {
hasLine_ = hasLine;
setBodyParameter(std::string("HasLine"), hasLine ? "true" : "false");
int RecognizeTableRequest::getImageType()const
{
return imageType_;
}
int RecognizeTableRequest::getImageType() const {
return imageType_;
void RecognizeTableRequest::setImageType(int imageType)
{
imageType_ = imageType;
setBodyParameter("ImageType", std::to_string(imageType));
}
void RecognizeTableRequest::setImageType(int imageType) {
imageType_ = imageType;
setBodyParameter(std::string("ImageType"), std::to_string(imageType));
std::string RecognizeTableRequest::getImageURL()const
{
return imageURL_;
}
std::string RecognizeTableRequest::getImageURL() const {
return imageURL_;
}
void RecognizeTableRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
void RecognizeTableRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}

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

@@ -1,36 +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/RecognizeTakeoutOrderRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeTakeoutOrderRequest;
RecognizeTakeoutOrderRequest::RecognizeTakeoutOrderRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeTakeoutOrder") {
setMethod(HttpRequest::Method::Post);
*/
#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_;
}
RecognizeTakeoutOrderRequest::~RecognizeTakeoutOrderRequest() {}
std::string RecognizeTakeoutOrderRequest::getImageURL() const {
return imageURL_;
}
void RecognizeTakeoutOrderRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
void RecognizeTakeoutOrderRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}

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

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

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

@@ -1,36 +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/RecognizeTicketInvoiceRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeTicketInvoiceRequest;
RecognizeTicketInvoiceRequest::RecognizeTicketInvoiceRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeTicketInvoice") {
setMethod(HttpRequest::Method::Post);
*/
#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_;
}
RecognizeTicketInvoiceRequest::~RecognizeTicketInvoiceRequest() {}
std::string RecognizeTicketInvoiceRequest::getImageURL() const {
return imageURL_;
}
void RecognizeTicketInvoiceRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
void RecognizeTicketInvoiceRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}

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

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

24
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["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["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());
}

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

@@ -1,36 +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/RecognizeTurkeyIdentityCardRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeTurkeyIdentityCardRequest;
RecognizeTurkeyIdentityCardRequest::RecognizeTurkeyIdentityCardRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeTurkeyIdentityCard") {
setMethod(HttpRequest::Method::Post);
*/
#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_;
}
RecognizeTurkeyIdentityCardRequest::~RecognizeTurkeyIdentityCardRequest() {}
std::string RecognizeTurkeyIdentityCardRequest::getImageUrl() const {
return imageUrl_;
}
void RecognizeTurkeyIdentityCardRequest::setImageUrl(const std::string &imageUrl) {
imageUrl_ = imageUrl;
setBodyParameter(std::string("ImageUrl"), imageUrl);
void RecognizeTurkeyIdentityCardRequest::setImageUrl(const std::string& imageUrl)
{
imageUrl_ = imageUrl;
setBodyParameter("ImageUrl", imageUrl);
}

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

@@ -1,36 +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/RecognizeUkraineIdentityCardRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeUkraineIdentityCardRequest;
RecognizeUkraineIdentityCardRequest::RecognizeUkraineIdentityCardRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeUkraineIdentityCard") {
setMethod(HttpRequest::Method::Post);
*/
#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_;
}
RecognizeUkraineIdentityCardRequest::~RecognizeUkraineIdentityCardRequest() {}
std::string RecognizeUkraineIdentityCardRequest::getImageUrl() const {
return imageUrl_;
}
void RecognizeUkraineIdentityCardRequest::setImageUrl(const std::string &imageUrl) {
imageUrl_ = imageUrl;
setBodyParameter(std::string("ImageUrl"), imageUrl);
void RecognizeUkraineIdentityCardRequest::setImageUrl(const std::string& imageUrl)
{
imageUrl_ = imageUrl;
setBodyParameter("ImageUrl", imageUrl);
}

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

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

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

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

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

@@ -1,36 +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/RecognizeVerificationcodeRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeVerificationcodeRequest;
RecognizeVerificationcodeRequest::RecognizeVerificationcodeRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeVerificationcode") {
setMethod(HttpRequest::Method::Post);
*/
#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_;
}
RecognizeVerificationcodeRequest::~RecognizeVerificationcodeRequest() {}
std::string RecognizeVerificationcodeRequest::getImageURL() const {
return imageURL_;
}
void RecognizeVerificationcodeRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
void RecognizeVerificationcodeRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
}

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

@@ -1,65 +1,73 @@
/*
* 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);
*/
#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_;
}
RecognizeVideoCastCrewListRequest::~RecognizeVideoCastCrewListRequest() {}
std::vector<RecognizeVideoCastCrewListRequest::Params> RecognizeVideoCastCrewListRequest::getParams() const {
return params_;
void RecognizeVideoCastCrewListRequest::setParams(const Array& params)
{
params_ = params;
setBodyParameter("Params", std::to_string(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_;
}
bool RecognizeVideoCastCrewListRequest::getAsync() const {
return async_;
void RecognizeVideoCastCrewListRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
}
void RecognizeVideoCastCrewListRequest::setAsync(bool async) {
async_ = async;
setBodyParameter(std::string("Async"), async ? "true" : "false");
std::string RecognizeVideoCastCrewListRequest::getRegisterUrl()const
{
return registerUrl_;
}
std::string RecognizeVideoCastCrewListRequest::getRegisterUrl() const {
return registerUrl_;
void RecognizeVideoCastCrewListRequest::setRegisterUrl(const std::string& registerUrl)
{
registerUrl_ = registerUrl;
setBodyParameter("RegisterUrl", registerUrl);
}
void RecognizeVideoCastCrewListRequest::setRegisterUrl(const std::string &registerUrl) {
registerUrl_ = registerUrl;
setBodyParameter(std::string("RegisterUrl"), registerUrl);
std::string RecognizeVideoCastCrewListRequest::getVideoUrl()const
{
return videoUrl_;
}
std::string RecognizeVideoCastCrewListRequest::getVideoUrl() const {
return videoUrl_;
}
void RecognizeVideoCastCrewListRequest::setVideoUrl(const std::string &videoUrl) {
videoUrl_ = videoUrl;
setBodyParameter(std::string("VideoUrl"), videoUrl);
void RecognizeVideoCastCrewListRequest::setVideoUrl(const std::string& videoUrl)
{
videoUrl_ = videoUrl;
setBodyParameter("VideoUrl", videoUrl);
}

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

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

14
ocr/src/model/RecognizeVideoCharacterResult.cc
View File

@@ -80,11 +80,25 @@ void RecognizeVideoCharacterResult::parse(const std::string &payload)
}
data_.frames.push_back(frameObject);
}
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["Message"].isNull())
message_ = value["Message"].asString();
}
std::string RecognizeVideoCharacterResult::getMessage()const
{
return message_;
}
RecognizeVideoCharacterResult::Data RecognizeVideoCharacterResult::getData()const
{
return data_;
}
std::string RecognizeVideoCharacterResult::getCode()const
{
return code_;
}

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

@@ -1,36 +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/RecognizeVietnamIdentityCardRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeVietnamIdentityCardRequest;
RecognizeVietnamIdentityCardRequest::RecognizeVietnamIdentityCardRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeVietnamIdentityCard") {
setMethod(HttpRequest::Method::Post);
*/
#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_;
}
RecognizeVietnamIdentityCardRequest::~RecognizeVietnamIdentityCardRequest() {}
std::string RecognizeVietnamIdentityCardRequest::getImageUrl() const {
return imageUrl_;
}
void RecognizeVietnamIdentityCardRequest::setImageUrl(const std::string &imageUrl) {
imageUrl_ = imageUrl;
setBodyParameter(std::string("ImageUrl"), imageUrl);
void RecognizeVietnamIdentityCardRequest::setImageUrl(const std::string& imageUrl)
{
imageUrl_ = imageUrl;
setBodyParameter("ImageUrl", imageUrl);
}

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

@@ -1,63 +1,73 @@
/*
* 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);
*/
#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_;
}
TrimDocumentRequest::~TrimDocumentRequest() {}
std::string TrimDocumentRequest::getFileType() const {
return fileType_;
void TrimDocumentRequest::setFileType(const std::string& fileType)
{
fileType_ = fileType;
setBodyParameter("FileType", fileType);
}
void TrimDocumentRequest::setFileType(const std::string &fileType) {
fileType_ = fileType;
setBodyParameter(std::string("FileType"), fileType);
std::string TrimDocumentRequest::getOutputType()const
{
return outputType_;
}
std::string TrimDocumentRequest::getOutputType() const {
return outputType_;
void TrimDocumentRequest::setOutputType(const std::string& outputType)
{
outputType_ = outputType;
setBodyParameter("OutputType", outputType);
}
void TrimDocumentRequest::setOutputType(const std::string &outputType) {
outputType_ = outputType;
setBodyParameter(std::string("OutputType"), outputType);
bool TrimDocumentRequest::getAsync()const
{
return async_;
}
bool TrimDocumentRequest::getAsync() const {
return async_;
void TrimDocumentRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
}
void TrimDocumentRequest::setAsync(bool async) {
async_ = async;
setBodyParameter(std::string("Async"), async ? "true" : "false");
std::string TrimDocumentRequest::getFileURL()const
{
return fileURL_;
}
std::string TrimDocumentRequest::getFileURL() const {
return fileURL_;
}
void TrimDocumentRequest::setFileURL(const std::string &fileURL) {
fileURL_ = fileURL;
setBodyParameter(std::string("FileURL"), fileURL);
void TrimDocumentRequest::setFileURL(const std::string& fileURL)
{
fileURL_ = fileURL;
setBodyParameter("FileURL", fileURL);
}

14
ocr/src/model/TrimDocumentResult.cc
View File

@@ -42,11 +42,25 @@ void TrimDocumentResult::parse(const std::string &payload)
auto dataNode = value["Data"];
if(!dataNode["Content"].isNull())
data_.content = dataNode["Content"].asString();
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["Message"].isNull())
message_ = value["Message"].asString();
}
std::string TrimDocumentResult::getMessage()const
{
return message_;
}
TrimDocumentResult::Data TrimDocumentResult::getData()const
{
return data_;
}
std::string TrimDocumentResult::getCode()const
{
return code_;
}