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

Aaaaa.

Browse Source
This commit is contained in:
sdk-team
2021-05-22 10:25:05 +00:00
parent 5d8e86e1a6
commit 8617b6ffe5
37 changed files with 2482 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGELOG
View File

@@ -1,3 +1,6 @@
2021-05-22 Version: 1.36.751
- Aaaaa.
2021-05-21 Version: 1.36.750
- Supported DescribeLoadBalancers with DeleteProtection and so on.

2
VERSION
View File

@@ -1 +1 @@
1.36.750
1.36.751

32
address-purification/CMakeLists.txt
View File

@@ -29,18 +29,34 @@ set(address-purification_public_header_model
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/ExtractExpressRequest.h
include/alibabacloud/address-purification/model/ExtractExpressResult.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/GetAddressBlockMappingRequest.h
include/alibabacloud/address-purification/model/GetAddressBlockMappingResult.h
include/alibabacloud/address-purification/model/GetAddressDivisionCodeRequest.h
include/alibabacloud/address-purification/model/GetAddressDivisionCodeResult.h
include/alibabacloud/address-purification/model/GetAddressEvaluateRequest.h
include/alibabacloud/address-purification/model/GetAddressEvaluateResult.h
include/alibabacloud/address-purification/model/GetAddressGeocodeRequest.h
include/alibabacloud/address-purification/model/GetAddressGeocodeResult.h
include/alibabacloud/address-purification/model/GetAddressSearchRequest.h
include/alibabacloud/address-purification/model/GetAddressSearchResult.h
include/alibabacloud/address-purification/model/GetAddressSimilarityRequest.h
include/alibabacloud/address-purification/model/GetAddressSimilarityResult.h
include/alibabacloud/address-purification/model/GetInputSearchRequest.h
include/alibabacloud/address-purification/model/GetInputSearchResult.h
include/alibabacloud/address-purification/model/GetZipcodeRequest.h
include/alibabacloud/address-purification/model/GetZipcodeResult.h
include/alibabacloud/address-purification/model/PredictPOIRequest.h
include/alibabacloud/address-purification/model/PredictPOIResult.h
include/alibabacloud/address-purification/model/StructureAddressRequest.h
include/alibabacloud/address-purification/model/StructureAddressResult.h
include/alibabacloud/address-purification/model/TransferCoordRequest.h
include/alibabacloud/address-purification/model/TransferCoordResult.h
include/alibabacloud/address-purification/model/UpdateProjectRequest.h
include/alibabacloud/address-purification/model/UpdateProjectResult.h )
@@ -54,18 +70,34 @@ set(address-purification_src
src/model/CorrectAddressResult.cc
src/model/ExtractAddressRequest.cc
src/model/ExtractAddressResult.cc
src/model/ExtractExpressRequest.cc
src/model/ExtractExpressResult.cc
src/model/ExtractNameRequest.cc
src/model/ExtractNameResult.cc
src/model/ExtractPhoneRequest.cc
src/model/ExtractPhoneResult.cc
src/model/GetAddressBlockMappingRequest.cc
src/model/GetAddressBlockMappingResult.cc
src/model/GetAddressDivisionCodeRequest.cc
src/model/GetAddressDivisionCodeResult.cc
src/model/GetAddressEvaluateRequest.cc
src/model/GetAddressEvaluateResult.cc
src/model/GetAddressGeocodeRequest.cc
src/model/GetAddressGeocodeResult.cc
src/model/GetAddressSearchRequest.cc
src/model/GetAddressSearchResult.cc
src/model/GetAddressSimilarityRequest.cc
src/model/GetAddressSimilarityResult.cc
src/model/GetInputSearchRequest.cc
src/model/GetInputSearchResult.cc
src/model/GetZipcodeRequest.cc
src/model/GetZipcodeResult.cc
src/model/PredictPOIRequest.cc
src/model/PredictPOIResult.cc
src/model/StructureAddressRequest.cc
src/model/StructureAddressResult.cc
src/model/TransferCoordRequest.cc
src/model/TransferCoordResult.cc
src/model/UpdateProjectRequest.cc
src/model/UpdateProjectResult.cc )

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

@@ -30,18 +30,34 @@
#include "model/CorrectAddressResult.h"
#include "model/ExtractAddressRequest.h"
#include "model/ExtractAddressResult.h"
#include "model/ExtractExpressRequest.h"
#include "model/ExtractExpressResult.h"
#include "model/ExtractNameRequest.h"
#include "model/ExtractNameResult.h"
#include "model/ExtractPhoneRequest.h"
#include "model/ExtractPhoneResult.h"
#include "model/GetAddressBlockMappingRequest.h"
#include "model/GetAddressBlockMappingResult.h"
#include "model/GetAddressDivisionCodeRequest.h"
#include "model/GetAddressDivisionCodeResult.h"
#include "model/GetAddressEvaluateRequest.h"
#include "model/GetAddressEvaluateResult.h"
#include "model/GetAddressGeocodeRequest.h"
#include "model/GetAddressGeocodeResult.h"
#include "model/GetAddressSearchRequest.h"
#include "model/GetAddressSearchResult.h"
#include "model/GetAddressSimilarityRequest.h"
#include "model/GetAddressSimilarityResult.h"
#include "model/GetInputSearchRequest.h"
#include "model/GetInputSearchResult.h"
#include "model/GetZipcodeRequest.h"
#include "model/GetZipcodeResult.h"
#include "model/PredictPOIRequest.h"
#include "model/PredictPOIResult.h"
#include "model/StructureAddressRequest.h"
#include "model/StructureAddressResult.h"
#include "model/TransferCoordRequest.h"
#include "model/TransferCoordResult.h"
#include "model/UpdateProjectRequest.h"
#include "model/UpdateProjectResult.h"
@@ -65,24 +81,48 @@ namespace AlibabaCloud
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::ExtractExpressResult> ExtractExpressOutcome;
typedef std::future<ExtractExpressOutcome> ExtractExpressOutcomeCallable;
typedef std::function<void(const Address_purificationClient*, const Model::ExtractExpressRequest&, const ExtractExpressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExtractExpressAsyncHandler;
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::GetAddressBlockMappingResult> GetAddressBlockMappingOutcome;
typedef std::future<GetAddressBlockMappingOutcome> GetAddressBlockMappingOutcomeCallable;
typedef std::function<void(const Address_purificationClient*, const Model::GetAddressBlockMappingRequest&, const GetAddressBlockMappingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAddressBlockMappingAsyncHandler;
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::GetAddressEvaluateResult> GetAddressEvaluateOutcome;
typedef std::future<GetAddressEvaluateOutcome> GetAddressEvaluateOutcomeCallable;
typedef std::function<void(const Address_purificationClient*, const Model::GetAddressEvaluateRequest&, const GetAddressEvaluateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAddressEvaluateAsyncHandler;
typedef Outcome<Error, Model::GetAddressGeocodeResult> GetAddressGeocodeOutcome;
typedef std::future<GetAddressGeocodeOutcome> GetAddressGeocodeOutcomeCallable;
typedef std::function<void(const Address_purificationClient*, const Model::GetAddressGeocodeRequest&, const GetAddressGeocodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAddressGeocodeAsyncHandler;
typedef Outcome<Error, Model::GetAddressSearchResult> GetAddressSearchOutcome;
typedef std::future<GetAddressSearchOutcome> GetAddressSearchOutcomeCallable;
typedef std::function<void(const Address_purificationClient*, const Model::GetAddressSearchRequest&, const GetAddressSearchOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAddressSearchAsyncHandler;
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::GetInputSearchResult> GetInputSearchOutcome;
typedef std::future<GetInputSearchOutcome> GetInputSearchOutcomeCallable;
typedef std::function<void(const Address_purificationClient*, const Model::GetInputSearchRequest&, const GetInputSearchOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetInputSearchAsyncHandler;
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::PredictPOIResult> PredictPOIOutcome;
typedef std::future<PredictPOIOutcome> PredictPOIOutcomeCallable;
typedef std::function<void(const Address_purificationClient*, const Model::PredictPOIRequest&, const PredictPOIOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PredictPOIAsyncHandler;
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::TransferCoordResult> TransferCoordOutcome;
typedef std::future<TransferCoordOutcome> TransferCoordOutcomeCallable;
typedef std::function<void(const Address_purificationClient*, const Model::TransferCoordRequest&, const TransferCoordOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TransferCoordAsyncHandler;
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;
@@ -103,24 +143,48 @@ namespace AlibabaCloud
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;
ExtractExpressOutcome extractExpress(const Model::ExtractExpressRequest &request)const;
void extractExpressAsync(const Model::ExtractExpressRequest& request, const ExtractExpressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ExtractExpressOutcomeCallable extractExpressCallable(const Model::ExtractExpressRequest& 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;
GetAddressBlockMappingOutcome getAddressBlockMapping(const Model::GetAddressBlockMappingRequest &request)const;
void getAddressBlockMappingAsync(const Model::GetAddressBlockMappingRequest& request, const GetAddressBlockMappingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetAddressBlockMappingOutcomeCallable getAddressBlockMappingCallable(const Model::GetAddressBlockMappingRequest& 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;
GetAddressEvaluateOutcome getAddressEvaluate(const Model::GetAddressEvaluateRequest &request)const;
void getAddressEvaluateAsync(const Model::GetAddressEvaluateRequest& request, const GetAddressEvaluateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetAddressEvaluateOutcomeCallable getAddressEvaluateCallable(const Model::GetAddressEvaluateRequest& request) const;
GetAddressGeocodeOutcome getAddressGeocode(const Model::GetAddressGeocodeRequest &request)const;
void getAddressGeocodeAsync(const Model::GetAddressGeocodeRequest& request, const GetAddressGeocodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetAddressGeocodeOutcomeCallable getAddressGeocodeCallable(const Model::GetAddressGeocodeRequest& request) const;
GetAddressSearchOutcome getAddressSearch(const Model::GetAddressSearchRequest &request)const;
void getAddressSearchAsync(const Model::GetAddressSearchRequest& request, const GetAddressSearchAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetAddressSearchOutcomeCallable getAddressSearchCallable(const Model::GetAddressSearchRequest& 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;
GetInputSearchOutcome getInputSearch(const Model::GetInputSearchRequest &request)const;
void getInputSearchAsync(const Model::GetInputSearchRequest& request, const GetInputSearchAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetInputSearchOutcomeCallable getInputSearchCallable(const Model::GetInputSearchRequest& 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;
PredictPOIOutcome predictPOI(const Model::PredictPOIRequest &request)const;
void predictPOIAsync(const Model::PredictPOIRequest& request, const PredictPOIAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
PredictPOIOutcomeCallable predictPOICallable(const Model::PredictPOIRequest& 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;
TransferCoordOutcome transferCoord(const Model::TransferCoordRequest &request)const;
void transferCoordAsync(const Model::TransferCoordRequest& request, const TransferCoordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
TransferCoordOutcomeCallable transferCoordCallable(const Model::TransferCoordRequest& 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;

63
address-purification/include/alibabacloud/address-purification/model/ExtractExpressRequest.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_EXTRACTEXPRESSREQUEST_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTEXPRESSREQUEST_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 ExtractExpressRequest : public RpcServiceRequest
{
public:
ExtractExpressRequest();
~ExtractExpressRequest();
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_EXTRACTEXPRESSREQUEST_H_

51
address-purification/include/alibabacloud/address-purification/model/ExtractExpressResult.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_EXTRACTEXPRESSRESULT_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTEXPRESSRESULT_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 ExtractExpressResult : public ServiceResult
{
public:
ExtractExpressResult();
explicit ExtractExpressResult(const std::string &payload);
~ExtractExpressResult();
std::string getData()const;
protected:
void parse(const std::string &payload);
private:
std::string data_;
};
}
}
}
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTEXPRESSRESULT_H_

63
address-purification/include/alibabacloud/address-purification/model/GetAddressBlockMappingRequest.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_GETADDRESSBLOCKMAPPINGREQUEST_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSBLOCKMAPPINGREQUEST_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 GetAddressBlockMappingRequest : public RpcServiceRequest
{
public:
GetAddressBlockMappingRequest();
~GetAddressBlockMappingRequest();
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_GETADDRESSBLOCKMAPPINGREQUEST_H_

51
address-purification/include/alibabacloud/address-purification/model/GetAddressBlockMappingResult.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_GETADDRESSBLOCKMAPPINGRESULT_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSBLOCKMAPPINGRESULT_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 GetAddressBlockMappingResult : public ServiceResult
{
public:
GetAddressBlockMappingResult();
explicit GetAddressBlockMappingResult(const std::string &payload);
~GetAddressBlockMappingResult();
std::string getData()const;
protected:
void parse(const std::string &payload);
private:
std::string data_;
};
}
}
}
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSBLOCKMAPPINGRESULT_H_

63
address-purification/include/alibabacloud/address-purification/model/GetAddressEvaluateRequest.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_GETADDRESSEVALUATEREQUEST_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSEVALUATEREQUEST_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 GetAddressEvaluateRequest : public RpcServiceRequest
{
public:
GetAddressEvaluateRequest();
~GetAddressEvaluateRequest();
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_GETADDRESSEVALUATEREQUEST_H_

51
address-purification/include/alibabacloud/address-purification/model/GetAddressEvaluateResult.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_GETADDRESSEVALUATERESULT_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSEVALUATERESULT_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 GetAddressEvaluateResult : public ServiceResult
{
public:
GetAddressEvaluateResult();
explicit GetAddressEvaluateResult(const std::string &payload);
~GetAddressEvaluateResult();
std::string getData()const;
protected:
void parse(const std::string &payload);
private:
std::string data_;
};
}
}
}
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSEVALUATERESULT_H_

63
address-purification/include/alibabacloud/address-purification/model/GetAddressGeocodeRequest.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_GETADDRESSGEOCODEREQUEST_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSGEOCODEREQUEST_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 GetAddressGeocodeRequest : public RpcServiceRequest
{
public:
GetAddressGeocodeRequest();
~GetAddressGeocodeRequest();
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_GETADDRESSGEOCODEREQUEST_H_

51
address-purification/include/alibabacloud/address-purification/model/GetAddressGeocodeResult.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_GETADDRESSGEOCODERESULT_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSGEOCODERESULT_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 GetAddressGeocodeResult : public ServiceResult
{
public:
GetAddressGeocodeResult();
explicit GetAddressGeocodeResult(const std::string &payload);
~GetAddressGeocodeResult();
std::string getData()const;
protected:
void parse(const std::string &payload);
private:
std::string data_;
};
}
}
}
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSGEOCODERESULT_H_

63
address-purification/include/alibabacloud/address-purification/model/GetAddressSearchRequest.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_GETADDRESSSEARCHREQUEST_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSSEARCHREQUEST_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 GetAddressSearchRequest : public RpcServiceRequest
{
public:
GetAddressSearchRequest();
~GetAddressSearchRequest();
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_GETADDRESSSEARCHREQUEST_H_

51
address-purification/include/alibabacloud/address-purification/model/GetAddressSearchResult.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_GETADDRESSSEARCHRESULT_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSSEARCHRESULT_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 GetAddressSearchResult : public ServiceResult
{
public:
GetAddressSearchResult();
explicit GetAddressSearchResult(const std::string &payload);
~GetAddressSearchResult();
std::string getData()const;
protected:
void parse(const std::string &payload);
private:
std::string data_;
};
}
}
}
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSSEARCHRESULT_H_

63
address-purification/include/alibabacloud/address-purification/model/GetInputSearchRequest.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_GETINPUTSEARCHREQUEST_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETINPUTSEARCHREQUEST_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 GetInputSearchRequest : public RpcServiceRequest
{
public:
GetInputSearchRequest();
~GetInputSearchRequest();
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_GETINPUTSEARCHREQUEST_H_

51
address-purification/include/alibabacloud/address-purification/model/GetInputSearchResult.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_GETINPUTSEARCHRESULT_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETINPUTSEARCHRESULT_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 GetInputSearchResult : public ServiceResult
{
public:
GetInputSearchResult();
explicit GetInputSearchResult(const std::string &payload);
~GetInputSearchResult();
std::string getData()const;
protected:
void parse(const std::string &payload);
private:
std::string data_;
};
}
}
}
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETINPUTSEARCHRESULT_H_

63
address-purification/include/alibabacloud/address-purification/model/PredictPOIRequest.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_PREDICTPOIREQUEST_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_PREDICTPOIREQUEST_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 PredictPOIRequest : public RpcServiceRequest
{
public:
PredictPOIRequest();
~PredictPOIRequest();
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_PREDICTPOIREQUEST_H_

51
address-purification/include/alibabacloud/address-purification/model/PredictPOIResult.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_PREDICTPOIRESULT_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_PREDICTPOIRESULT_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 PredictPOIResult : public ServiceResult
{
public:
PredictPOIResult();
explicit PredictPOIResult(const std::string &payload);
~PredictPOIResult();
std::string getData()const;
protected:
void parse(const std::string &payload);
private:
std::string data_;
};
}
}
}
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_PREDICTPOIRESULT_H_

66
address-purification/include/alibabacloud/address-purification/model/TransferCoordRequest.h Normal file
View File

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

51
address-purification/include/alibabacloud/address-purification/model/TransferCoordResult.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_TRANSFERCOORDRESULT_H_
#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_TRANSFERCOORDRESULT_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 TransferCoordResult : public ServiceResult
{
public:
TransferCoordResult();
explicit TransferCoordResult(const std::string &payload);
~TransferCoordResult();
std::string getData()const;
protected:
void parse(const std::string &payload);
private:
std::string data_;
};
}
}
}
#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_TRANSFERCOORDRESULT_H_

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

@@ -195,6 +195,42 @@ Address_purificationClient::ExtractAddressOutcomeCallable Address_purificationCl
return task->get_future();
}
Address_purificationClient::ExtractExpressOutcome Address_purificationClient::extractExpress(const ExtractExpressRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ExtractExpressOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ExtractExpressOutcome(ExtractExpressResult(outcome.result()));
else
return ExtractExpressOutcome(outcome.error());
}
void Address_purificationClient::extractExpressAsync(const ExtractExpressRequest& request, const ExtractExpressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, extractExpress(request), context);
};
asyncExecute(new Runnable(fn));
}
Address_purificationClient::ExtractExpressOutcomeCallable Address_purificationClient::extractExpressCallable(const ExtractExpressRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ExtractExpressOutcome()>>(
[this, request]()
{
return this->extractExpress(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Address_purificationClient::ExtractNameOutcome Address_purificationClient::extractName(const ExtractNameRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -267,6 +303,42 @@ Address_purificationClient::ExtractPhoneOutcomeCallable Address_purificationClie
return task->get_future();
}
Address_purificationClient::GetAddressBlockMappingOutcome Address_purificationClient::getAddressBlockMapping(const GetAddressBlockMappingRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetAddressBlockMappingOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetAddressBlockMappingOutcome(GetAddressBlockMappingResult(outcome.result()));
else
return GetAddressBlockMappingOutcome(outcome.error());
}
void Address_purificationClient::getAddressBlockMappingAsync(const GetAddressBlockMappingRequest& request, const GetAddressBlockMappingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getAddressBlockMapping(request), context);
};
asyncExecute(new Runnable(fn));
}
Address_purificationClient::GetAddressBlockMappingOutcomeCallable Address_purificationClient::getAddressBlockMappingCallable(const GetAddressBlockMappingRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetAddressBlockMappingOutcome()>>(
[this, request]()
{
return this->getAddressBlockMapping(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Address_purificationClient::GetAddressDivisionCodeOutcome Address_purificationClient::getAddressDivisionCode(const GetAddressDivisionCodeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -303,6 +375,114 @@ Address_purificationClient::GetAddressDivisionCodeOutcomeCallable Address_purifi
return task->get_future();
}
Address_purificationClient::GetAddressEvaluateOutcome Address_purificationClient::getAddressEvaluate(const GetAddressEvaluateRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetAddressEvaluateOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetAddressEvaluateOutcome(GetAddressEvaluateResult(outcome.result()));
else
return GetAddressEvaluateOutcome(outcome.error());
}
void Address_purificationClient::getAddressEvaluateAsync(const GetAddressEvaluateRequest& request, const GetAddressEvaluateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getAddressEvaluate(request), context);
};
asyncExecute(new Runnable(fn));
}
Address_purificationClient::GetAddressEvaluateOutcomeCallable Address_purificationClient::getAddressEvaluateCallable(const GetAddressEvaluateRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetAddressEvaluateOutcome()>>(
[this, request]()
{
return this->getAddressEvaluate(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Address_purificationClient::GetAddressGeocodeOutcome Address_purificationClient::getAddressGeocode(const GetAddressGeocodeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetAddressGeocodeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetAddressGeocodeOutcome(GetAddressGeocodeResult(outcome.result()));
else
return GetAddressGeocodeOutcome(outcome.error());
}
void Address_purificationClient::getAddressGeocodeAsync(const GetAddressGeocodeRequest& request, const GetAddressGeocodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getAddressGeocode(request), context);
};
asyncExecute(new Runnable(fn));
}
Address_purificationClient::GetAddressGeocodeOutcomeCallable Address_purificationClient::getAddressGeocodeCallable(const GetAddressGeocodeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetAddressGeocodeOutcome()>>(
[this, request]()
{
return this->getAddressGeocode(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Address_purificationClient::GetAddressSearchOutcome Address_purificationClient::getAddressSearch(const GetAddressSearchRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetAddressSearchOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetAddressSearchOutcome(GetAddressSearchResult(outcome.result()));
else
return GetAddressSearchOutcome(outcome.error());
}
void Address_purificationClient::getAddressSearchAsync(const GetAddressSearchRequest& request, const GetAddressSearchAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getAddressSearch(request), context);
};
asyncExecute(new Runnable(fn));
}
Address_purificationClient::GetAddressSearchOutcomeCallable Address_purificationClient::getAddressSearchCallable(const GetAddressSearchRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetAddressSearchOutcome()>>(
[this, request]()
{
return this->getAddressSearch(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Address_purificationClient::GetAddressSimilarityOutcome Address_purificationClient::getAddressSimilarity(const GetAddressSimilarityRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -339,6 +519,42 @@ Address_purificationClient::GetAddressSimilarityOutcomeCallable Address_purifica
return task->get_future();
}
Address_purificationClient::GetInputSearchOutcome Address_purificationClient::getInputSearch(const GetInputSearchRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetInputSearchOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetInputSearchOutcome(GetInputSearchResult(outcome.result()));
else
return GetInputSearchOutcome(outcome.error());
}
void Address_purificationClient::getInputSearchAsync(const GetInputSearchRequest& request, const GetInputSearchAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getInputSearch(request), context);
};
asyncExecute(new Runnable(fn));
}
Address_purificationClient::GetInputSearchOutcomeCallable Address_purificationClient::getInputSearchCallable(const GetInputSearchRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetInputSearchOutcome()>>(
[this, request]()
{
return this->getInputSearch(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Address_purificationClient::GetZipcodeOutcome Address_purificationClient::getZipcode(const GetZipcodeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -375,6 +591,42 @@ Address_purificationClient::GetZipcodeOutcomeCallable Address_purificationClient
return task->get_future();
}
Address_purificationClient::PredictPOIOutcome Address_purificationClient::predictPOI(const PredictPOIRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return PredictPOIOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return PredictPOIOutcome(PredictPOIResult(outcome.result()));
else
return PredictPOIOutcome(outcome.error());
}
void Address_purificationClient::predictPOIAsync(const PredictPOIRequest& request, const PredictPOIAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, predictPOI(request), context);
};
asyncExecute(new Runnable(fn));
}
Address_purificationClient::PredictPOIOutcomeCallable Address_purificationClient::predictPOICallable(const PredictPOIRequest &request) const
{
auto task = std::make_shared<std::packaged_task<PredictPOIOutcome()>>(
[this, request]()
{
return this->predictPOI(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Address_purificationClient::StructureAddressOutcome Address_purificationClient::structureAddress(const StructureAddressRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -411,6 +663,42 @@ Address_purificationClient::StructureAddressOutcomeCallable Address_purification
return task->get_future();
}
Address_purificationClient::TransferCoordOutcome Address_purificationClient::transferCoord(const TransferCoordRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return TransferCoordOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return TransferCoordOutcome(TransferCoordResult(outcome.result()));
else
return TransferCoordOutcome(outcome.error());
}
void Address_purificationClient::transferCoordAsync(const TransferCoordRequest& request, const TransferCoordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, transferCoord(request), context);
};
asyncExecute(new Runnable(fn));
}
Address_purificationClient::TransferCoordOutcomeCallable Address_purificationClient::transferCoordCallable(const TransferCoordRequest &request) const
{
auto task = std::make_shared<std::packaged_task<TransferCoordOutcome()>>(
[this, request]()
{
return this->transferCoord(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Address_purificationClient::UpdateProjectOutcome Address_purificationClient::updateProject(const UpdateProjectRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

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

51
address-purification/src/model/ExtractExpressResult.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/ExtractExpressResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Address_purification;
using namespace AlibabaCloud::Address_purification::Model;
ExtractExpressResult::ExtractExpressResult() :
ServiceResult()
{}
ExtractExpressResult::ExtractExpressResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ExtractExpressResult::~ExtractExpressResult()
{}
void ExtractExpressResult::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 ExtractExpressResult::getData()const
{
return data_;
}

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

51
address-purification/src/model/GetAddressBlockMappingResult.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/GetAddressBlockMappingResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Address_purification;
using namespace AlibabaCloud::Address_purification::Model;
GetAddressBlockMappingResult::GetAddressBlockMappingResult() :
ServiceResult()
{}
GetAddressBlockMappingResult::GetAddressBlockMappingResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetAddressBlockMappingResult::~GetAddressBlockMappingResult()
{}
void GetAddressBlockMappingResult::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 GetAddressBlockMappingResult::getData()const
{
return data_;
}

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

51
address-purification/src/model/GetAddressEvaluateResult.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/GetAddressEvaluateResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Address_purification;
using namespace AlibabaCloud::Address_purification::Model;
GetAddressEvaluateResult::GetAddressEvaluateResult() :
ServiceResult()
{}
GetAddressEvaluateResult::GetAddressEvaluateResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetAddressEvaluateResult::~GetAddressEvaluateResult()
{}
void GetAddressEvaluateResult::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 GetAddressEvaluateResult::getData()const
{
return data_;
}

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

51
address-purification/src/model/GetAddressGeocodeResult.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/GetAddressGeocodeResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Address_purification;
using namespace AlibabaCloud::Address_purification::Model;
GetAddressGeocodeResult::GetAddressGeocodeResult() :
ServiceResult()
{}
GetAddressGeocodeResult::GetAddressGeocodeResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetAddressGeocodeResult::~GetAddressGeocodeResult()
{}
void GetAddressGeocodeResult::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 GetAddressGeocodeResult::getData()const
{
return data_;
}

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

51
address-purification/src/model/GetAddressSearchResult.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/GetAddressSearchResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Address_purification;
using namespace AlibabaCloud::Address_purification::Model;
GetAddressSearchResult::GetAddressSearchResult() :
ServiceResult()
{}
GetAddressSearchResult::GetAddressSearchResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetAddressSearchResult::~GetAddressSearchResult()
{}
void GetAddressSearchResult::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 GetAddressSearchResult::getData()const
{
return data_;
}

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

51
address-purification/src/model/GetInputSearchResult.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/GetInputSearchResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Address_purification;
using namespace AlibabaCloud::Address_purification::Model;
GetInputSearchResult::GetInputSearchResult() :
ServiceResult()
{}
GetInputSearchResult::GetInputSearchResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetInputSearchResult::~GetInputSearchResult()
{}
void GetInputSearchResult::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 GetInputSearchResult::getData()const
{
return data_;
}

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

51
address-purification/src/model/PredictPOIResult.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/PredictPOIResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Address_purification;
using namespace AlibabaCloud::Address_purification::Model;
PredictPOIResult::PredictPOIResult() :
ServiceResult()
{}
PredictPOIResult::PredictPOIResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
PredictPOIResult::~PredictPOIResult()
{}
void PredictPOIResult::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 PredictPOIResult::getData()const
{
return data_;
}

106
address-purification/src/model/TransferCoordRequest.cc Normal file
View File

@@ -0,0 +1,106 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/address-purification/model/TransferCoordRequest.h>
using AlibabaCloud::Address_purification::Model::TransferCoordRequest;
TransferCoordRequest::TransferCoordRequest() :
RpcServiceRequest("address-purification", "2019-11-18", "TransferCoord")
{
setMethod(HttpRequest::Method::Post);
}
TransferCoordRequest::~TransferCoordRequest()
{}
std::string TransferCoordRequest::getDefaultProvince()const
{
return defaultProvince_;
}
void TransferCoordRequest::setDefaultProvince(const std::string& defaultProvince)
{
defaultProvince_ = defaultProvince;
setBodyParameter("DefaultProvince", defaultProvince);
}
std::string TransferCoordRequest::getSrcCoord()const
{
return srcCoord_;
}
void TransferCoordRequest::setSrcCoord(const std::string& srcCoord)
{
srcCoord_ = srcCoord;
setBodyParameter("SrcCoord", srcCoord);
}
std::string TransferCoordRequest::getDefaultCity()const
{
return defaultCity_;
}
void TransferCoordRequest::setDefaultCity(const std::string& defaultCity)
{
defaultCity_ = defaultCity;
setBodyParameter("DefaultCity", defaultCity);
}
std::string TransferCoordRequest::getText()const
{
return text_;
}
void TransferCoordRequest::setText(const std::string& text)
{
text_ = text;
setBodyParameter("Text", text);
}
std::string TransferCoordRequest::getServiceCode()const
{
return serviceCode_;
}
void TransferCoordRequest::setServiceCode(const std::string& serviceCode)
{
serviceCode_ = serviceCode;
setBodyParameter("ServiceCode", serviceCode);
}
std::string TransferCoordRequest::getDefaultDistrict()const
{
return defaultDistrict_;
}
void TransferCoordRequest::setDefaultDistrict(const std::string& defaultDistrict)
{
defaultDistrict_ = defaultDistrict;
setBodyParameter("DefaultDistrict", defaultDistrict);
}
std::string TransferCoordRequest::getAppKey()const
{
return appKey_;
}
void TransferCoordRequest::setAppKey(const std::string& appKey)
{
appKey_ = appKey;
setBodyParameter("AppKey", appKey);
}

51
address-purification/src/model/TransferCoordResult.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/TransferCoordResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Address_purification;
using namespace AlibabaCloud::Address_purification::Model;
TransferCoordResult::TransferCoordResult() :
ServiceResult()
{}
TransferCoordResult::TransferCoordResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
TransferCoordResult::~TransferCoordResult()
{}
void TransferCoordResult::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 TransferCoordResult::getData()const
{
return data_;
}