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

Support for addrp.

Browse Source
This commit is contained in:
sdk-team
2020-06-04 21:10:51 +08:00
parent 99feb0fdea
commit e3faa7d285
58 changed files with 2719 additions and 850 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGELOG
View File

@@ -1,3 +1,6 @@
2020-06-04 Version: 1.36.451
- Support for addrp.
2020-06-04 Version: 1.36.450
- Supported Eni Trunking.

2
VERSION
View File

@@ -1 +1 @@
1.36.450
1.36.451

64
address-purification/CMakeLists.txt
View File

@@ -21,29 +21,53 @@ set(address-purification_public_header
include/alibabacloud/address-purification/Address_purificationExport.h )
set(address-purification_public_header_model
include/alibabacloud/address-purification/model/DescribeProductRequest.h
include/alibabacloud/address-purification/model/DescribeProductResult.h
include/alibabacloud/address-purification/model/GetAlgorithmResultRequest.h
include/alibabacloud/address-purification/model/GetAlgorithmResultResult.h
include/alibabacloud/address-purification/model/GetConsoleResultRequest.h
include/alibabacloud/address-purification/model/GetConsoleResultResult.h
include/alibabacloud/address-purification/model/GetReportRequest.h
include/alibabacloud/address-purification/model/GetReportResult.h
include/alibabacloud/address-purification/model/GetUserInfomationRequest.h
include/alibabacloud/address-purification/model/GetUserInfomationResult.h )
include/alibabacloud/address-purification/model/ClassifyPOIRequest.h
include/alibabacloud/address-purification/model/ClassifyPOIResult.h
include/alibabacloud/address-purification/model/CompleteAddressRequest.h
include/alibabacloud/address-purification/model/CompleteAddressResult.h
include/alibabacloud/address-purification/model/CorrectAddressRequest.h
include/alibabacloud/address-purification/model/CorrectAddressResult.h
include/alibabacloud/address-purification/model/ExtractAddressRequest.h
include/alibabacloud/address-purification/model/ExtractAddressResult.h
include/alibabacloud/address-purification/model/ExtractNameRequest.h
include/alibabacloud/address-purification/model/ExtractNameResult.h
include/alibabacloud/address-purification/model/ExtractPhoneRequest.h
include/alibabacloud/address-purification/model/ExtractPhoneResult.h
include/alibabacloud/address-purification/model/GetAddressDivisionCodeRequest.h
include/alibabacloud/address-purification/model/GetAddressDivisionCodeResult.h
include/alibabacloud/address-purification/model/GetAddressSimilarityRequest.h
include/alibabacloud/address-purification/model/GetAddressSimilarityResult.h
include/alibabacloud/address-purification/model/GetZipcodeRequest.h
include/alibabacloud/address-purification/model/GetZipcodeResult.h
include/alibabacloud/address-purification/model/StructureAddressRequest.h
include/alibabacloud/address-purification/model/StructureAddressResult.h
include/alibabacloud/address-purification/model/UpdateProjectRequest.h
include/alibabacloud/address-purification/model/UpdateProjectResult.h )
set(address-purification_src
src/Address-purificationClient.cc
src/model/DescribeProductRequest.cc
src/model/DescribeProductResult.cc
src/model/GetAlgorithmResultRequest.cc
src/model/GetAlgorithmResultResult.cc
src/model/GetConsoleResultRequest.cc
src/model/GetConsoleResultResult.cc
src/model/GetReportRequest.cc
src/model/GetReportResult.cc
src/model/GetUserInfomationRequest.cc
src/model/GetUserInfomationResult.cc )
src/model/ClassifyPOIRequest.cc
src/model/ClassifyPOIResult.cc
src/model/CompleteAddressRequest.cc
src/model/CompleteAddressResult.cc
src/model/CorrectAddressRequest.cc
src/model/CorrectAddressResult.cc
src/model/ExtractAddressRequest.cc
src/model/ExtractAddressResult.cc
src/model/ExtractNameRequest.cc
src/model/ExtractNameResult.cc
src/model/ExtractPhoneRequest.cc
src/model/ExtractPhoneResult.cc
src/model/GetAddressDivisionCodeRequest.cc
src/model/GetAddressDivisionCodeResult.cc
src/model/GetAddressSimilarityRequest.cc
src/model/GetAddressSimilarityResult.cc
src/model/GetZipcodeRequest.cc
src/model/GetZipcodeResult.cc
src/model/StructureAddressRequest.cc
src/model/StructureAddressResult.cc
src/model/UpdateProjectRequest.cc
src/model/UpdateProjectResult.cc )
add_library(address-purification ${LIB_TYPE}
${address-purification_public_header}

128
address-purification/include/alibabacloud/address-purification/Address_purificationClient.h
View File

@@ -22,16 +22,28 @@
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "Address_purificationExport.h"
#include "model/DescribeProductRequest.h"
#include "model/DescribeProductResult.h"
#include "model/GetAlgorithmResultRequest.h"
#include "model/GetAlgorithmResultResult.h"
#include "model/GetConsoleResultRequest.h"
#include "model/GetConsoleResultResult.h"
#include "model/GetReportRequest.h"
#include "model/GetReportResult.h"
#include "model/GetUserInfomationRequest.h"
#include "model/GetUserInfomationResult.h"
#include "model/ClassifyPOIRequest.h"
#include "model/ClassifyPOIResult.h"
#include "model/CompleteAddressRequest.h"
#include "model/CompleteAddressResult.h"
#include "model/CorrectAddressRequest.h"
#include "model/CorrectAddressResult.h"
#include "model/ExtractAddressRequest.h"
#include "model/ExtractAddressResult.h"
#include "model/ExtractNameRequest.h"
#include "model/ExtractNameResult.h"
#include "model/ExtractPhoneRequest.h"
#include "model/ExtractPhoneResult.h"
#include "model/GetAddressDivisionCodeRequest.h"
#include "model/GetAddressDivisionCodeResult.h"
#include "model/GetAddressSimilarityRequest.h"
#include "model/GetAddressSimilarityResult.h"
#include "model/GetZipcodeRequest.h"
#include "model/GetZipcodeResult.h"
#include "model/StructureAddressRequest.h"
#include "model/StructureAddressResult.h"
#include "model/UpdateProjectRequest.h"
#include "model/UpdateProjectResult.h"
namespace AlibabaCloud
@@ -41,41 +53,77 @@ namespace AlibabaCloud
class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT Address_purificationClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::DescribeProductResult> DescribeProductOutcome;
typedef std::future<DescribeProductOutcome> DescribeProductOutcomeCallable;
typedef std::function<void(const Address_purificationClient*, const Model::DescribeProductRequest&, const DescribeProductOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeProductAsyncHandler;
typedef Outcome<Error, Model::GetAlgorithmResultResult> GetAlgorithmResultOutcome;
typedef std::future<GetAlgorithmResultOutcome> GetAlgorithmResultOutcomeCallable;
typedef std::function<void(const Address_purificationClient*, const Model::GetAlgorithmResultRequest&, const GetAlgorithmResultOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAlgorithmResultAsyncHandler;
typedef Outcome<Error, Model::GetConsoleResultResult> GetConsoleResultOutcome;
typedef std::future<GetConsoleResultOutcome> GetConsoleResultOutcomeCallable;
typedef std::function<void(const Address_purificationClient*, const Model::GetConsoleResultRequest&, const GetConsoleResultOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetConsoleResultAsyncHandler;
typedef Outcome<Error, Model::GetReportResult> GetReportOutcome;
typedef std::future<GetReportOutcome> GetReportOutcomeCallable;
typedef std::function<void(const Address_purificationClient*, const Model::GetReportRequest&, const GetReportOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetReportAsyncHandler;
typedef Outcome<Error, Model::GetUserInfomationResult> GetUserInfomationOutcome;
typedef std::future<GetUserInfomationOutcome> GetUserInfomationOutcomeCallable;
typedef std::function<void(const Address_purificationClient*, const Model::GetUserInfomationRequest&, const GetUserInfomationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetUserInfomationAsyncHandler;
typedef Outcome<Error, Model::ClassifyPOIResult> ClassifyPOIOutcome;
typedef std::future<ClassifyPOIOutcome> ClassifyPOIOutcomeCallable;
typedef std::function<void(const Address_purificationClient*, const Model::ClassifyPOIRequest&, const ClassifyPOIOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ClassifyPOIAsyncHandler;
typedef Outcome<Error, Model::CompleteAddressResult> CompleteAddressOutcome;
typedef std::future<CompleteAddressOutcome> CompleteAddressOutcomeCallable;
typedef std::function<void(const Address_purificationClient*, const Model::CompleteAddressRequest&, const CompleteAddressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CompleteAddressAsyncHandler;
typedef Outcome<Error, Model::CorrectAddressResult> CorrectAddressOutcome;
typedef std::future<CorrectAddressOutcome> CorrectAddressOutcomeCallable;
typedef std::function<void(const Address_purificationClient*, const Model::CorrectAddressRequest&, const CorrectAddressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CorrectAddressAsyncHandler;
typedef Outcome<Error, Model::ExtractAddressResult> ExtractAddressOutcome;
typedef std::future<ExtractAddressOutcome> ExtractAddressOutcomeCallable;
typedef std::function<void(const Address_purificationClient*, const Model::ExtractAddressRequest&, const ExtractAddressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExtractAddressAsyncHandler;
typedef Outcome<Error, Model::ExtractNameResult> ExtractNameOutcome;
typedef std::future<ExtractNameOutcome> ExtractNameOutcomeCallable;
typedef std::function<void(const Address_purificationClient*, const Model::ExtractNameRequest&, const ExtractNameOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExtractNameAsyncHandler;
typedef Outcome<Error, Model::ExtractPhoneResult> ExtractPhoneOutcome;
typedef std::future<ExtractPhoneOutcome> ExtractPhoneOutcomeCallable;
typedef std::function<void(const Address_purificationClient*, const Model::ExtractPhoneRequest&, const ExtractPhoneOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExtractPhoneAsyncHandler;
typedef Outcome<Error, Model::GetAddressDivisionCodeResult> GetAddressDivisionCodeOutcome;
typedef std::future<GetAddressDivisionCodeOutcome> GetAddressDivisionCodeOutcomeCallable;
typedef std::function<void(const Address_purificationClient*, const Model::GetAddressDivisionCodeRequest&, const GetAddressDivisionCodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAddressDivisionCodeAsyncHandler;
typedef Outcome<Error, Model::GetAddressSimilarityResult> GetAddressSimilarityOutcome;
typedef std::future<GetAddressSimilarityOutcome> GetAddressSimilarityOutcomeCallable;
typedef std::function<void(const Address_purificationClient*, const Model::GetAddressSimilarityRequest&, const GetAddressSimilarityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAddressSimilarityAsyncHandler;
typedef Outcome<Error, Model::GetZipcodeResult> GetZipcodeOutcome;
typedef std::future<GetZipcodeOutcome> GetZipcodeOutcomeCallable;
typedef std::function<void(const Address_purificationClient*, const Model::GetZipcodeRequest&, const GetZipcodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetZipcodeAsyncHandler;
typedef Outcome<Error, Model::StructureAddressResult> StructureAddressOutcome;
typedef std::future<StructureAddressOutcome> StructureAddressOutcomeCallable;
typedef std::function<void(const Address_purificationClient*, const Model::StructureAddressRequest&, const StructureAddressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StructureAddressAsyncHandler;
typedef Outcome<Error, Model::UpdateProjectResult> UpdateProjectOutcome;
typedef std::future<UpdateProjectOutcome> UpdateProjectOutcomeCallable;
typedef std::function<void(const Address_purificationClient*, const Model::UpdateProjectRequest&, const UpdateProjectOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateProjectAsyncHandler;
Address_purificationClient(const Credentials &credentials, const ClientConfiguration &configuration);
Address_purificationClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
Address_purificationClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~Address_purificationClient();
DescribeProductOutcome describeProduct(const Model::DescribeProductRequest &request)const;
void describeProductAsync(const Model::DescribeProductRequest& request, const DescribeProductAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeProductOutcomeCallable describeProductCallable(const Model::DescribeProductRequest& request) const;
GetAlgorithmResultOutcome getAlgorithmResult(const Model::GetAlgorithmResultRequest &request)const;
void getAlgorithmResultAsync(const Model::GetAlgorithmResultRequest& request, const GetAlgorithmResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetAlgorithmResultOutcomeCallable getAlgorithmResultCallable(const Model::GetAlgorithmResultRequest& request) const;
GetConsoleResultOutcome getConsoleResult(const Model::GetConsoleResultRequest &request)const;
void getConsoleResultAsync(const Model::GetConsoleResultRequest& request, const GetConsoleResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetConsoleResultOutcomeCallable getConsoleResultCallable(const Model::GetConsoleResultRequest& request) const;
GetReportOutcome getReport(const Model::GetReportRequest &request)const;
void getReportAsync(const Model::GetReportRequest& request, const GetReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetReportOutcomeCallable getReportCallable(const Model::GetReportRequest& request) const;
GetUserInfomationOutcome getUserInfomation(const Model::GetUserInfomationRequest &request)const;
void getUserInfomationAsync(const Model::GetUserInfomationRequest& request, const GetUserInfomationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetUserInfomationOutcomeCallable getUserInfomationCallable(const Model::GetUserInfomationRequest& request) const;
ClassifyPOIOutcome classifyPOI(const Model::ClassifyPOIRequest &request)const;
void classifyPOIAsync(const Model::ClassifyPOIRequest& request, const ClassifyPOIAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ClassifyPOIOutcomeCallable classifyPOICallable(const Model::ClassifyPOIRequest& request) const;
CompleteAddressOutcome completeAddress(const Model::CompleteAddressRequest &request)const;
void completeAddressAsync(const Model::CompleteAddressRequest& request, const CompleteAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CompleteAddressOutcomeCallable completeAddressCallable(const Model::CompleteAddressRequest& request) const;
CorrectAddressOutcome correctAddress(const Model::CorrectAddressRequest &request)const;
void correctAddressAsync(const Model::CorrectAddressRequest& request, const CorrectAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CorrectAddressOutcomeCallable correctAddressCallable(const Model::CorrectAddressRequest& request) const;
ExtractAddressOutcome extractAddress(const Model::ExtractAddressRequest &request)const;
void extractAddressAsync(const Model::ExtractAddressRequest& request, const ExtractAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ExtractAddressOutcomeCallable extractAddressCallable(const Model::ExtractAddressRequest& request) const;
ExtractNameOutcome extractName(const Model::ExtractNameRequest &request)const;
void extractNameAsync(const Model::ExtractNameRequest& request, const ExtractNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ExtractNameOutcomeCallable extractNameCallable(const Model::ExtractNameRequest& request) const;
ExtractPhoneOutcome extractPhone(const Model::ExtractPhoneRequest &request)const;
void extractPhoneAsync(const Model::ExtractPhoneRequest& request, const ExtractPhoneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ExtractPhoneOutcomeCallable extractPhoneCallable(const Model::ExtractPhoneRequest& request) const;
GetAddressDivisionCodeOutcome getAddressDivisionCode(const Model::GetAddressDivisionCodeRequest &request)const;
void getAddressDivisionCodeAsync(const Model::GetAddressDivisionCodeRequest& request, const GetAddressDivisionCodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetAddressDivisionCodeOutcomeCallable getAddressDivisionCodeCallable(const Model::GetAddressDivisionCodeRequest& request) const;
GetAddressSimilarityOutcome getAddressSimilarity(const Model::GetAddressSimilarityRequest &request)const;
void getAddressSimilarityAsync(const Model::GetAddressSimilarityRequest& request, const GetAddressSimilarityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetAddressSimilarityOutcomeCallable getAddressSimilarityCallable(const Model::GetAddressSimilarityRequest& request) const;
GetZipcodeOutcome getZipcode(const Model::GetZipcodeRequest &request)const;
void getZipcodeAsync(const Model::GetZipcodeRequest& request, const GetZipcodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetZipcodeOutcomeCallable getZipcodeCallable(const Model::GetZipcodeRequest& request) const;
StructureAddressOutcome structureAddress(const Model::StructureAddressRequest &request)const;
void structureAddressAsync(const Model::StructureAddressRequest& request, const StructureAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StructureAddressOutcomeCallable structureAddressCallable(const Model::StructureAddressRequest& request) const;
UpdateProjectOutcome updateProject(const Model::UpdateProjectRequest &request)const;
void updateProjectAsync(const Model::UpdateProjectRequest& request, const UpdateProjectAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateProjectOutcomeCallable updateProjectCallable(const Model::UpdateProjectRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;

63
address-purification/include/alibabacloud/address-purification/model/ClassifyPOIRequest.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_CLASSIFYPOIREQUEST_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_CLASSIFYPOIREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/address-purification/Address_purificationExport.h>
namespace AlibabaCloud
{
namespace Address_purification
{
namespace Model
{
class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT ClassifyPOIRequest : public RpcServiceRequest
{
public:
ClassifyPOIRequest();
~ClassifyPOIRequest();
std::string getDefaultProvince()const;
void setDefaultProvince(const std::string& defaultProvince);
std::string getServiceCode()const;
void setServiceCode(const std::string& serviceCode);
std::string getDefaultCity()const;
void setDefaultCity(const std::string& defaultCity);
std::string getDefaultDistrict()const;
void setDefaultDistrict(const std::string& defaultDistrict);
std::string getAppKey()const;
void setAppKey(const std::string& appKey);
std::string getText()const;
void setText(const std::string& text);
private:
std::string defaultProvince_;
std::string serviceCode_;
std::string defaultCity_;
std::string defaultDistrict_;
std::string appKey_;
std::string text_;
};
}
}
}
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_CLASSIFYPOIREQUEST_H_

18
address-purification/include/alibabacloud/address-purification/model/GetReportResult.h → address-purification/include/alibabacloud/address-purification/model/ClassifyPOIResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETREPORTRESULT_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETREPORTRESULT_H_
#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_CLASSIFYPOIRESULT_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_CLASSIFYPOIRESULT_H_
#include <string>
#include <vector>
@@ -29,27 +29,23 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetReportResult : public ServiceResult
class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT ClassifyPOIResult : public ServiceResult
{
public:
GetReportResult();
explicit GetReportResult(const std::string &payload);
~GetReportResult();
ClassifyPOIResult();
explicit ClassifyPOIResult(const std::string &payload);
~ClassifyPOIResult();
std::string getData()const;
std::string getErrMessage()const;
std::string getErrCode()const;
protected:
void parse(const std::string &payload);
private:
std::string data_;
std::string errMessage_;
std::string errCode_;
};
}
}
}
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETREPORTRESULT_H_
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_CLASSIFYPOIRESULT_H_

63
address-purification/include/alibabacloud/address-purification/model/CompleteAddressRequest.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_COMPLETEADDRESSREQUEST_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_COMPLETEADDRESSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/address-purification/Address_purificationExport.h>
namespace AlibabaCloud
{
namespace Address_purification
{
namespace Model
{
class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT CompleteAddressRequest : public RpcServiceRequest
{
public:
CompleteAddressRequest();
~CompleteAddressRequest();
std::string getDefaultProvince()const;
void setDefaultProvince(const std::string& defaultProvince);
std::string getServiceCode()const;
void setServiceCode(const std::string& serviceCode);
std::string getDefaultCity()const;
void setDefaultCity(const std::string& defaultCity);
std::string getDefaultDistrict()const;
void setDefaultDistrict(const std::string& defaultDistrict);
std::string getAppKey()const;
void setAppKey(const std::string& appKey);
std::string getText()const;
void setText(const std::string& text);
private:
std::string defaultProvince_;
std::string serviceCode_;
std::string defaultCity_;
std::string defaultDistrict_;
std::string appKey_;
std::string text_;
};
}
}
}
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_COMPLETEADDRESSREQUEST_H_

18
address-purification/include/alibabacloud/address-purification/model/GetUserInfomationResult.h → address-purification/include/alibabacloud/address-purification/model/CompleteAddressResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETUSERINFOMATIONRESULT_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETUSERINFOMATIONRESULT_H_
#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_COMPLETEADDRESSRESULT_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_COMPLETEADDRESSRESULT_H_
#include <string>
#include <vector>
@@ -29,27 +29,23 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetUserInfomationResult : public ServiceResult
class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT CompleteAddressResult : public ServiceResult
{
public:
GetUserInfomationResult();
explicit GetUserInfomationResult(const std::string &payload);
~GetUserInfomationResult();
CompleteAddressResult();
explicit CompleteAddressResult(const std::string &payload);
~CompleteAddressResult();
std::string getData()const;
std::string getErrMessage()const;
std::string getErrCode()const;
protected:
void parse(const std::string &payload);
private:
std::string data_;
std::string errMessage_;
std::string errCode_;
};
}
}
}
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETUSERINFOMATIONRESULT_H_
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_COMPLETEADDRESSRESULT_H_

63
address-purification/include/alibabacloud/address-purification/model/CorrectAddressRequest.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_CORRECTADDRESSREQUEST_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_CORRECTADDRESSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/address-purification/Address_purificationExport.h>
namespace AlibabaCloud
{
namespace Address_purification
{
namespace Model
{
class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT CorrectAddressRequest : public RpcServiceRequest
{
public:
CorrectAddressRequest();
~CorrectAddressRequest();
std::string getDefaultProvince()const;
void setDefaultProvince(const std::string& defaultProvince);
std::string getServiceCode()const;
void setServiceCode(const std::string& serviceCode);
std::string getDefaultCity()const;
void setDefaultCity(const std::string& defaultCity);
std::string getDefaultDistrict()const;
void setDefaultDistrict(const std::string& defaultDistrict);
std::string getAppKey()const;
void setAppKey(const std::string& appKey);
std::string getText()const;
void setText(const std::string& text);
private:
std::string defaultProvince_;
std::string serviceCode_;
std::string defaultCity_;
std::string defaultDistrict_;
std::string appKey_;
std::string text_;
};
}
}
}
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_CORRECTADDRESSREQUEST_H_

20
address-purification/include/alibabacloud/address-purification/model/DescribeProductResult.h → address-purification/include/alibabacloud/address-purification/model/CorrectAddressResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_DESCRIBEPRODUCTRESULT_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_DESCRIBEPRODUCTRESULT_H_
#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_CORRECTADDRESSRESULT_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_CORRECTADDRESSRESULT_H_
#include <string>
#include <vector>
@@ -29,29 +29,23 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT DescribeProductResult : public ServiceResult
class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT CorrectAddressResult : public ServiceResult
{
public:
DescribeProductResult();
explicit DescribeProductResult(const std::string &payload);
~DescribeProductResult();
CorrectAddressResult();
explicit CorrectAddressResult(const std::string &payload);
~CorrectAddressResult();
std::string getData()const;
std::string getErrMessage()const;
std::string getCode()const;
std::string getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string data_;
std::string errMessage_;
std::string code_;
std::string success_;
};
}
}
}
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_DESCRIBEPRODUCTRESULT_H_
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_CORRECTADDRESSRESULT_H_

63
address-purification/include/alibabacloud/address-purification/model/ExtractAddressRequest.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTADDRESSREQUEST_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTADDRESSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/address-purification/Address_purificationExport.h>
namespace AlibabaCloud
{
namespace Address_purification
{
namespace Model
{
class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT ExtractAddressRequest : public RpcServiceRequest
{
public:
ExtractAddressRequest();
~ExtractAddressRequest();
std::string getDefaultProvince()const;
void setDefaultProvince(const std::string& defaultProvince);
std::string getServiceCode()const;
void setServiceCode(const std::string& serviceCode);
std::string getDefaultCity()const;
void setDefaultCity(const std::string& defaultCity);
std::string getDefaultDistrict()const;
void setDefaultDistrict(const std::string& defaultDistrict);
std::string getAppKey()const;
void setAppKey(const std::string& appKey);
std::string getText()const;
void setText(const std::string& text);
private:
std::string defaultProvince_;
std::string serviceCode_;
std::string defaultCity_;
std::string defaultDistrict_;
std::string appKey_;
std::string text_;
};
}
}
}
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTADDRESSREQUEST_H_

51
address-purification/include/alibabacloud/address-purification/model/ExtractAddressResult.h Normal file
View File

@@ -0,0 +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_ADDRESS_PURIFICATION_MODEL_EXTRACTADDRESSRESULT_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTADDRESSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/address-purification/Address_purificationExport.h>
namespace AlibabaCloud
{
namespace Address_purification
{
namespace Model
{
class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT ExtractAddressResult : public ServiceResult
{
public:
ExtractAddressResult();
explicit ExtractAddressResult(const std::string &payload);
~ExtractAddressResult();
std::string getData()const;
protected:
void parse(const std::string &payload);
private:
std::string data_;
};
}
}
}
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTADDRESSRESULT_H_

63
address-purification/include/alibabacloud/address-purification/model/ExtractNameRequest.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTNAMEREQUEST_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTNAMEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/address-purification/Address_purificationExport.h>
namespace AlibabaCloud
{
namespace Address_purification
{
namespace Model
{
class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT ExtractNameRequest : public RpcServiceRequest
{
public:
ExtractNameRequest();
~ExtractNameRequest();
std::string getDefaultProvince()const;
void setDefaultProvince(const std::string& defaultProvince);
std::string getServiceCode()const;
void setServiceCode(const std::string& serviceCode);
std::string getDefaultCity()const;
void setDefaultCity(const std::string& defaultCity);
std::string getDefaultDistrict()const;
void setDefaultDistrict(const std::string& defaultDistrict);
std::string getAppKey()const;
void setAppKey(const std::string& appKey);
std::string getText()const;
void setText(const std::string& text);
private:
std::string defaultProvince_;
std::string serviceCode_;
std::string defaultCity_;
std::string defaultDistrict_;
std::string appKey_;
std::string text_;
};
}
}
}
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTNAMEREQUEST_H_

51
address-purification/include/alibabacloud/address-purification/model/ExtractNameResult.h Normal file
View File

@@ -0,0 +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_ADDRESS_PURIFICATION_MODEL_EXTRACTNAMERESULT_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTNAMERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/address-purification/Address_purificationExport.h>
namespace AlibabaCloud
{
namespace Address_purification
{
namespace Model
{
class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT ExtractNameResult : public ServiceResult
{
public:
ExtractNameResult();
explicit ExtractNameResult(const std::string &payload);
~ExtractNameResult();
std::string getData()const;
protected:
void parse(const std::string &payload);
private:
std::string data_;
};
}
}
}
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTNAMERESULT_H_

63
address-purification/include/alibabacloud/address-purification/model/ExtractPhoneRequest.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTPHONEREQUEST_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTPHONEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/address-purification/Address_purificationExport.h>
namespace AlibabaCloud
{
namespace Address_purification
{
namespace Model
{
class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT ExtractPhoneRequest : public RpcServiceRequest
{
public:
ExtractPhoneRequest();
~ExtractPhoneRequest();
std::string getDefaultProvince()const;
void setDefaultProvince(const std::string& defaultProvince);
std::string getServiceCode()const;
void setServiceCode(const std::string& serviceCode);
std::string getDefaultCity()const;
void setDefaultCity(const std::string& defaultCity);
std::string getDefaultDistrict()const;
void setDefaultDistrict(const std::string& defaultDistrict);
std::string getAppKey()const;
void setAppKey(const std::string& appKey);
std::string getText()const;
void setText(const std::string& text);
private:
std::string defaultProvince_;
std::string serviceCode_;
std::string defaultCity_;
std::string defaultDistrict_;
std::string appKey_;
std::string text_;
};
}
}
}
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTPHONEREQUEST_H_

51
address-purification/include/alibabacloud/address-purification/model/ExtractPhoneResult.h Normal file
View File

@@ -0,0 +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_ADDRESS_PURIFICATION_MODEL_EXTRACTPHONERESULT_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTPHONERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/address-purification/Address_purificationExport.h>
namespace AlibabaCloud
{
namespace Address_purification
{
namespace Model
{
class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT ExtractPhoneResult : public ServiceResult
{
public:
ExtractPhoneResult();
explicit ExtractPhoneResult(const std::string &payload);
~ExtractPhoneResult();
std::string getData()const;
protected:
void parse(const std::string &payload);
private:
std::string data_;
};
}
}
}
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTPHONERESULT_H_

63
address-purification/include/alibabacloud/address-purification/model/GetAddressDivisionCodeRequest.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSDIVISIONCODEREQUEST_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSDIVISIONCODEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/address-purification/Address_purificationExport.h>
namespace AlibabaCloud
{
namespace Address_purification
{
namespace Model
{
class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetAddressDivisionCodeRequest : public RpcServiceRequest
{
public:
GetAddressDivisionCodeRequest();
~GetAddressDivisionCodeRequest();
std::string getDefaultProvince()const;
void setDefaultProvince(const std::string& defaultProvince);
std::string getServiceCode()const;
void setServiceCode(const std::string& serviceCode);
std::string getDefaultCity()const;
void setDefaultCity(const std::string& defaultCity);
std::string getDefaultDistrict()const;
void setDefaultDistrict(const std::string& defaultDistrict);
std::string getAppKey()const;
void setAppKey(const std::string& appKey);
std::string getText()const;
void setText(const std::string& text);
private:
std::string defaultProvince_;
std::string serviceCode_;
std::string defaultCity_;
std::string defaultDistrict_;
std::string appKey_;
std::string text_;
};
}
}
}
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSDIVISIONCODEREQUEST_H_

51
address-purification/include/alibabacloud/address-purification/model/GetAddressDivisionCodeResult.h Normal file
View File

@@ -0,0 +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_ADDRESS_PURIFICATION_MODEL_GETADDRESSDIVISIONCODERESULT_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSDIVISIONCODERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/address-purification/Address_purificationExport.h>
namespace AlibabaCloud
{
namespace Address_purification
{
namespace Model
{
class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetAddressDivisionCodeResult : public ServiceResult
{
public:
GetAddressDivisionCodeResult();
explicit GetAddressDivisionCodeResult(const std::string &payload);
~GetAddressDivisionCodeResult();
std::string getData()const;
protected:
void parse(const std::string &payload);
private:
std::string data_;
};
}
}
}
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSDIVISIONCODERESULT_H_

63
address-purification/include/alibabacloud/address-purification/model/GetAddressSimilarityRequest.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSSIMILARITYREQUEST_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSSIMILARITYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/address-purification/Address_purificationExport.h>
namespace AlibabaCloud
{
namespace Address_purification
{
namespace Model
{
class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetAddressSimilarityRequest : public RpcServiceRequest
{
public:
GetAddressSimilarityRequest();
~GetAddressSimilarityRequest();
std::string getDefaultProvince()const;
void setDefaultProvince(const std::string& defaultProvince);
std::string getServiceCode()const;
void setServiceCode(const std::string& serviceCode);
std::string getDefaultCity()const;
void setDefaultCity(const std::string& defaultCity);
std::string getDefaultDistrict()const;
void setDefaultDistrict(const std::string& defaultDistrict);
std::string getAppKey()const;
void setAppKey(const std::string& appKey);
std::string getText()const;
void setText(const std::string& text);
private:
std::string defaultProvince_;
std::string serviceCode_;
std::string defaultCity_;
std::string defaultDistrict_;
std::string appKey_;
std::string text_;
};
}
}
}
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSSIMILARITYREQUEST_H_

51
address-purification/include/alibabacloud/address-purification/model/GetAddressSimilarityResult.h Normal file
View File

@@ -0,0 +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_ADDRESS_PURIFICATION_MODEL_GETADDRESSSIMILARITYRESULT_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSSIMILARITYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/address-purification/Address_purificationExport.h>
namespace AlibabaCloud
{
namespace Address_purification
{
namespace Model
{
class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetAddressSimilarityResult : public ServiceResult
{
public:
GetAddressSimilarityResult();
explicit GetAddressSimilarityResult(const std::string &payload);
~GetAddressSimilarityResult();
std::string getData()const;
protected:
void parse(const std::string &payload);
private:
std::string data_;
};
}
}
}
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSSIMILARITYRESULT_H_

57
address-purification/include/alibabacloud/address-purification/model/GetAlgorithmResultResult.h
View File

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

57
address-purification/include/alibabacloud/address-purification/model/GetConsoleResultRequest.h
View File

@@ -1,57 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETCONSOLERESULTREQUEST_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETCONSOLERESULTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/address-purification/Address_purificationExport.h>
namespace AlibabaCloud
{
namespace Address_purification
{
namespace Model
{
class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetConsoleResultRequest : public RpcServiceRequest
{
public:
GetConsoleResultRequest();
~GetConsoleResultRequest();
std::string getProductCode()const;
void setProductCode(const std::string& productCode);
std::string getApiCode()const;
void setApiCode(const std::string& apiCode);
std::string getCommodityCode()const;
void setCommodityCode(const std::string& commodityCode);
std::string getParameters()const;
void setParameters(const std::string& parameters);
private:
std::string productCode_;
std::string apiCode_;
std::string commodityCode_;
std::string parameters_;
};
}
}
}
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETCONSOLERESULTREQUEST_H_

63
address-purification/include/alibabacloud/address-purification/model/GetReportRequest.h
View File

@@ -1,63 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETREPORTREQUEST_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETREPORTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/address-purification/Address_purificationExport.h>
namespace AlibabaCloud
{
namespace Address_purification
{
namespace Model
{
class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetReportRequest : public RpcServiceRequest
{
public:
GetReportRequest();
~GetReportRequest();
std::string getProductCode()const;
void setProductCode(const std::string& productCode);
std::string getReportType()const;
void setReportType(const std::string& reportType);
std::string getApiCode()const;
void setApiCode(const std::string& apiCode);
std::string getGranularity()const;
void setGranularity(const std::string& granularity);
std::string getCommodityCode()const;
void setCommodityCode(const std::string& commodityCode);
std::string getParameters()const;
void setParameters(const std::string& parameters);
private:
std::string productCode_;
std::string reportType_;
std::string apiCode_;
std::string granularity_;
std::string commodityCode_;
std::string parameters_;
};
}
}
}
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETREPORTREQUEST_H_

51
address-purification/include/alibabacloud/address-purification/model/GetUserInfomationRequest.h
View File

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

33
address-purification/include/alibabacloud/address-purification/model/GetAlgorithmResultRequest.h → address-purification/include/alibabacloud/address-purification/model/GetZipcodeRequest.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETALGORITHMRESULTREQUEST_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETALGORITHMRESULTREQUEST_H_
#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETZIPCODEREQUEST_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETZIPCODEREQUEST_H_
#include <string>
#include <vector>
@@ -28,27 +28,36 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetAlgorithmResultRequest : public RpcServiceRequest
class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetZipcodeRequest : public RpcServiceRequest
{
public:
GetAlgorithmResultRequest();
~GetAlgorithmResultRequest();
GetZipcodeRequest();
~GetZipcodeRequest();
std::string getDefaultProvince()const;
void setDefaultProvince(const std::string& defaultProvince);
std::string getServiceCode()const;
void setServiceCode(const std::string& serviceCode);
std::string getApiCode()const;
void setApiCode(const std::string& apiCode);
std::string getParameters()const;
void setParameters(const std::string& parameters);
std::string getDefaultCity()const;
void setDefaultCity(const std::string& defaultCity);
std::string getDefaultDistrict()const;
void setDefaultDistrict(const std::string& defaultDistrict);
std::string getAppKey()const;
void setAppKey(const std::string& appKey);
std::string getText()const;
void setText(const std::string& text);
private:
std::string defaultProvince_;
std::string serviceCode_;
std::string apiCode_;
std::string parameters_;
std::string defaultCity_;
std::string defaultDistrict_;
std::string appKey_;
std::string text_;
};
}
}
}
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETALGORITHMRESULTREQUEST_H_
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETZIPCODEREQUEST_H_

51
address-purification/include/alibabacloud/address-purification/model/GetZipcodeResult.h Normal file
View File

@@ -0,0 +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_ADDRESS_PURIFICATION_MODEL_GETZIPCODERESULT_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETZIPCODERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/address-purification/Address_purificationExport.h>
namespace AlibabaCloud
{
namespace Address_purification
{
namespace Model
{
class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetZipcodeResult : public ServiceResult
{
public:
GetZipcodeResult();
explicit GetZipcodeResult(const std::string &payload);
~GetZipcodeResult();
std::string getData()const;
protected:
void parse(const std::string &payload);
private:
std::string data_;
};
}
}
}
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETZIPCODERESULT_H_

63
address-purification/include/alibabacloud/address-purification/model/StructureAddressRequest.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_STRUCTUREADDRESSREQUEST_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_STRUCTUREADDRESSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/address-purification/Address_purificationExport.h>
namespace AlibabaCloud
{
namespace Address_purification
{
namespace Model
{
class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT StructureAddressRequest : public RpcServiceRequest
{
public:
StructureAddressRequest();
~StructureAddressRequest();
std::string getDefaultProvince()const;
void setDefaultProvince(const std::string& defaultProvince);
std::string getServiceCode()const;
void setServiceCode(const std::string& serviceCode);
std::string getDefaultCity()const;
void setDefaultCity(const std::string& defaultCity);
std::string getDefaultDistrict()const;
void setDefaultDistrict(const std::string& defaultDistrict);
std::string getAppKey()const;
void setAppKey(const std::string& appKey);
std::string getText()const;
void setText(const std::string& text);
private:
std::string defaultProvince_;
std::string serviceCode_;
std::string defaultCity_;
std::string defaultDistrict_;
std::string appKey_;
std::string text_;
};
}
}
}
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_STRUCTUREADDRESSREQUEST_H_

18
address-purification/include/alibabacloud/address-purification/model/GetConsoleResultResult.h → address-purification/include/alibabacloud/address-purification/model/StructureAddressResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETCONSOLERESULTRESULT_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETCONSOLERESULTRESULT_H_
#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_STRUCTUREADDRESSRESULT_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_STRUCTUREADDRESSRESULT_H_
#include <string>
#include <vector>
@@ -29,27 +29,23 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetConsoleResultResult : public ServiceResult
class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT StructureAddressResult : public ServiceResult
{
public:
GetConsoleResultResult();
explicit GetConsoleResultResult(const std::string &payload);
~GetConsoleResultResult();
StructureAddressResult();
explicit StructureAddressResult(const std::string &payload);
~StructureAddressResult();
std::string getData()const;
std::string getErrMessage()const;
std::string getErrCode()const;
protected:
void parse(const std::string &payload);
private:
std::string data_;
std::string errMessage_;
std::string errCode_;
};
}
}
}
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETCONSOLERESULTRESULT_H_
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_STRUCTUREADDRESSRESULT_H_

12
address-purification/include/alibabacloud/address-purification/model/DescribeProductRequest.h → address-purification/include/alibabacloud/address-purification/model/UpdateProjectRequest.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_DESCRIBEPRODUCTREQUEST_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_DESCRIBEPRODUCTREQUEST_H_
#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_UPDATEPROJECTREQUEST_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_UPDATEPROJECTREQUEST_H_
#include <string>
#include <vector>
@@ -28,12 +28,12 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT DescribeProductRequest : public RpcServiceRequest
class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT UpdateProjectRequest : public RpcServiceRequest
{
public:
DescribeProductRequest();
~DescribeProductRequest();
UpdateProjectRequest();
~UpdateProjectRequest();
std::string getServiceCode()const;
void setServiceCode(const std::string& serviceCode);
@@ -48,4 +48,4 @@ namespace AlibabaCloud
}
}
}
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_DESCRIBEPRODUCTREQUEST_H_
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_UPDATEPROJECTREQUEST_H_

51
address-purification/include/alibabacloud/address-purification/model/UpdateProjectResult.h Normal file
View File

@@ -0,0 +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_ADDRESS_PURIFICATION_MODEL_UPDATEPROJECTRESULT_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_UPDATEPROJECTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/address-purification/Address_purificationExport.h>
namespace AlibabaCloud
{
namespace Address_purification
{
namespace Model
{
class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT UpdateProjectResult : public ServiceResult
{
public:
UpdateProjectResult();
explicit UpdateProjectResult(const std::string &payload);
~UpdateProjectResult();
std::string getData()const;
protected:
void parse(const std::string &payload);
private:
std::string data_;
};
}
}
}
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_UPDATEPROJECTRESULT_H_

312
address-purification/src/Address-purificationClient.cc
View File

@@ -31,200 +31,416 @@ Address_purificationClient::Address_purificationClient(const Credentials &creden
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "addrp");
}
Address_purificationClient::Address_purificationClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "addrp");
}
Address_purificationClient::Address_purificationClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
{
auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "addrp");
}
Address_purificationClient::~Address_purificationClient()
{}
Address_purificationClient::DescribeProductOutcome Address_purificationClient::describeProduct(const DescribeProductRequest &request) const
Address_purificationClient::ClassifyPOIOutcome Address_purificationClient::classifyPOI(const ClassifyPOIRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeProductOutcome(endpointOutcome.error());
return ClassifyPOIOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeProductOutcome(DescribeProductResult(outcome.result()));
return ClassifyPOIOutcome(ClassifyPOIResult(outcome.result()));
else
return DescribeProductOutcome(outcome.error());
return ClassifyPOIOutcome(outcome.error());
}
void Address_purificationClient::describeProductAsync(const DescribeProductRequest& request, const DescribeProductAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void Address_purificationClient::classifyPOIAsync(const ClassifyPOIRequest& request, const ClassifyPOIAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeProduct(request), context);
handler(this, request, classifyPOI(request), context);
};
asyncExecute(new Runnable(fn));
}
Address_purificationClient::DescribeProductOutcomeCallable Address_purificationClient::describeProductCallable(const DescribeProductRequest &request) const
Address_purificationClient::ClassifyPOIOutcomeCallable Address_purificationClient::classifyPOICallable(const ClassifyPOIRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeProductOutcome()>>(
auto task = std::make_shared<std::packaged_task<ClassifyPOIOutcome()>>(
[this, request]()
{
return this->describeProduct(request);
return this->classifyPOI(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Address_purificationClient::GetAlgorithmResultOutcome Address_purificationClient::getAlgorithmResult(const GetAlgorithmResultRequest &request) const
Address_purificationClient::CompleteAddressOutcome Address_purificationClient::completeAddress(const CompleteAddressRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetAlgorithmResultOutcome(endpointOutcome.error());
return CompleteAddressOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetAlgorithmResultOutcome(GetAlgorithmResultResult(outcome.result()));
return CompleteAddressOutcome(CompleteAddressResult(outcome.result()));
else
return GetAlgorithmResultOutcome(outcome.error());
return CompleteAddressOutcome(outcome.error());
}
void Address_purificationClient::getAlgorithmResultAsync(const GetAlgorithmResultRequest& request, const GetAlgorithmResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void Address_purificationClient::completeAddressAsync(const CompleteAddressRequest& request, const CompleteAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getAlgorithmResult(request), context);
handler(this, request, completeAddress(request), context);
};
asyncExecute(new Runnable(fn));
}
Address_purificationClient::GetAlgorithmResultOutcomeCallable Address_purificationClient::getAlgorithmResultCallable(const GetAlgorithmResultRequest &request) const
Address_purificationClient::CompleteAddressOutcomeCallable Address_purificationClient::completeAddressCallable(const CompleteAddressRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetAlgorithmResultOutcome()>>(
auto task = std::make_shared<std::packaged_task<CompleteAddressOutcome()>>(
[this, request]()
{
return this->getAlgorithmResult(request);
return this->completeAddress(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Address_purificationClient::GetConsoleResultOutcome Address_purificationClient::getConsoleResult(const GetConsoleResultRequest &request) const
Address_purificationClient::CorrectAddressOutcome Address_purificationClient::correctAddress(const CorrectAddressRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetConsoleResultOutcome(endpointOutcome.error());
return CorrectAddressOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetConsoleResultOutcome(GetConsoleResultResult(outcome.result()));
return CorrectAddressOutcome(CorrectAddressResult(outcome.result()));
else
return GetConsoleResultOutcome(outcome.error());
return CorrectAddressOutcome(outcome.error());
}
void Address_purificationClient::getConsoleResultAsync(const GetConsoleResultRequest& request, const GetConsoleResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void Address_purificationClient::correctAddressAsync(const CorrectAddressRequest& request, const CorrectAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getConsoleResult(request), context);
handler(this, request, correctAddress(request), context);
};
asyncExecute(new Runnable(fn));
}
Address_purificationClient::GetConsoleResultOutcomeCallable Address_purificationClient::getConsoleResultCallable(const GetConsoleResultRequest &request) const
Address_purificationClient::CorrectAddressOutcomeCallable Address_purificationClient::correctAddressCallable(const CorrectAddressRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetConsoleResultOutcome()>>(
auto task = std::make_shared<std::packaged_task<CorrectAddressOutcome()>>(
[this, request]()
{
return this->getConsoleResult(request);
return this->correctAddress(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Address_purificationClient::GetReportOutcome Address_purificationClient::getReport(const GetReportRequest &request) const
Address_purificationClient::ExtractAddressOutcome Address_purificationClient::extractAddress(const ExtractAddressRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetReportOutcome(endpointOutcome.error());
return ExtractAddressOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetReportOutcome(GetReportResult(outcome.result()));
return ExtractAddressOutcome(ExtractAddressResult(outcome.result()));
else
return GetReportOutcome(outcome.error());
return ExtractAddressOutcome(outcome.error());
}
void Address_purificationClient::getReportAsync(const GetReportRequest& request, const GetReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void Address_purificationClient::extractAddressAsync(const ExtractAddressRequest& request, const ExtractAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getReport(request), context);
handler(this, request, extractAddress(request), context);
};
asyncExecute(new Runnable(fn));
}
Address_purificationClient::GetReportOutcomeCallable Address_purificationClient::getReportCallable(const GetReportRequest &request) const
Address_purificationClient::ExtractAddressOutcomeCallable Address_purificationClient::extractAddressCallable(const ExtractAddressRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetReportOutcome()>>(
auto task = std::make_shared<std::packaged_task<ExtractAddressOutcome()>>(
[this, request]()
{
return this->getReport(request);
return this->extractAddress(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Address_purificationClient::GetUserInfomationOutcome Address_purificationClient::getUserInfomation(const GetUserInfomationRequest &request) const
Address_purificationClient::ExtractNameOutcome Address_purificationClient::extractName(const ExtractNameRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetUserInfomationOutcome(endpointOutcome.error());
return ExtractNameOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetUserInfomationOutcome(GetUserInfomationResult(outcome.result()));
return ExtractNameOutcome(ExtractNameResult(outcome.result()));
else
return GetUserInfomationOutcome(outcome.error());
return ExtractNameOutcome(outcome.error());
}
void Address_purificationClient::getUserInfomationAsync(const GetUserInfomationRequest& request, const GetUserInfomationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void Address_purificationClient::extractNameAsync(const ExtractNameRequest& request, const ExtractNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getUserInfomation(request), context);
handler(this, request, extractName(request), context);
};
asyncExecute(new Runnable(fn));
}
Address_purificationClient::GetUserInfomationOutcomeCallable Address_purificationClient::getUserInfomationCallable(const GetUserInfomationRequest &request) const
Address_purificationClient::ExtractNameOutcomeCallable Address_purificationClient::extractNameCallable(const ExtractNameRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetUserInfomationOutcome()>>(
auto task = std::make_shared<std::packaged_task<ExtractNameOutcome()>>(
[this, request]()
{
return this->getUserInfomation(request);
return this->extractName(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Address_purificationClient::ExtractPhoneOutcome Address_purificationClient::extractPhone(const ExtractPhoneRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ExtractPhoneOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ExtractPhoneOutcome(ExtractPhoneResult(outcome.result()));
else
return ExtractPhoneOutcome(outcome.error());
}
void Address_purificationClient::extractPhoneAsync(const ExtractPhoneRequest& request, const ExtractPhoneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, extractPhone(request), context);
};
asyncExecute(new Runnable(fn));
}
Address_purificationClient::ExtractPhoneOutcomeCallable Address_purificationClient::extractPhoneCallable(const ExtractPhoneRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ExtractPhoneOutcome()>>(
[this, request]()
{
return this->extractPhone(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Address_purificationClient::GetAddressDivisionCodeOutcome Address_purificationClient::getAddressDivisionCode(const GetAddressDivisionCodeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetAddressDivisionCodeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetAddressDivisionCodeOutcome(GetAddressDivisionCodeResult(outcome.result()));
else
return GetAddressDivisionCodeOutcome(outcome.error());
}
void Address_purificationClient::getAddressDivisionCodeAsync(const GetAddressDivisionCodeRequest& request, const GetAddressDivisionCodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getAddressDivisionCode(request), context);
};
asyncExecute(new Runnable(fn));
}
Address_purificationClient::GetAddressDivisionCodeOutcomeCallable Address_purificationClient::getAddressDivisionCodeCallable(const GetAddressDivisionCodeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetAddressDivisionCodeOutcome()>>(
[this, request]()
{
return this->getAddressDivisionCode(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Address_purificationClient::GetAddressSimilarityOutcome Address_purificationClient::getAddressSimilarity(const GetAddressSimilarityRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetAddressSimilarityOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetAddressSimilarityOutcome(GetAddressSimilarityResult(outcome.result()));
else
return GetAddressSimilarityOutcome(outcome.error());
}
void Address_purificationClient::getAddressSimilarityAsync(const GetAddressSimilarityRequest& request, const GetAddressSimilarityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getAddressSimilarity(request), context);
};
asyncExecute(new Runnable(fn));
}
Address_purificationClient::GetAddressSimilarityOutcomeCallable Address_purificationClient::getAddressSimilarityCallable(const GetAddressSimilarityRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetAddressSimilarityOutcome()>>(
[this, request]()
{
return this->getAddressSimilarity(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Address_purificationClient::GetZipcodeOutcome Address_purificationClient::getZipcode(const GetZipcodeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetZipcodeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetZipcodeOutcome(GetZipcodeResult(outcome.result()));
else
return GetZipcodeOutcome(outcome.error());
}
void Address_purificationClient::getZipcodeAsync(const GetZipcodeRequest& request, const GetZipcodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getZipcode(request), context);
};
asyncExecute(new Runnable(fn));
}
Address_purificationClient::GetZipcodeOutcomeCallable Address_purificationClient::getZipcodeCallable(const GetZipcodeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetZipcodeOutcome()>>(
[this, request]()
{
return this->getZipcode(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Address_purificationClient::StructureAddressOutcome Address_purificationClient::structureAddress(const StructureAddressRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return StructureAddressOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return StructureAddressOutcome(StructureAddressResult(outcome.result()));
else
return StructureAddressOutcome(outcome.error());
}
void Address_purificationClient::structureAddressAsync(const StructureAddressRequest& request, const StructureAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, structureAddress(request), context);
};
asyncExecute(new Runnable(fn));
}
Address_purificationClient::StructureAddressOutcomeCallable Address_purificationClient::structureAddressCallable(const StructureAddressRequest &request) const
{
auto task = std::make_shared<std::packaged_task<StructureAddressOutcome()>>(
[this, request]()
{
return this->structureAddress(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Address_purificationClient::UpdateProjectOutcome Address_purificationClient::updateProject(const UpdateProjectRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpdateProjectOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpdateProjectOutcome(UpdateProjectResult(outcome.result()));
else
return UpdateProjectOutcome(outcome.error());
}
void Address_purificationClient::updateProjectAsync(const UpdateProjectRequest& request, const UpdateProjectAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, updateProject(request), context);
};
asyncExecute(new Runnable(fn));
}
Address_purificationClient::UpdateProjectOutcomeCallable Address_purificationClient::updateProjectCallable(const UpdateProjectRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpdateProjectOutcome()>>(
[this, request]()
{
return this->updateProject(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));

95
address-purification/src/model/ClassifyPOIRequest.cc Normal file
View File

@@ -0,0 +1,95 @@
/*
* 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/address-purification/model/ClassifyPOIRequest.h>
using AlibabaCloud::Address_purification::Model::ClassifyPOIRequest;
ClassifyPOIRequest::ClassifyPOIRequest() :
RpcServiceRequest("address-purification", "2019-11-18", "ClassifyPOI")
{
setMethod(HttpRequest::Method::Post);
}
ClassifyPOIRequest::~ClassifyPOIRequest()
{}
std::string ClassifyPOIRequest::getDefaultProvince()const
{
return defaultProvince_;
}
void ClassifyPOIRequest::setDefaultProvince(const std::string& defaultProvince)
{
defaultProvince_ = defaultProvince;
setBodyParameter("DefaultProvince", defaultProvince);
}
std::string ClassifyPOIRequest::getServiceCode()const
{
return serviceCode_;
}
void ClassifyPOIRequest::setServiceCode(const std::string& serviceCode)
{
serviceCode_ = serviceCode;
setBodyParameter("ServiceCode", serviceCode);
}
std::string ClassifyPOIRequest::getDefaultCity()const
{
return defaultCity_;
}
void ClassifyPOIRequest::setDefaultCity(const std::string& defaultCity)
{
defaultCity_ = defaultCity;
setBodyParameter("DefaultCity", defaultCity);
}
std::string ClassifyPOIRequest::getDefaultDistrict()const
{
return defaultDistrict_;
}
void ClassifyPOIRequest::setDefaultDistrict(const std::string& defaultDistrict)
{
defaultDistrict_ = defaultDistrict;
setBodyParameter("DefaultDistrict", defaultDistrict);
}
std::string ClassifyPOIRequest::getAppKey()const
{
return appKey_;
}
void ClassifyPOIRequest::setAppKey(const std::string& appKey)
{
appKey_ = appKey;
setBodyParameter("AppKey", appKey);
}
std::string ClassifyPOIRequest::getText()const
{
return text_;
}
void ClassifyPOIRequest::setText(const std::string& text)
{
text_ = text;
setBodyParameter("Text", text);
}

26
address-purification/src/model/GetUserInfomationResult.cc → address-purification/src/model/ClassifyPOIResult.cc
View File

@@ -14,52 +14,38 @@
* limitations under the License.
*/
#include <alibabacloud/address-purification/model/GetUserInfomationResult.h>
#include <alibabacloud/address-purification/model/ClassifyPOIResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Address_purification;
using namespace AlibabaCloud::Address_purification::Model;
GetUserInfomationResult::GetUserInfomationResult() :
ClassifyPOIResult::ClassifyPOIResult() :
ServiceResult()
{}
GetUserInfomationResult::GetUserInfomationResult(const std::string &payload) :
ClassifyPOIResult::ClassifyPOIResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetUserInfomationResult::~GetUserInfomationResult()
ClassifyPOIResult::~ClassifyPOIResult()
{}
void GetUserInfomationResult::parse(const std::string &payload)
void ClassifyPOIResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["ErrCode"].isNull())
errCode_ = value["ErrCode"].asString();
if(!value["ErrMessage"].isNull())
errMessage_ = value["ErrMessage"].asString();
if(!value["Data"].isNull())
data_ = value["Data"].asString();
}
std::string GetUserInfomationResult::getData()const
std::string ClassifyPOIResult::getData()const
{
return data_;
}
std::string GetUserInfomationResult::getErrMessage()const
{
return errMessage_;
}
std::string GetUserInfomationResult::getErrCode()const
{
return errCode_;
}

95
address-purification/src/model/CompleteAddressRequest.cc Normal file
View File

@@ -0,0 +1,95 @@
/*
* 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/address-purification/model/CompleteAddressRequest.h>
using AlibabaCloud::Address_purification::Model::CompleteAddressRequest;
CompleteAddressRequest::CompleteAddressRequest() :
RpcServiceRequest("address-purification", "2019-11-18", "CompleteAddress")
{
setMethod(HttpRequest::Method::Post);
}
CompleteAddressRequest::~CompleteAddressRequest()
{}
std::string CompleteAddressRequest::getDefaultProvince()const
{
return defaultProvince_;
}
void CompleteAddressRequest::setDefaultProvince(const std::string& defaultProvince)
{
defaultProvince_ = defaultProvince;
setBodyParameter("DefaultProvince", defaultProvince);
}
std::string CompleteAddressRequest::getServiceCode()const
{
return serviceCode_;
}
void CompleteAddressRequest::setServiceCode(const std::string& serviceCode)
{
serviceCode_ = serviceCode;
setBodyParameter("ServiceCode", serviceCode);
}
std::string CompleteAddressRequest::getDefaultCity()const
{
return defaultCity_;
}
void CompleteAddressRequest::setDefaultCity(const std::string& defaultCity)
{
defaultCity_ = defaultCity;
setBodyParameter("DefaultCity", defaultCity);
}
std::string CompleteAddressRequest::getDefaultDistrict()const
{
return defaultDistrict_;
}
void CompleteAddressRequest::setDefaultDistrict(const std::string& defaultDistrict)
{
defaultDistrict_ = defaultDistrict;
setBodyParameter("DefaultDistrict", defaultDistrict);
}
std::string CompleteAddressRequest::getAppKey()const
{
return appKey_;
}
void CompleteAddressRequest::setAppKey(const std::string& appKey)
{
appKey_ = appKey;
setBodyParameter("AppKey", appKey);
}
std::string CompleteAddressRequest::getText()const
{
return text_;
}
void CompleteAddressRequest::setText(const std::string& text)
{
text_ = text;
setBodyParameter("Text", text);
}

33
address-purification/src/model/DescribeProductResult.cc → address-purification/src/model/CompleteAddressResult.cc
View File

@@ -14,59 +14,38 @@
* limitations under the License.
*/
#include <alibabacloud/address-purification/model/DescribeProductResult.h>
#include <alibabacloud/address-purification/model/CompleteAddressResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Address_purification;
using namespace AlibabaCloud::Address_purification::Model;
DescribeProductResult::DescribeProductResult() :
CompleteAddressResult::CompleteAddressResult() :
ServiceResult()
{}
DescribeProductResult::DescribeProductResult(const std::string &payload) :
CompleteAddressResult::CompleteAddressResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeProductResult::~DescribeProductResult()
CompleteAddressResult::~CompleteAddressResult()
{}
void DescribeProductResult::parse(const std::string &payload)
void CompleteAddressResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString();
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["ErrMessage"].isNull())
errMessage_ = value["ErrMessage"].asString();
if(!value["Data"].isNull())
data_ = value["Data"].asString();
}
std::string DescribeProductResult::getData()const
std::string CompleteAddressResult::getData()const
{
return data_;
}
std::string DescribeProductResult::getErrMessage()const
{
return errMessage_;
}
std::string DescribeProductResult::getCode()const
{
return code_;
}
std::string DescribeProductResult::getSuccess()const
{
return success_;
}

95
address-purification/src/model/CorrectAddressRequest.cc Normal file
View File

@@ -0,0 +1,95 @@
/*
* 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/address-purification/model/CorrectAddressRequest.h>
using AlibabaCloud::Address_purification::Model::CorrectAddressRequest;
CorrectAddressRequest::CorrectAddressRequest() :
RpcServiceRequest("address-purification", "2019-11-18", "CorrectAddress")
{
setMethod(HttpRequest::Method::Post);
}
CorrectAddressRequest::~CorrectAddressRequest()
{}
std::string CorrectAddressRequest::getDefaultProvince()const
{
return defaultProvince_;
}
void CorrectAddressRequest::setDefaultProvince(const std::string& defaultProvince)
{
defaultProvince_ = defaultProvince;
setBodyParameter("DefaultProvince", defaultProvince);
}
std::string CorrectAddressRequest::getServiceCode()const
{
return serviceCode_;
}
void CorrectAddressRequest::setServiceCode(const std::string& serviceCode)
{
serviceCode_ = serviceCode;
setBodyParameter("ServiceCode", serviceCode);
}
std::string CorrectAddressRequest::getDefaultCity()const
{
return defaultCity_;
}
void CorrectAddressRequest::setDefaultCity(const std::string& defaultCity)
{
defaultCity_ = defaultCity;
setBodyParameter("DefaultCity", defaultCity);
}
std::string CorrectAddressRequest::getDefaultDistrict()const
{
return defaultDistrict_;
}
void CorrectAddressRequest::setDefaultDistrict(const std::string& defaultDistrict)
{
defaultDistrict_ = defaultDistrict;
setBodyParameter("DefaultDistrict", defaultDistrict);
}
std::string CorrectAddressRequest::getAppKey()const
{
return appKey_;
}
void CorrectAddressRequest::setAppKey(const std::string& appKey)
{
appKey_ = appKey;
setBodyParameter("AppKey", appKey);
}
std::string CorrectAddressRequest::getText()const
{
return text_;
}
void CorrectAddressRequest::setText(const std::string& text)
{
text_ = text;
setBodyParameter("Text", text);
}

51
address-purification/src/model/CorrectAddressResult.cc Normal file
View File

@@ -0,0 +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/address-purification/model/CorrectAddressResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Address_purification;
using namespace AlibabaCloud::Address_purification::Model;
CorrectAddressResult::CorrectAddressResult() :
ServiceResult()
{}
CorrectAddressResult::CorrectAddressResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CorrectAddressResult::~CorrectAddressResult()
{}
void CorrectAddressResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Data"].isNull())
data_ = value["Data"].asString();
}
std::string CorrectAddressResult::getData()const
{
return data_;
}

95
address-purification/src/model/ExtractAddressRequest.cc Normal file
View File

@@ -0,0 +1,95 @@
/*
* 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/address-purification/model/ExtractAddressRequest.h>
using AlibabaCloud::Address_purification::Model::ExtractAddressRequest;
ExtractAddressRequest::ExtractAddressRequest() :
RpcServiceRequest("address-purification", "2019-11-18", "ExtractAddress")
{
setMethod(HttpRequest::Method::Post);
}
ExtractAddressRequest::~ExtractAddressRequest()
{}
std::string ExtractAddressRequest::getDefaultProvince()const
{
return defaultProvince_;
}
void ExtractAddressRequest::setDefaultProvince(const std::string& defaultProvince)
{
defaultProvince_ = defaultProvince;
setBodyParameter("DefaultProvince", defaultProvince);
}
std::string ExtractAddressRequest::getServiceCode()const
{
return serviceCode_;
}
void ExtractAddressRequest::setServiceCode(const std::string& serviceCode)
{
serviceCode_ = serviceCode;
setBodyParameter("ServiceCode", serviceCode);
}
std::string ExtractAddressRequest::getDefaultCity()const
{
return defaultCity_;
}
void ExtractAddressRequest::setDefaultCity(const std::string& defaultCity)
{
defaultCity_ = defaultCity;
setBodyParameter("DefaultCity", defaultCity);
}
std::string ExtractAddressRequest::getDefaultDistrict()const
{
return defaultDistrict_;
}
void ExtractAddressRequest::setDefaultDistrict(const std::string& defaultDistrict)
{
defaultDistrict_ = defaultDistrict;
setBodyParameter("DefaultDistrict", defaultDistrict);
}
std::string ExtractAddressRequest::getAppKey()const
{
return appKey_;
}
void ExtractAddressRequest::setAppKey(const std::string& appKey)
{
appKey_ = appKey;
setBodyParameter("AppKey", appKey);
}
std::string ExtractAddressRequest::getText()const
{
return text_;
}
void ExtractAddressRequest::setText(const std::string& text)
{
text_ = text;
setBodyParameter("Text", text);
}

51
address-purification/src/model/ExtractAddressResult.cc Normal file
View File

@@ -0,0 +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/address-purification/model/ExtractAddressResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Address_purification;
using namespace AlibabaCloud::Address_purification::Model;
ExtractAddressResult::ExtractAddressResult() :
ServiceResult()
{}
ExtractAddressResult::ExtractAddressResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ExtractAddressResult::~ExtractAddressResult()
{}
void ExtractAddressResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Data"].isNull())
data_ = value["Data"].asString();
}
std::string ExtractAddressResult::getData()const
{
return data_;
}

95
address-purification/src/model/ExtractNameRequest.cc Normal file
View File

@@ -0,0 +1,95 @@
/*
* 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/address-purification/model/ExtractNameRequest.h>
using AlibabaCloud::Address_purification::Model::ExtractNameRequest;
ExtractNameRequest::ExtractNameRequest() :
RpcServiceRequest("address-purification", "2019-11-18", "ExtractName")
{
setMethod(HttpRequest::Method::Post);
}
ExtractNameRequest::~ExtractNameRequest()
{}
std::string ExtractNameRequest::getDefaultProvince()const
{
return defaultProvince_;
}
void ExtractNameRequest::setDefaultProvince(const std::string& defaultProvince)
{
defaultProvince_ = defaultProvince;
setBodyParameter("DefaultProvince", defaultProvince);
}
std::string ExtractNameRequest::getServiceCode()const
{
return serviceCode_;
}
void ExtractNameRequest::setServiceCode(const std::string& serviceCode)
{
serviceCode_ = serviceCode;
setBodyParameter("ServiceCode", serviceCode);
}
std::string ExtractNameRequest::getDefaultCity()const
{
return defaultCity_;
}
void ExtractNameRequest::setDefaultCity(const std::string& defaultCity)
{
defaultCity_ = defaultCity;
setBodyParameter("DefaultCity", defaultCity);
}
std::string ExtractNameRequest::getDefaultDistrict()const
{
return defaultDistrict_;
}
void ExtractNameRequest::setDefaultDistrict(const std::string& defaultDistrict)
{
defaultDistrict_ = defaultDistrict;
setBodyParameter("DefaultDistrict", defaultDistrict);
}
std::string ExtractNameRequest::getAppKey()const
{
return appKey_;
}
void ExtractNameRequest::setAppKey(const std::string& appKey)
{
appKey_ = appKey;
setBodyParameter("AppKey", appKey);
}
std::string ExtractNameRequest::getText()const
{
return text_;
}
void ExtractNameRequest::setText(const std::string& text)
{
text_ = text;
setBodyParameter("Text", text);
}

51
address-purification/src/model/ExtractNameResult.cc Normal file
View File

@@ -0,0 +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/address-purification/model/ExtractNameResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Address_purification;
using namespace AlibabaCloud::Address_purification::Model;
ExtractNameResult::ExtractNameResult() :
ServiceResult()
{}
ExtractNameResult::ExtractNameResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ExtractNameResult::~ExtractNameResult()
{}
void ExtractNameResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Data"].isNull())
data_ = value["Data"].asString();
}
std::string ExtractNameResult::getData()const
{
return data_;
}

95
address-purification/src/model/ExtractPhoneRequest.cc Normal file
View File

@@ -0,0 +1,95 @@
/*
* 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/address-purification/model/ExtractPhoneRequest.h>
using AlibabaCloud::Address_purification::Model::ExtractPhoneRequest;
ExtractPhoneRequest::ExtractPhoneRequest() :
RpcServiceRequest("address-purification", "2019-11-18", "ExtractPhone")
{
setMethod(HttpRequest::Method::Post);
}
ExtractPhoneRequest::~ExtractPhoneRequest()
{}
std::string ExtractPhoneRequest::getDefaultProvince()const
{
return defaultProvince_;
}
void ExtractPhoneRequest::setDefaultProvince(const std::string& defaultProvince)
{
defaultProvince_ = defaultProvince;
setBodyParameter("DefaultProvince", defaultProvince);
}
std::string ExtractPhoneRequest::getServiceCode()const
{
return serviceCode_;
}
void ExtractPhoneRequest::setServiceCode(const std::string& serviceCode)
{
serviceCode_ = serviceCode;
setBodyParameter("ServiceCode", serviceCode);
}
std::string ExtractPhoneRequest::getDefaultCity()const
{
return defaultCity_;
}
void ExtractPhoneRequest::setDefaultCity(const std::string& defaultCity)
{
defaultCity_ = defaultCity;
setBodyParameter("DefaultCity", defaultCity);
}
std::string ExtractPhoneRequest::getDefaultDistrict()const
{
return defaultDistrict_;
}
void ExtractPhoneRequest::setDefaultDistrict(const std::string& defaultDistrict)
{
defaultDistrict_ = defaultDistrict;
setBodyParameter("DefaultDistrict", defaultDistrict);
}
std::string ExtractPhoneRequest::getAppKey()const
{
return appKey_;
}
void ExtractPhoneRequest::setAppKey(const std::string& appKey)
{
appKey_ = appKey;
setBodyParameter("AppKey", appKey);
}
std::string ExtractPhoneRequest::getText()const
{
return text_;
}
void ExtractPhoneRequest::setText(const std::string& text)
{
text_ = text;
setBodyParameter("Text", text);
}

51
address-purification/src/model/ExtractPhoneResult.cc Normal file
View File

@@ -0,0 +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/address-purification/model/ExtractPhoneResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Address_purification;
using namespace AlibabaCloud::Address_purification::Model;
ExtractPhoneResult::ExtractPhoneResult() :
ServiceResult()
{}
ExtractPhoneResult::ExtractPhoneResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ExtractPhoneResult::~ExtractPhoneResult()
{}
void ExtractPhoneResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Data"].isNull())
data_ = value["Data"].asString();
}
std::string ExtractPhoneResult::getData()const
{
return data_;
}

95
address-purification/src/model/GetAddressDivisionCodeRequest.cc Normal file
View File

@@ -0,0 +1,95 @@
/*
* 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/address-purification/model/GetAddressDivisionCodeRequest.h>
using AlibabaCloud::Address_purification::Model::GetAddressDivisionCodeRequest;
GetAddressDivisionCodeRequest::GetAddressDivisionCodeRequest() :
RpcServiceRequest("address-purification", "2019-11-18", "GetAddressDivisionCode")
{
setMethod(HttpRequest::Method::Post);
}
GetAddressDivisionCodeRequest::~GetAddressDivisionCodeRequest()
{}
std::string GetAddressDivisionCodeRequest::getDefaultProvince()const
{
return defaultProvince_;
}
void GetAddressDivisionCodeRequest::setDefaultProvince(const std::string& defaultProvince)
{
defaultProvince_ = defaultProvince;
setBodyParameter("DefaultProvince", defaultProvince);
}
std::string GetAddressDivisionCodeRequest::getServiceCode()const
{
return serviceCode_;
}
void GetAddressDivisionCodeRequest::setServiceCode(const std::string& serviceCode)
{
serviceCode_ = serviceCode;
setBodyParameter("ServiceCode", serviceCode);
}
std::string GetAddressDivisionCodeRequest::getDefaultCity()const
{
return defaultCity_;
}
void GetAddressDivisionCodeRequest::setDefaultCity(const std::string& defaultCity)
{
defaultCity_ = defaultCity;
setBodyParameter("DefaultCity", defaultCity);
}
std::string GetAddressDivisionCodeRequest::getDefaultDistrict()const
{
return defaultDistrict_;
}
void GetAddressDivisionCodeRequest::setDefaultDistrict(const std::string& defaultDistrict)
{
defaultDistrict_ = defaultDistrict;
setBodyParameter("DefaultDistrict", defaultDistrict);
}
std::string GetAddressDivisionCodeRequest::getAppKey()const
{
return appKey_;
}
void GetAddressDivisionCodeRequest::setAppKey(const std::string& appKey)
{
appKey_ = appKey;
setBodyParameter("AppKey", appKey);
}
std::string GetAddressDivisionCodeRequest::getText()const
{
return text_;
}
void GetAddressDivisionCodeRequest::setText(const std::string& text)
{
text_ = text;
setBodyParameter("Text", text);
}

51
address-purification/src/model/GetAddressDivisionCodeResult.cc Normal file
View File

@@ -0,0 +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/address-purification/model/GetAddressDivisionCodeResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Address_purification;
using namespace AlibabaCloud::Address_purification::Model;
GetAddressDivisionCodeResult::GetAddressDivisionCodeResult() :
ServiceResult()
{}
GetAddressDivisionCodeResult::GetAddressDivisionCodeResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetAddressDivisionCodeResult::~GetAddressDivisionCodeResult()
{}
void GetAddressDivisionCodeResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Data"].isNull())
data_ = value["Data"].asString();
}
std::string GetAddressDivisionCodeResult::getData()const
{
return data_;
}

95
address-purification/src/model/GetAddressSimilarityRequest.cc Normal file
View File

@@ -0,0 +1,95 @@
/*
* 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/address-purification/model/GetAddressSimilarityRequest.h>
using AlibabaCloud::Address_purification::Model::GetAddressSimilarityRequest;
GetAddressSimilarityRequest::GetAddressSimilarityRequest() :
RpcServiceRequest("address-purification", "2019-11-18", "GetAddressSimilarity")
{
setMethod(HttpRequest::Method::Post);
}
GetAddressSimilarityRequest::~GetAddressSimilarityRequest()
{}
std::string GetAddressSimilarityRequest::getDefaultProvince()const
{
return defaultProvince_;
}
void GetAddressSimilarityRequest::setDefaultProvince(const std::string& defaultProvince)
{
defaultProvince_ = defaultProvince;
setBodyParameter("DefaultProvince", defaultProvince);
}
std::string GetAddressSimilarityRequest::getServiceCode()const
{
return serviceCode_;
}
void GetAddressSimilarityRequest::setServiceCode(const std::string& serviceCode)
{
serviceCode_ = serviceCode;
setBodyParameter("ServiceCode", serviceCode);
}
std::string GetAddressSimilarityRequest::getDefaultCity()const
{
return defaultCity_;
}
void GetAddressSimilarityRequest::setDefaultCity(const std::string& defaultCity)
{
defaultCity_ = defaultCity;
setBodyParameter("DefaultCity", defaultCity);
}
std::string GetAddressSimilarityRequest::getDefaultDistrict()const
{
return defaultDistrict_;
}
void GetAddressSimilarityRequest::setDefaultDistrict(const std::string& defaultDistrict)
{
defaultDistrict_ = defaultDistrict;
setBodyParameter("DefaultDistrict", defaultDistrict);
}
std::string GetAddressSimilarityRequest::getAppKey()const
{
return appKey_;
}
void GetAddressSimilarityRequest::setAppKey(const std::string& appKey)
{
appKey_ = appKey;
setBodyParameter("AppKey", appKey);
}
std::string GetAddressSimilarityRequest::getText()const
{
return text_;
}
void GetAddressSimilarityRequest::setText(const std::string& text)
{
text_ = text;
setBodyParameter("Text", text);
}

51
address-purification/src/model/GetAddressSimilarityResult.cc Normal file
View File

@@ -0,0 +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/address-purification/model/GetAddressSimilarityResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Address_purification;
using namespace AlibabaCloud::Address_purification::Model;
GetAddressSimilarityResult::GetAddressSimilarityResult() :
ServiceResult()
{}
GetAddressSimilarityResult::GetAddressSimilarityResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetAddressSimilarityResult::~GetAddressSimilarityResult()
{}
void GetAddressSimilarityResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Data"].isNull())
data_ = value["Data"].asString();
}
std::string GetAddressSimilarityResult::getData()const
{
return data_;
}

62
address-purification/src/model/GetAlgorithmResultRequest.cc
View File

@@ -1,62 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/address-purification/model/GetAlgorithmResultRequest.h>
using AlibabaCloud::Address_purification::Model::GetAlgorithmResultRequest;
GetAlgorithmResultRequest::GetAlgorithmResultRequest() :
RpcServiceRequest("address-purification", "2019-11-18", "GetAlgorithmResult")
{
setMethod(HttpRequest::Method::Post);
}
GetAlgorithmResultRequest::~GetAlgorithmResultRequest()
{}
std::string GetAlgorithmResultRequest::getServiceCode()const
{
return serviceCode_;
}
void GetAlgorithmResultRequest::setServiceCode(const std::string& serviceCode)
{
serviceCode_ = serviceCode;
setBodyParameter("ServiceCode", serviceCode);
}
std::string GetAlgorithmResultRequest::getApiCode()const
{
return apiCode_;
}
void GetAlgorithmResultRequest::setApiCode(const std::string& apiCode)
{
apiCode_ = apiCode;
setBodyParameter("ApiCode", apiCode);
}
std::string GetAlgorithmResultRequest::getParameters()const
{
return parameters_;
}
void GetAlgorithmResultRequest::setParameters(const std::string& parameters)
{
parameters_ = parameters;
setBodyParameter("Parameters", parameters);
}

72
address-purification/src/model/GetAlgorithmResultResult.cc
View File

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

73
address-purification/src/model/GetConsoleResultRequest.cc
View File

@@ -1,73 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/address-purification/model/GetConsoleResultRequest.h>
using AlibabaCloud::Address_purification::Model::GetConsoleResultRequest;
GetConsoleResultRequest::GetConsoleResultRequest() :
RpcServiceRequest("address-purification", "2019-11-18", "GetConsoleResult")
{
setMethod(HttpRequest::Method::Post);
}
GetConsoleResultRequest::~GetConsoleResultRequest()
{}
std::string GetConsoleResultRequest::getProductCode()const
{
return productCode_;
}
void GetConsoleResultRequest::setProductCode(const std::string& productCode)
{
productCode_ = productCode;
setBodyParameter("ProductCode", productCode);
}
std::string GetConsoleResultRequest::getApiCode()const
{
return apiCode_;
}
void GetConsoleResultRequest::setApiCode(const std::string& apiCode)
{
apiCode_ = apiCode;
setBodyParameter("ApiCode", apiCode);
}
std::string GetConsoleResultRequest::getCommodityCode()const
{
return commodityCode_;
}
void GetConsoleResultRequest::setCommodityCode(const std::string& commodityCode)
{
commodityCode_ = commodityCode;
setBodyParameter("CommodityCode", commodityCode);
}
std::string GetConsoleResultRequest::getParameters()const
{
return parameters_;
}
void GetConsoleResultRequest::setParameters(const std::string& parameters)
{
parameters_ = parameters;
setBodyParameter("Parameters", parameters);
}

95
address-purification/src/model/GetReportRequest.cc
View File

@@ -1,95 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/address-purification/model/GetReportRequest.h>
using AlibabaCloud::Address_purification::Model::GetReportRequest;
GetReportRequest::GetReportRequest() :
RpcServiceRequest("address-purification", "2019-11-18", "GetReport")
{
setMethod(HttpRequest::Method::Post);
}
GetReportRequest::~GetReportRequest()
{}
std::string GetReportRequest::getProductCode()const
{
return productCode_;
}
void GetReportRequest::setProductCode(const std::string& productCode)
{
productCode_ = productCode;
setBodyParameter("ProductCode", productCode);
}
std::string GetReportRequest::getReportType()const
{
return reportType_;
}
void GetReportRequest::setReportType(const std::string& reportType)
{
reportType_ = reportType;
setBodyParameter("ReportType", reportType);
}
std::string GetReportRequest::getApiCode()const
{
return apiCode_;
}
void GetReportRequest::setApiCode(const std::string& apiCode)
{
apiCode_ = apiCode;
setBodyParameter("ApiCode", apiCode);
}
std::string GetReportRequest::getGranularity()const
{
return granularity_;
}
void GetReportRequest::setGranularity(const std::string& granularity)
{
granularity_ = granularity;
setBodyParameter("Granularity", granularity);
}
std::string GetReportRequest::getCommodityCode()const
{
return commodityCode_;
}
void GetReportRequest::setCommodityCode(const std::string& commodityCode)
{
commodityCode_ = commodityCode;
setBodyParameter("CommodityCode", commodityCode);
}
std::string GetReportRequest::getParameters()const
{
return parameters_;
}
void GetReportRequest::setParameters(const std::string& parameters)
{
parameters_ = parameters;
setBodyParameter("Parameters", parameters);
}

51
address-purification/src/model/GetUserInfomationRequest.cc
View File

@@ -1,51 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/address-purification/model/GetUserInfomationRequest.h>
using AlibabaCloud::Address_purification::Model::GetUserInfomationRequest;
GetUserInfomationRequest::GetUserInfomationRequest() :
RpcServiceRequest("address-purification", "2019-11-18", "GetUserInfomation")
{
setMethod(HttpRequest::Method::Post);
}
GetUserInfomationRequest::~GetUserInfomationRequest()
{}
std::string GetUserInfomationRequest::getProductCode()const
{
return productCode_;
}
void GetUserInfomationRequest::setProductCode(const std::string& productCode)
{
productCode_ = productCode;
setBodyParameter("ProductCode", productCode);
}
std::string GetUserInfomationRequest::getParameters()const
{
return parameters_;
}
void GetUserInfomationRequest::setParameters(const std::string& parameters)
{
parameters_ = parameters;
setBodyParameter("Parameters", parameters);
}

95
address-purification/src/model/GetZipcodeRequest.cc Normal file
View File

@@ -0,0 +1,95 @@
/*
* 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/address-purification/model/GetZipcodeRequest.h>
using AlibabaCloud::Address_purification::Model::GetZipcodeRequest;
GetZipcodeRequest::GetZipcodeRequest() :
RpcServiceRequest("address-purification", "2019-11-18", "GetZipcode")
{
setMethod(HttpRequest::Method::Post);
}
GetZipcodeRequest::~GetZipcodeRequest()
{}
std::string GetZipcodeRequest::getDefaultProvince()const
{
return defaultProvince_;
}
void GetZipcodeRequest::setDefaultProvince(const std::string& defaultProvince)
{
defaultProvince_ = defaultProvince;
setBodyParameter("DefaultProvince", defaultProvince);
}
std::string GetZipcodeRequest::getServiceCode()const
{
return serviceCode_;
}
void GetZipcodeRequest::setServiceCode(const std::string& serviceCode)
{
serviceCode_ = serviceCode;
setBodyParameter("ServiceCode", serviceCode);
}
std::string GetZipcodeRequest::getDefaultCity()const
{
return defaultCity_;
}
void GetZipcodeRequest::setDefaultCity(const std::string& defaultCity)
{
defaultCity_ = defaultCity;
setBodyParameter("DefaultCity", defaultCity);
}
std::string GetZipcodeRequest::getDefaultDistrict()const
{
return defaultDistrict_;
}
void GetZipcodeRequest::setDefaultDistrict(const std::string& defaultDistrict)
{
defaultDistrict_ = defaultDistrict;
setBodyParameter("DefaultDistrict", defaultDistrict);
}
std::string GetZipcodeRequest::getAppKey()const
{
return appKey_;
}
void GetZipcodeRequest::setAppKey(const std::string& appKey)
{
appKey_ = appKey;
setBodyParameter("AppKey", appKey);
}
std::string GetZipcodeRequest::getText()const
{
return text_;
}
void GetZipcodeRequest::setText(const std::string& text)
{
text_ = text;
setBodyParameter("Text", text);
}

26
address-purification/src/model/GetReportResult.cc → address-purification/src/model/GetZipcodeResult.cc
View File

@@ -14,52 +14,38 @@
* limitations under the License.
*/
#include <alibabacloud/address-purification/model/GetReportResult.h>
#include <alibabacloud/address-purification/model/GetZipcodeResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Address_purification;
using namespace AlibabaCloud::Address_purification::Model;
GetReportResult::GetReportResult() :
GetZipcodeResult::GetZipcodeResult() :
ServiceResult()
{}
GetReportResult::GetReportResult(const std::string &payload) :
GetZipcodeResult::GetZipcodeResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetReportResult::~GetReportResult()
GetZipcodeResult::~GetZipcodeResult()
{}
void GetReportResult::parse(const std::string &payload)
void GetZipcodeResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["ErrCode"].isNull())
errCode_ = value["ErrCode"].asString();
if(!value["ErrMessage"].isNull())
errMessage_ = value["ErrMessage"].asString();
if(!value["Data"].isNull())
data_ = value["Data"].asString();
}
std::string GetReportResult::getData()const
std::string GetZipcodeResult::getData()const
{
return data_;
}
std::string GetReportResult::getErrMessage()const
{
return errMessage_;
}
std::string GetReportResult::getErrCode()const
{
return errCode_;
}

95
address-purification/src/model/StructureAddressRequest.cc Normal file
View File

@@ -0,0 +1,95 @@
/*
* 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/address-purification/model/StructureAddressRequest.h>
using AlibabaCloud::Address_purification::Model::StructureAddressRequest;
StructureAddressRequest::StructureAddressRequest() :
RpcServiceRequest("address-purification", "2019-11-18", "StructureAddress")
{
setMethod(HttpRequest::Method::Post);
}
StructureAddressRequest::~StructureAddressRequest()
{}
std::string StructureAddressRequest::getDefaultProvince()const
{
return defaultProvince_;
}
void StructureAddressRequest::setDefaultProvince(const std::string& defaultProvince)
{
defaultProvince_ = defaultProvince;
setBodyParameter("DefaultProvince", defaultProvince);
}
std::string StructureAddressRequest::getServiceCode()const
{
return serviceCode_;
}
void StructureAddressRequest::setServiceCode(const std::string& serviceCode)
{
serviceCode_ = serviceCode;
setBodyParameter("ServiceCode", serviceCode);
}
std::string StructureAddressRequest::getDefaultCity()const
{
return defaultCity_;
}
void StructureAddressRequest::setDefaultCity(const std::string& defaultCity)
{
defaultCity_ = defaultCity;
setBodyParameter("DefaultCity", defaultCity);
}
std::string StructureAddressRequest::getDefaultDistrict()const
{
return defaultDistrict_;
}
void StructureAddressRequest::setDefaultDistrict(const std::string& defaultDistrict)
{
defaultDistrict_ = defaultDistrict;
setBodyParameter("DefaultDistrict", defaultDistrict);
}
std::string StructureAddressRequest::getAppKey()const
{
return appKey_;
}
void StructureAddressRequest::setAppKey(const std::string& appKey)
{
appKey_ = appKey;
setBodyParameter("AppKey", appKey);
}
std::string StructureAddressRequest::getText()const
{
return text_;
}
void StructureAddressRequest::setText(const std::string& text)
{
text_ = text;
setBodyParameter("Text", text);
}

26
address-purification/src/model/GetConsoleResultResult.cc → address-purification/src/model/StructureAddressResult.cc
View File

@@ -14,52 +14,38 @@
* limitations under the License.
*/
#include <alibabacloud/address-purification/model/GetConsoleResultResult.h>
#include <alibabacloud/address-purification/model/StructureAddressResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Address_purification;
using namespace AlibabaCloud::Address_purification::Model;
GetConsoleResultResult::GetConsoleResultResult() :
StructureAddressResult::StructureAddressResult() :
ServiceResult()
{}
GetConsoleResultResult::GetConsoleResultResult(const std::string &payload) :
StructureAddressResult::StructureAddressResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetConsoleResultResult::~GetConsoleResultResult()
StructureAddressResult::~StructureAddressResult()
{}
void GetConsoleResultResult::parse(const std::string &payload)
void StructureAddressResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["ErrCode"].isNull())
errCode_ = value["ErrCode"].asString();
if(!value["ErrMessage"].isNull())
errMessage_ = value["ErrMessage"].asString();
if(!value["Data"].isNull())
data_ = value["Data"].asString();
}
std::string GetConsoleResultResult::getData()const
std::string StructureAddressResult::getData()const
{
return data_;
}
std::string GetConsoleResultResult::getErrMessage()const
{
return errMessage_;
}
std::string GetConsoleResultResult::getErrCode()const
{
return errCode_;
}

18
address-purification/src/model/DescribeProductRequest.cc → address-purification/src/model/UpdateProjectRequest.cc
View File

@@ -14,36 +14,36 @@
* limitations under the License.
*/
#include <alibabacloud/address-purification/model/DescribeProductRequest.h>
#include <alibabacloud/address-purification/model/UpdateProjectRequest.h>
using AlibabaCloud::Address_purification::Model::DescribeProductRequest;
using AlibabaCloud::Address_purification::Model::UpdateProjectRequest;
DescribeProductRequest::DescribeProductRequest() :
RpcServiceRequest("address-purification", "2019-11-18", "DescribeProduct")
UpdateProjectRequest::UpdateProjectRequest() :
RpcServiceRequest("address-purification", "2019-11-18", "UpdateProject")
{
setMethod(HttpRequest::Method::Post);
}
DescribeProductRequest::~DescribeProductRequest()
UpdateProjectRequest::~UpdateProjectRequest()
{}
std::string DescribeProductRequest::getServiceCode()const
std::string UpdateProjectRequest::getServiceCode()const
{
return serviceCode_;
}
void DescribeProductRequest::setServiceCode(const std::string& serviceCode)
void UpdateProjectRequest::setServiceCode(const std::string& serviceCode)
{
serviceCode_ = serviceCode;
setBodyParameter("ServiceCode", serviceCode);
}
std::string DescribeProductRequest::getParameters()const
std::string UpdateProjectRequest::getParameters()const
{
return parameters_;
}
void DescribeProductRequest::setParameters(const std::string& parameters)
void UpdateProjectRequest::setParameters(const std::string& parameters)
{
parameters_ = parameters;
setBodyParameter("Parameters", parameters);

51
address-purification/src/model/UpdateProjectResult.cc Normal file
View File

@@ -0,0 +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/address-purification/model/UpdateProjectResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Address_purification;
using namespace AlibabaCloud::Address_purification::Model;
UpdateProjectResult::UpdateProjectResult() :
ServiceResult()
{}
UpdateProjectResult::UpdateProjectResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
UpdateProjectResult::~UpdateProjectResult()
{}
void UpdateProjectResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Data"].isNull())
data_ = value["Data"].asString();
}
std::string UpdateProjectResult::getData()const
{
return data_;
}