由尛宏发起的GREEN SDK自动发布, 版本号:1.5.0

Signed-off-by: haowei.yao <haowei.yao@alibaba-inc.com>
This commit is contained in:
haowei.yao
2018-04-08 16:20:52 +08:00
parent c3794202f0
commit 4fa1912a54
107 changed files with 6087 additions and 2 deletions

182
green/CMakeLists.txt Normal file
View File

@@ -0,0 +1,182 @@
#
# 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.
#
set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include)
set(green_public_header
include/alibabacloud/green/GreenClient.h
include/alibabacloud/green/GreenExport.h )
set(green_public_header_model
include/alibabacloud/green/model/ImageSyncScanRequest.h
include/alibabacloud/green/model/ImageSyncScanResult.h
include/alibabacloud/green/model/GetPersonsRequest.h
include/alibabacloud/green/model/GetPersonsResult.h
include/alibabacloud/green/model/GetPersonRequest.h
include/alibabacloud/green/model/GetPersonResult.h
include/alibabacloud/green/model/DeleteFacesRequest.h
include/alibabacloud/green/model/DeleteFacesResult.h
include/alibabacloud/green/model/VideoFeedbackRequest.h
include/alibabacloud/green/model/VideoFeedbackResult.h
include/alibabacloud/green/model/DeletePersonRequest.h
include/alibabacloud/green/model/DeletePersonResult.h
include/alibabacloud/green/model/VideoAsyncScanResultsRequest.h
include/alibabacloud/green/model/VideoAsyncScanResultsResult.h
include/alibabacloud/green/model/AddGroupsRequest.h
include/alibabacloud/green/model/AddGroupsResult.h
include/alibabacloud/green/model/FileAsyncScanRequest.h
include/alibabacloud/green/model/FileAsyncScanResult.h
include/alibabacloud/green/model/SetPersonRequest.h
include/alibabacloud/green/model/SetPersonResult.h
include/alibabacloud/green/model/TextFeedbackRequest.h
include/alibabacloud/green/model/TextFeedbackResult.h
include/alibabacloud/green/model/SearchRequest.h
include/alibabacloud/green/model/SearchResult.h
include/alibabacloud/green/model/FileAsyncScanResultsRequest.h
include/alibabacloud/green/model/FileAsyncScanResultsResult.h
include/alibabacloud/green/model/DeleteGroupsRequest.h
include/alibabacloud/green/model/DeleteGroupsResult.h
include/alibabacloud/green/model/ImageAsyncScanRequest.h
include/alibabacloud/green/model/ImageAsyncScanResult.h
include/alibabacloud/green/model/VideoAsyncScanRequest.h
include/alibabacloud/green/model/VideoAsyncScanResult.h
include/alibabacloud/green/model/ImageAsyncScanResultsRequest.h
include/alibabacloud/green/model/ImageAsyncScanResultsResult.h
include/alibabacloud/green/model/VoiceAsyncScanResultsRequest.h
include/alibabacloud/green/model/VoiceAsyncScanResultsResult.h
include/alibabacloud/green/model/GetFacesRequest.h
include/alibabacloud/green/model/GetFacesResult.h
include/alibabacloud/green/model/VoiceAsyncScanRequest.h
include/alibabacloud/green/model/VoiceAsyncScanResult.h
include/alibabacloud/green/model/GetGroupsRequest.h
include/alibabacloud/green/model/GetGroupsResult.h
include/alibabacloud/green/model/TextScanRequest.h
include/alibabacloud/green/model/TextScanResult.h
include/alibabacloud/green/model/ImageScanFeedbackRequest.h
include/alibabacloud/green/model/ImageScanFeedbackResult.h
include/alibabacloud/green/model/AddPersonRequest.h
include/alibabacloud/green/model/AddPersonResult.h
include/alibabacloud/green/model/AddFacesRequest.h
include/alibabacloud/green/model/AddFacesResult.h )
set(green_src
src/GreenClient.cc
src/model/ImageSyncScanRequest.cc
src/model/ImageSyncScanResult.cc
src/model/GetPersonsRequest.cc
src/model/GetPersonsResult.cc
src/model/GetPersonRequest.cc
src/model/GetPersonResult.cc
src/model/DeleteFacesRequest.cc
src/model/DeleteFacesResult.cc
src/model/VideoFeedbackRequest.cc
src/model/VideoFeedbackResult.cc
src/model/DeletePersonRequest.cc
src/model/DeletePersonResult.cc
src/model/VideoAsyncScanResultsRequest.cc
src/model/VideoAsyncScanResultsResult.cc
src/model/AddGroupsRequest.cc
src/model/AddGroupsResult.cc
src/model/FileAsyncScanRequest.cc
src/model/FileAsyncScanResult.cc
src/model/SetPersonRequest.cc
src/model/SetPersonResult.cc
src/model/TextFeedbackRequest.cc
src/model/TextFeedbackResult.cc
src/model/SearchRequest.cc
src/model/SearchResult.cc
src/model/FileAsyncScanResultsRequest.cc
src/model/FileAsyncScanResultsResult.cc
src/model/DeleteGroupsRequest.cc
src/model/DeleteGroupsResult.cc
src/model/ImageAsyncScanRequest.cc
src/model/ImageAsyncScanResult.cc
src/model/VideoAsyncScanRequest.cc
src/model/VideoAsyncScanResult.cc
src/model/ImageAsyncScanResultsRequest.cc
src/model/ImageAsyncScanResultsResult.cc
src/model/VoiceAsyncScanResultsRequest.cc
src/model/VoiceAsyncScanResultsResult.cc
src/model/GetFacesRequest.cc
src/model/GetFacesResult.cc
src/model/VoiceAsyncScanRequest.cc
src/model/VoiceAsyncScanResult.cc
src/model/GetGroupsRequest.cc
src/model/GetGroupsResult.cc
src/model/TextScanRequest.cc
src/model/TextScanResult.cc
src/model/ImageScanFeedbackRequest.cc
src/model/ImageScanFeedbackResult.cc
src/model/AddPersonRequest.cc
src/model/AddPersonResult.cc
src/model/AddFacesRequest.cc
src/model/AddFacesResult.cc )
add_library(green ${LIB_TYPE}
${green_public_header}
${green_public_header_model}
${green_src})
set_target_properties(green
PROPERTIES
LINKER_LANGUAGE CXX
ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
OUTPUT_NAME ${TARGET_OUTPUT_NAME_PREFIX}green
)
if(${LIB_TYPE} STREQUAL "SHARED")
set_target_properties(green
PROPERTIES
DEFINE_SYMBOL ALIBABACLOUD_GREEN_LIBRARY)
endif()
target_include_directories(green
PRIVATE include
${CMAKE_SOURCE_DIR}/core/include
)
target_link_libraries(green
core)
if(CMAKE_HOST_WIN32)
ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
set(jsoncpp_install_dir ${INSTALL_DIR})
add_dependencies(green
jsoncpp)
target_include_directories(green
PRIVATE ${jsoncpp_install_dir}/include)
target_link_libraries(green
${jsoncpp_install_dir}/lib/jsoncpp.lib)
set_target_properties(green
PROPERTIES
COMPILE_OPTIONS "/bigobj")
else()
target_include_directories(green
PRIVATE /usr/include/jsoncpp)
target_link_libraries(green
jsoncpp)
endif()
install(FILES ${green_public_header}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/green)
install(FILES ${green_public_header_model}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/green/model)
install(TARGETS green
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)

View File

@@ -0,0 +1,246 @@
/*
* 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_GREEN_GREENCLIENT_H_
#define ALIBABACLOUD_GREEN_GREENCLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RoaServiceClient.h>
#include "GreenExport.h"
#include "model/ImageSyncScanRequest.h"
#include "model/ImageSyncScanResult.h"
#include "model/GetPersonsRequest.h"
#include "model/GetPersonsResult.h"
#include "model/GetPersonRequest.h"
#include "model/GetPersonResult.h"
#include "model/DeleteFacesRequest.h"
#include "model/DeleteFacesResult.h"
#include "model/VideoFeedbackRequest.h"
#include "model/VideoFeedbackResult.h"
#include "model/DeletePersonRequest.h"
#include "model/DeletePersonResult.h"
#include "model/VideoAsyncScanResultsRequest.h"
#include "model/VideoAsyncScanResultsResult.h"
#include "model/AddGroupsRequest.h"
#include "model/AddGroupsResult.h"
#include "model/FileAsyncScanRequest.h"
#include "model/FileAsyncScanResult.h"
#include "model/SetPersonRequest.h"
#include "model/SetPersonResult.h"
#include "model/TextFeedbackRequest.h"
#include "model/TextFeedbackResult.h"
#include "model/SearchRequest.h"
#include "model/SearchResult.h"
#include "model/FileAsyncScanResultsRequest.h"
#include "model/FileAsyncScanResultsResult.h"
#include "model/DeleteGroupsRequest.h"
#include "model/DeleteGroupsResult.h"
#include "model/ImageAsyncScanRequest.h"
#include "model/ImageAsyncScanResult.h"
#include "model/VideoAsyncScanRequest.h"
#include "model/VideoAsyncScanResult.h"
#include "model/ImageAsyncScanResultsRequest.h"
#include "model/ImageAsyncScanResultsResult.h"
#include "model/VoiceAsyncScanResultsRequest.h"
#include "model/VoiceAsyncScanResultsResult.h"
#include "model/GetFacesRequest.h"
#include "model/GetFacesResult.h"
#include "model/VoiceAsyncScanRequest.h"
#include "model/VoiceAsyncScanResult.h"
#include "model/GetGroupsRequest.h"
#include "model/GetGroupsResult.h"
#include "model/TextScanRequest.h"
#include "model/TextScanResult.h"
#include "model/ImageScanFeedbackRequest.h"
#include "model/ImageScanFeedbackResult.h"
#include "model/AddPersonRequest.h"
#include "model/AddPersonResult.h"
#include "model/AddFacesRequest.h"
#include "model/AddFacesResult.h"
namespace AlibabaCloud
{
namespace Green
{
class ALIBABACLOUD_GREEN_EXPORT GreenClient : public RoaServiceClient
{
public:
typedef Outcome<Error, Model::ImageSyncScanResult> ImageSyncScanOutcome;
typedef std::future<ImageSyncScanOutcome> ImageSyncScanOutcomeCallable;
typedef std::function<void(const GreenClient*, const Model::ImageSyncScanRequest&, const ImageSyncScanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ImageSyncScanAsyncHandler;
typedef Outcome<Error, Model::GetPersonsResult> GetPersonsOutcome;
typedef std::future<GetPersonsOutcome> GetPersonsOutcomeCallable;
typedef std::function<void(const GreenClient*, const Model::GetPersonsRequest&, const GetPersonsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetPersonsAsyncHandler;
typedef Outcome<Error, Model::GetPersonResult> GetPersonOutcome;
typedef std::future<GetPersonOutcome> GetPersonOutcomeCallable;
typedef std::function<void(const GreenClient*, const Model::GetPersonRequest&, const GetPersonOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetPersonAsyncHandler;
typedef Outcome<Error, Model::DeleteFacesResult> DeleteFacesOutcome;
typedef std::future<DeleteFacesOutcome> DeleteFacesOutcomeCallable;
typedef std::function<void(const GreenClient*, const Model::DeleteFacesRequest&, const DeleteFacesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteFacesAsyncHandler;
typedef Outcome<Error, Model::VideoFeedbackResult> VideoFeedbackOutcome;
typedef std::future<VideoFeedbackOutcome> VideoFeedbackOutcomeCallable;
typedef std::function<void(const GreenClient*, const Model::VideoFeedbackRequest&, const VideoFeedbackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> VideoFeedbackAsyncHandler;
typedef Outcome<Error, Model::DeletePersonResult> DeletePersonOutcome;
typedef std::future<DeletePersonOutcome> DeletePersonOutcomeCallable;
typedef std::function<void(const GreenClient*, const Model::DeletePersonRequest&, const DeletePersonOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeletePersonAsyncHandler;
typedef Outcome<Error, Model::VideoAsyncScanResultsResult> VideoAsyncScanResultsOutcome;
typedef std::future<VideoAsyncScanResultsOutcome> VideoAsyncScanResultsOutcomeCallable;
typedef std::function<void(const GreenClient*, const Model::VideoAsyncScanResultsRequest&, const VideoAsyncScanResultsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> VideoAsyncScanResultsAsyncHandler;
typedef Outcome<Error, Model::AddGroupsResult> AddGroupsOutcome;
typedef std::future<AddGroupsOutcome> AddGroupsOutcomeCallable;
typedef std::function<void(const GreenClient*, const Model::AddGroupsRequest&, const AddGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddGroupsAsyncHandler;
typedef Outcome<Error, Model::FileAsyncScanResult> FileAsyncScanOutcome;
typedef std::future<FileAsyncScanOutcome> FileAsyncScanOutcomeCallable;
typedef std::function<void(const GreenClient*, const Model::FileAsyncScanRequest&, const FileAsyncScanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> FileAsyncScanAsyncHandler;
typedef Outcome<Error, Model::SetPersonResult> SetPersonOutcome;
typedef std::future<SetPersonOutcome> SetPersonOutcomeCallable;
typedef std::function<void(const GreenClient*, const Model::SetPersonRequest&, const SetPersonOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetPersonAsyncHandler;
typedef Outcome<Error, Model::TextFeedbackResult> TextFeedbackOutcome;
typedef std::future<TextFeedbackOutcome> TextFeedbackOutcomeCallable;
typedef std::function<void(const GreenClient*, const Model::TextFeedbackRequest&, const TextFeedbackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TextFeedbackAsyncHandler;
typedef Outcome<Error, Model::SearchResult> SearchOutcome;
typedef std::future<SearchOutcome> SearchOutcomeCallable;
typedef std::function<void(const GreenClient*, const Model::SearchRequest&, const SearchOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SearchAsyncHandler;
typedef Outcome<Error, Model::FileAsyncScanResultsResult> FileAsyncScanResultsOutcome;
typedef std::future<FileAsyncScanResultsOutcome> FileAsyncScanResultsOutcomeCallable;
typedef std::function<void(const GreenClient*, const Model::FileAsyncScanResultsRequest&, const FileAsyncScanResultsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> FileAsyncScanResultsAsyncHandler;
typedef Outcome<Error, Model::DeleteGroupsResult> DeleteGroupsOutcome;
typedef std::future<DeleteGroupsOutcome> DeleteGroupsOutcomeCallable;
typedef std::function<void(const GreenClient*, const Model::DeleteGroupsRequest&, const DeleteGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteGroupsAsyncHandler;
typedef Outcome<Error, Model::ImageAsyncScanResult> ImageAsyncScanOutcome;
typedef std::future<ImageAsyncScanOutcome> ImageAsyncScanOutcomeCallable;
typedef std::function<void(const GreenClient*, const Model::ImageAsyncScanRequest&, const ImageAsyncScanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ImageAsyncScanAsyncHandler;
typedef Outcome<Error, Model::VideoAsyncScanResult> VideoAsyncScanOutcome;
typedef std::future<VideoAsyncScanOutcome> VideoAsyncScanOutcomeCallable;
typedef std::function<void(const GreenClient*, const Model::VideoAsyncScanRequest&, const VideoAsyncScanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> VideoAsyncScanAsyncHandler;
typedef Outcome<Error, Model::ImageAsyncScanResultsResult> ImageAsyncScanResultsOutcome;
typedef std::future<ImageAsyncScanResultsOutcome> ImageAsyncScanResultsOutcomeCallable;
typedef std::function<void(const GreenClient*, const Model::ImageAsyncScanResultsRequest&, const ImageAsyncScanResultsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ImageAsyncScanResultsAsyncHandler;
typedef Outcome<Error, Model::VoiceAsyncScanResultsResult> VoiceAsyncScanResultsOutcome;
typedef std::future<VoiceAsyncScanResultsOutcome> VoiceAsyncScanResultsOutcomeCallable;
typedef std::function<void(const GreenClient*, const Model::VoiceAsyncScanResultsRequest&, const VoiceAsyncScanResultsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> VoiceAsyncScanResultsAsyncHandler;
typedef Outcome<Error, Model::GetFacesResult> GetFacesOutcome;
typedef std::future<GetFacesOutcome> GetFacesOutcomeCallable;
typedef std::function<void(const GreenClient*, const Model::GetFacesRequest&, const GetFacesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetFacesAsyncHandler;
typedef Outcome<Error, Model::VoiceAsyncScanResult> VoiceAsyncScanOutcome;
typedef std::future<VoiceAsyncScanOutcome> VoiceAsyncScanOutcomeCallable;
typedef std::function<void(const GreenClient*, const Model::VoiceAsyncScanRequest&, const VoiceAsyncScanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> VoiceAsyncScanAsyncHandler;
typedef Outcome<Error, Model::GetGroupsResult> GetGroupsOutcome;
typedef std::future<GetGroupsOutcome> GetGroupsOutcomeCallable;
typedef std::function<void(const GreenClient*, const Model::GetGroupsRequest&, const GetGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetGroupsAsyncHandler;
typedef Outcome<Error, Model::TextScanResult> TextScanOutcome;
typedef std::future<TextScanOutcome> TextScanOutcomeCallable;
typedef std::function<void(const GreenClient*, const Model::TextScanRequest&, const TextScanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TextScanAsyncHandler;
typedef Outcome<Error, Model::ImageScanFeedbackResult> ImageScanFeedbackOutcome;
typedef std::future<ImageScanFeedbackOutcome> ImageScanFeedbackOutcomeCallable;
typedef std::function<void(const GreenClient*, const Model::ImageScanFeedbackRequest&, const ImageScanFeedbackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ImageScanFeedbackAsyncHandler;
typedef Outcome<Error, Model::AddPersonResult> AddPersonOutcome;
typedef std::future<AddPersonOutcome> AddPersonOutcomeCallable;
typedef std::function<void(const GreenClient*, const Model::AddPersonRequest&, const AddPersonOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddPersonAsyncHandler;
typedef Outcome<Error, Model::AddFacesResult> AddFacesOutcome;
typedef std::future<AddFacesOutcome> AddFacesOutcomeCallable;
typedef std::function<void(const GreenClient*, const Model::AddFacesRequest&, const AddFacesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddFacesAsyncHandler;
GreenClient(const Credentials &credentials, const ClientConfiguration &configuration);
GreenClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
GreenClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~GreenClient();
ImageSyncScanOutcome imageSyncScan(const Model::ImageSyncScanRequest &request)const;
void imageSyncScanAsync(const Model::ImageSyncScanRequest& request, const ImageSyncScanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ImageSyncScanOutcomeCallable imageSyncScanCallable(const Model::ImageSyncScanRequest& request) const;
GetPersonsOutcome getPersons(const Model::GetPersonsRequest &request)const;
void getPersonsAsync(const Model::GetPersonsRequest& request, const GetPersonsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetPersonsOutcomeCallable getPersonsCallable(const Model::GetPersonsRequest& request) const;
GetPersonOutcome getPerson(const Model::GetPersonRequest &request)const;
void getPersonAsync(const Model::GetPersonRequest& request, const GetPersonAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetPersonOutcomeCallable getPersonCallable(const Model::GetPersonRequest& request) const;
DeleteFacesOutcome deleteFaces(const Model::DeleteFacesRequest &request)const;
void deleteFacesAsync(const Model::DeleteFacesRequest& request, const DeleteFacesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteFacesOutcomeCallable deleteFacesCallable(const Model::DeleteFacesRequest& request) const;
VideoFeedbackOutcome videoFeedback(const Model::VideoFeedbackRequest &request)const;
void videoFeedbackAsync(const Model::VideoFeedbackRequest& request, const VideoFeedbackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
VideoFeedbackOutcomeCallable videoFeedbackCallable(const Model::VideoFeedbackRequest& request) const;
DeletePersonOutcome deletePerson(const Model::DeletePersonRequest &request)const;
void deletePersonAsync(const Model::DeletePersonRequest& request, const DeletePersonAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeletePersonOutcomeCallable deletePersonCallable(const Model::DeletePersonRequest& request) const;
VideoAsyncScanResultsOutcome videoAsyncScanResults(const Model::VideoAsyncScanResultsRequest &request)const;
void videoAsyncScanResultsAsync(const Model::VideoAsyncScanResultsRequest& request, const VideoAsyncScanResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
VideoAsyncScanResultsOutcomeCallable videoAsyncScanResultsCallable(const Model::VideoAsyncScanResultsRequest& request) const;
AddGroupsOutcome addGroups(const Model::AddGroupsRequest &request)const;
void addGroupsAsync(const Model::AddGroupsRequest& request, const AddGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddGroupsOutcomeCallable addGroupsCallable(const Model::AddGroupsRequest& request) const;
FileAsyncScanOutcome fileAsyncScan(const Model::FileAsyncScanRequest &request)const;
void fileAsyncScanAsync(const Model::FileAsyncScanRequest& request, const FileAsyncScanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
FileAsyncScanOutcomeCallable fileAsyncScanCallable(const Model::FileAsyncScanRequest& request) const;
SetPersonOutcome setPerson(const Model::SetPersonRequest &request)const;
void setPersonAsync(const Model::SetPersonRequest& request, const SetPersonAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetPersonOutcomeCallable setPersonCallable(const Model::SetPersonRequest& request) const;
TextFeedbackOutcome textFeedback(const Model::TextFeedbackRequest &request)const;
void textFeedbackAsync(const Model::TextFeedbackRequest& request, const TextFeedbackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
TextFeedbackOutcomeCallable textFeedbackCallable(const Model::TextFeedbackRequest& request) const;
SearchOutcome search(const Model::SearchRequest &request)const;
void searchAsync(const Model::SearchRequest& request, const SearchAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SearchOutcomeCallable searchCallable(const Model::SearchRequest& request) const;
FileAsyncScanResultsOutcome fileAsyncScanResults(const Model::FileAsyncScanResultsRequest &request)const;
void fileAsyncScanResultsAsync(const Model::FileAsyncScanResultsRequest& request, const FileAsyncScanResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
FileAsyncScanResultsOutcomeCallable fileAsyncScanResultsCallable(const Model::FileAsyncScanResultsRequest& request) const;
DeleteGroupsOutcome deleteGroups(const Model::DeleteGroupsRequest &request)const;
void deleteGroupsAsync(const Model::DeleteGroupsRequest& request, const DeleteGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteGroupsOutcomeCallable deleteGroupsCallable(const Model::DeleteGroupsRequest& request) const;
ImageAsyncScanOutcome imageAsyncScan(const Model::ImageAsyncScanRequest &request)const;
void imageAsyncScanAsync(const Model::ImageAsyncScanRequest& request, const ImageAsyncScanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ImageAsyncScanOutcomeCallable imageAsyncScanCallable(const Model::ImageAsyncScanRequest& request) const;
VideoAsyncScanOutcome videoAsyncScan(const Model::VideoAsyncScanRequest &request)const;
void videoAsyncScanAsync(const Model::VideoAsyncScanRequest& request, const VideoAsyncScanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
VideoAsyncScanOutcomeCallable videoAsyncScanCallable(const Model::VideoAsyncScanRequest& request) const;
ImageAsyncScanResultsOutcome imageAsyncScanResults(const Model::ImageAsyncScanResultsRequest &request)const;
void imageAsyncScanResultsAsync(const Model::ImageAsyncScanResultsRequest& request, const ImageAsyncScanResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ImageAsyncScanResultsOutcomeCallable imageAsyncScanResultsCallable(const Model::ImageAsyncScanResultsRequest& request) const;
VoiceAsyncScanResultsOutcome voiceAsyncScanResults(const Model::VoiceAsyncScanResultsRequest &request)const;
void voiceAsyncScanResultsAsync(const Model::VoiceAsyncScanResultsRequest& request, const VoiceAsyncScanResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
VoiceAsyncScanResultsOutcomeCallable voiceAsyncScanResultsCallable(const Model::VoiceAsyncScanResultsRequest& request) const;
GetFacesOutcome getFaces(const Model::GetFacesRequest &request)const;
void getFacesAsync(const Model::GetFacesRequest& request, const GetFacesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetFacesOutcomeCallable getFacesCallable(const Model::GetFacesRequest& request) const;
VoiceAsyncScanOutcome voiceAsyncScan(const Model::VoiceAsyncScanRequest &request)const;
void voiceAsyncScanAsync(const Model::VoiceAsyncScanRequest& request, const VoiceAsyncScanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
VoiceAsyncScanOutcomeCallable voiceAsyncScanCallable(const Model::VoiceAsyncScanRequest& request) const;
GetGroupsOutcome getGroups(const Model::GetGroupsRequest &request)const;
void getGroupsAsync(const Model::GetGroupsRequest& request, const GetGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetGroupsOutcomeCallable getGroupsCallable(const Model::GetGroupsRequest& request) const;
TextScanOutcome textScan(const Model::TextScanRequest &request)const;
void textScanAsync(const Model::TextScanRequest& request, const TextScanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
TextScanOutcomeCallable textScanCallable(const Model::TextScanRequest& request) const;
ImageScanFeedbackOutcome imageScanFeedback(const Model::ImageScanFeedbackRequest &request)const;
void imageScanFeedbackAsync(const Model::ImageScanFeedbackRequest& request, const ImageScanFeedbackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ImageScanFeedbackOutcomeCallable imageScanFeedbackCallable(const Model::ImageScanFeedbackRequest& request) const;
AddPersonOutcome addPerson(const Model::AddPersonRequest &request)const;
void addPersonAsync(const Model::AddPersonRequest& request, const AddPersonAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddPersonOutcomeCallable addPersonCallable(const Model::AddPersonRequest& request) const;
AddFacesOutcome addFaces(const Model::AddFacesRequest &request)const;
void addFacesAsync(const Model::AddFacesRequest& request, const AddFacesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddFacesOutcomeCallable addFacesCallable(const Model::AddFacesRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_GREEN_GREENCLIENT_H_

View File

@@ -0,0 +1,32 @@
/*
* 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_GREEN_GREENEXPORT_H_
#define ALIBABACLOUD_GREEN_GREENEXPORT_H_
#include <alibabacloud/core/Global.h>
#if defined(ALIBABACLOUD_SHARED)
# if defined(ALIBABACLOUD_GREEN_LIBRARY)
# define ALIBABACLOUD_GREEN_EXPORT ALIBABACLOUD_DECL_EXPORT
# else
# define ALIBABACLOUD_GREEN_EXPORT ALIBABACLOUD_DECL_IMPORT
# endif
#else
# define ALIBABACLOUD_GREEN_EXPORT
#endif
#endif // !ALIBABACLOUD_GREEN_GREENEXPORT_H_

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_GREEN_MODEL_ADDFACESREQUEST_H_
#define ALIBABACLOUD_GREEN_MODEL_ADDFACESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RoaServiceRequest.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT AddFacesRequest : public RoaServiceRequest
{
public:
AddFacesRequest();
~AddFacesRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getClientInfo()const;
void setClientInfo(const std::string& clientInfo);
private:
std::string regionId_;
std::string clientInfo_;
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_ADDFACESREQUEST_H_

View File

@@ -0,0 +1,49 @@
/*
* 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_GREEN_MODEL_ADDFACESRESULT_H_
#define ALIBABACLOUD_GREEN_MODEL_ADDFACESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT AddFacesResult : public ServiceResult
{
public:
AddFacesResult();
explicit AddFacesResult(const std::string &payload);
~AddFacesResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_ADDFACESRESULT_H_

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_GREEN_MODEL_ADDGROUPSREQUEST_H_
#define ALIBABACLOUD_GREEN_MODEL_ADDGROUPSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RoaServiceRequest.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT AddGroupsRequest : public RoaServiceRequest
{
public:
AddGroupsRequest();
~AddGroupsRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getClientInfo()const;
void setClientInfo(const std::string& clientInfo);
private:
std::string regionId_;
std::string clientInfo_;
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_ADDGROUPSREQUEST_H_

View File

@@ -0,0 +1,49 @@
/*
* 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_GREEN_MODEL_ADDGROUPSRESULT_H_
#define ALIBABACLOUD_GREEN_MODEL_ADDGROUPSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT AddGroupsResult : public ServiceResult
{
public:
AddGroupsResult();
explicit AddGroupsResult(const std::string &payload);
~AddGroupsResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_ADDGROUPSRESULT_H_

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_GREEN_MODEL_ADDPERSONREQUEST_H_
#define ALIBABACLOUD_GREEN_MODEL_ADDPERSONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RoaServiceRequest.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT AddPersonRequest : public RoaServiceRequest
{
public:
AddPersonRequest();
~AddPersonRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getClientInfo()const;
void setClientInfo(const std::string& clientInfo);
private:
std::string regionId_;
std::string clientInfo_;
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_ADDPERSONREQUEST_H_

View File

@@ -0,0 +1,49 @@
/*
* 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_GREEN_MODEL_ADDPERSONRESULT_H_
#define ALIBABACLOUD_GREEN_MODEL_ADDPERSONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT AddPersonResult : public ServiceResult
{
public:
AddPersonResult();
explicit AddPersonResult(const std::string &payload);
~AddPersonResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_ADDPERSONRESULT_H_

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_GREEN_MODEL_DELETEFACESREQUEST_H_
#define ALIBABACLOUD_GREEN_MODEL_DELETEFACESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RoaServiceRequest.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT DeleteFacesRequest : public RoaServiceRequest
{
public:
DeleteFacesRequest();
~DeleteFacesRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getClientInfo()const;
void setClientInfo(const std::string& clientInfo);
private:
std::string regionId_;
std::string clientInfo_;
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_DELETEFACESREQUEST_H_

View File

@@ -0,0 +1,49 @@
/*
* 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_GREEN_MODEL_DELETEFACESRESULT_H_
#define ALIBABACLOUD_GREEN_MODEL_DELETEFACESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT DeleteFacesResult : public ServiceResult
{
public:
DeleteFacesResult();
explicit DeleteFacesResult(const std::string &payload);
~DeleteFacesResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_DELETEFACESRESULT_H_

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_GREEN_MODEL_DELETEGROUPSREQUEST_H_
#define ALIBABACLOUD_GREEN_MODEL_DELETEGROUPSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RoaServiceRequest.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT DeleteGroupsRequest : public RoaServiceRequest
{
public:
DeleteGroupsRequest();
~DeleteGroupsRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getClientInfo()const;
void setClientInfo(const std::string& clientInfo);
private:
std::string regionId_;
std::string clientInfo_;
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_DELETEGROUPSREQUEST_H_

View File

@@ -0,0 +1,49 @@
/*
* 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_GREEN_MODEL_DELETEGROUPSRESULT_H_
#define ALIBABACLOUD_GREEN_MODEL_DELETEGROUPSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT DeleteGroupsResult : public ServiceResult
{
public:
DeleteGroupsResult();
explicit DeleteGroupsResult(const std::string &payload);
~DeleteGroupsResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_DELETEGROUPSRESULT_H_

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_GREEN_MODEL_DELETEPERSONREQUEST_H_
#define ALIBABACLOUD_GREEN_MODEL_DELETEPERSONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RoaServiceRequest.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT DeletePersonRequest : public RoaServiceRequest
{
public:
DeletePersonRequest();
~DeletePersonRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getClientInfo()const;
void setClientInfo(const std::string& clientInfo);
private:
std::string regionId_;
std::string clientInfo_;
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_DELETEPERSONREQUEST_H_

View File

@@ -0,0 +1,49 @@
/*
* 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_GREEN_MODEL_DELETEPERSONRESULT_H_
#define ALIBABACLOUD_GREEN_MODEL_DELETEPERSONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT DeletePersonResult : public ServiceResult
{
public:
DeletePersonResult();
explicit DeletePersonResult(const std::string &payload);
~DeletePersonResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_DELETEPERSONRESULT_H_

View File

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

View File

@@ -0,0 +1,49 @@
/*
* 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_GREEN_MODEL_FILEASYNCSCANRESULT_H_
#define ALIBABACLOUD_GREEN_MODEL_FILEASYNCSCANRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT FileAsyncScanResult : public ServiceResult
{
public:
FileAsyncScanResult();
explicit FileAsyncScanResult(const std::string &payload);
~FileAsyncScanResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_FILEASYNCSCANRESULT_H_

View File

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

View File

@@ -0,0 +1,49 @@
/*
* 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_GREEN_MODEL_FILEASYNCSCANRESULTSRESULT_H_
#define ALIBABACLOUD_GREEN_MODEL_FILEASYNCSCANRESULTSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT FileAsyncScanResultsResult : public ServiceResult
{
public:
FileAsyncScanResultsResult();
explicit FileAsyncScanResultsResult(const std::string &payload);
~FileAsyncScanResultsResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_FILEASYNCSCANRESULTSRESULT_H_

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_GREEN_MODEL_GETFACESREQUEST_H_
#define ALIBABACLOUD_GREEN_MODEL_GETFACESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RoaServiceRequest.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT GetFacesRequest : public RoaServiceRequest
{
public:
GetFacesRequest();
~GetFacesRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getClientInfo()const;
void setClientInfo(const std::string& clientInfo);
private:
std::string regionId_;
std::string clientInfo_;
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_GETFACESREQUEST_H_

View File

@@ -0,0 +1,49 @@
/*
* 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_GREEN_MODEL_GETFACESRESULT_H_
#define ALIBABACLOUD_GREEN_MODEL_GETFACESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT GetFacesResult : public ServiceResult
{
public:
GetFacesResult();
explicit GetFacesResult(const std::string &payload);
~GetFacesResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_GETFACESRESULT_H_

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_GREEN_MODEL_GETGROUPSREQUEST_H_
#define ALIBABACLOUD_GREEN_MODEL_GETGROUPSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RoaServiceRequest.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT GetGroupsRequest : public RoaServiceRequest
{
public:
GetGroupsRequest();
~GetGroupsRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getClientInfo()const;
void setClientInfo(const std::string& clientInfo);
private:
std::string regionId_;
std::string clientInfo_;
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_GETGROUPSREQUEST_H_

View File

@@ -0,0 +1,49 @@
/*
* 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_GREEN_MODEL_GETGROUPSRESULT_H_
#define ALIBABACLOUD_GREEN_MODEL_GETGROUPSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT GetGroupsResult : public ServiceResult
{
public:
GetGroupsResult();
explicit GetGroupsResult(const std::string &payload);
~GetGroupsResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_GETGROUPSRESULT_H_

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_GREEN_MODEL_GETPERSONREQUEST_H_
#define ALIBABACLOUD_GREEN_MODEL_GETPERSONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RoaServiceRequest.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT GetPersonRequest : public RoaServiceRequest
{
public:
GetPersonRequest();
~GetPersonRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getClientInfo()const;
void setClientInfo(const std::string& clientInfo);
private:
std::string regionId_;
std::string clientInfo_;
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_GETPERSONREQUEST_H_

View File

@@ -0,0 +1,49 @@
/*
* 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_GREEN_MODEL_GETPERSONRESULT_H_
#define ALIBABACLOUD_GREEN_MODEL_GETPERSONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT GetPersonResult : public ServiceResult
{
public:
GetPersonResult();
explicit GetPersonResult(const std::string &payload);
~GetPersonResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_GETPERSONRESULT_H_

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_GREEN_MODEL_GETPERSONSREQUEST_H_
#define ALIBABACLOUD_GREEN_MODEL_GETPERSONSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RoaServiceRequest.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT GetPersonsRequest : public RoaServiceRequest
{
public:
GetPersonsRequest();
~GetPersonsRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getClientInfo()const;
void setClientInfo(const std::string& clientInfo);
private:
std::string regionId_;
std::string clientInfo_;
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_GETPERSONSREQUEST_H_

View File

@@ -0,0 +1,49 @@
/*
* 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_GREEN_MODEL_GETPERSONSRESULT_H_
#define ALIBABACLOUD_GREEN_MODEL_GETPERSONSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT GetPersonsResult : public ServiceResult
{
public:
GetPersonsResult();
explicit GetPersonsResult(const std::string &payload);
~GetPersonsResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_GETPERSONSRESULT_H_

View File

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

View File

@@ -0,0 +1,49 @@
/*
* 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_GREEN_MODEL_IMAGEASYNCSCANRESULT_H_
#define ALIBABACLOUD_GREEN_MODEL_IMAGEASYNCSCANRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT ImageAsyncScanResult : public ServiceResult
{
public:
ImageAsyncScanResult();
explicit ImageAsyncScanResult(const std::string &payload);
~ImageAsyncScanResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_IMAGEASYNCSCANRESULT_H_

View File

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

View File

@@ -0,0 +1,49 @@
/*
* 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_GREEN_MODEL_IMAGEASYNCSCANRESULTSRESULT_H_
#define ALIBABACLOUD_GREEN_MODEL_IMAGEASYNCSCANRESULTSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT ImageAsyncScanResultsResult : public ServiceResult
{
public:
ImageAsyncScanResultsResult();
explicit ImageAsyncScanResultsResult(const std::string &payload);
~ImageAsyncScanResultsResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_IMAGEASYNCSCANRESULTSRESULT_H_

View File

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

View File

@@ -0,0 +1,49 @@
/*
* 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_GREEN_MODEL_IMAGESCANFEEDBACKRESULT_H_
#define ALIBABACLOUD_GREEN_MODEL_IMAGESCANFEEDBACKRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT ImageScanFeedbackResult : public ServiceResult
{
public:
ImageScanFeedbackResult();
explicit ImageScanFeedbackResult(const std::string &payload);
~ImageScanFeedbackResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_IMAGESCANFEEDBACKRESULT_H_

View File

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

View File

@@ -0,0 +1,49 @@
/*
* 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_GREEN_MODEL_IMAGESYNCSCANRESULT_H_
#define ALIBABACLOUD_GREEN_MODEL_IMAGESYNCSCANRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT ImageSyncScanResult : public ServiceResult
{
public:
ImageSyncScanResult();
explicit ImageSyncScanResult(const std::string &payload);
~ImageSyncScanResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_IMAGESYNCSCANRESULT_H_

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_GREEN_MODEL_SEARCHREQUEST_H_
#define ALIBABACLOUD_GREEN_MODEL_SEARCHREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RoaServiceRequest.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT SearchRequest : public RoaServiceRequest
{
public:
SearchRequest();
~SearchRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getClientInfo()const;
void setClientInfo(const std::string& clientInfo);
private:
std::string regionId_;
std::string clientInfo_;
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_SEARCHREQUEST_H_

View File

@@ -0,0 +1,49 @@
/*
* 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_GREEN_MODEL_SEARCHRESULT_H_
#define ALIBABACLOUD_GREEN_MODEL_SEARCHRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT SearchResult : public ServiceResult
{
public:
SearchResult();
explicit SearchResult(const std::string &payload);
~SearchResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_SEARCHRESULT_H_

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_GREEN_MODEL_SETPERSONREQUEST_H_
#define ALIBABACLOUD_GREEN_MODEL_SETPERSONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RoaServiceRequest.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT SetPersonRequest : public RoaServiceRequest
{
public:
SetPersonRequest();
~SetPersonRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getClientInfo()const;
void setClientInfo(const std::string& clientInfo);
private:
std::string regionId_;
std::string clientInfo_;
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_SETPERSONREQUEST_H_

View File

@@ -0,0 +1,49 @@
/*
* 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_GREEN_MODEL_SETPERSONRESULT_H_
#define ALIBABACLOUD_GREEN_MODEL_SETPERSONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT SetPersonResult : public ServiceResult
{
public:
SetPersonResult();
explicit SetPersonResult(const std::string &payload);
~SetPersonResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_SETPERSONRESULT_H_

View File

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

View File

@@ -0,0 +1,49 @@
/*
* 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_GREEN_MODEL_TEXTFEEDBACKRESULT_H_
#define ALIBABACLOUD_GREEN_MODEL_TEXTFEEDBACKRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT TextFeedbackResult : public ServiceResult
{
public:
TextFeedbackResult();
explicit TextFeedbackResult(const std::string &payload);
~TextFeedbackResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_TEXTFEEDBACKRESULT_H_

View File

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

View File

@@ -0,0 +1,49 @@
/*
* 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_GREEN_MODEL_TEXTSCANRESULT_H_
#define ALIBABACLOUD_GREEN_MODEL_TEXTSCANRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT TextScanResult : public ServiceResult
{
public:
TextScanResult();
explicit TextScanResult(const std::string &payload);
~TextScanResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_TEXTSCANRESULT_H_

View File

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

View File

@@ -0,0 +1,49 @@
/*
* 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_GREEN_MODEL_VIDEOASYNCSCANRESULT_H_
#define ALIBABACLOUD_GREEN_MODEL_VIDEOASYNCSCANRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT VideoAsyncScanResult : public ServiceResult
{
public:
VideoAsyncScanResult();
explicit VideoAsyncScanResult(const std::string &payload);
~VideoAsyncScanResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_VIDEOASYNCSCANRESULT_H_

View File

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

View File

@@ -0,0 +1,49 @@
/*
* 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_GREEN_MODEL_VIDEOASYNCSCANRESULTSRESULT_H_
#define ALIBABACLOUD_GREEN_MODEL_VIDEOASYNCSCANRESULTSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT VideoAsyncScanResultsResult : public ServiceResult
{
public:
VideoAsyncScanResultsResult();
explicit VideoAsyncScanResultsResult(const std::string &payload);
~VideoAsyncScanResultsResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_VIDEOASYNCSCANRESULTSRESULT_H_

View File

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

View File

@@ -0,0 +1,49 @@
/*
* 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_GREEN_MODEL_VIDEOFEEDBACKRESULT_H_
#define ALIBABACLOUD_GREEN_MODEL_VIDEOFEEDBACKRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT VideoFeedbackResult : public ServiceResult
{
public:
VideoFeedbackResult();
explicit VideoFeedbackResult(const std::string &payload);
~VideoFeedbackResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_VIDEOFEEDBACKRESULT_H_

View File

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

View File

@@ -0,0 +1,49 @@
/*
* 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_GREEN_MODEL_VOICEASYNCSCANRESULT_H_
#define ALIBABACLOUD_GREEN_MODEL_VOICEASYNCSCANRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT VoiceAsyncScanResult : public ServiceResult
{
public:
VoiceAsyncScanResult();
explicit VoiceAsyncScanResult(const std::string &payload);
~VoiceAsyncScanResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_VOICEASYNCSCANRESULT_H_

View File

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

View File

@@ -0,0 +1,49 @@
/*
* 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_GREEN_MODEL_VOICEASYNCSCANRESULTSRESULT_H_
#define ALIBABACLOUD_GREEN_MODEL_VOICEASYNCSCANRESULTSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/green/GreenExport.h>
namespace AlibabaCloud
{
namespace Green
{
namespace Model
{
class ALIBABACLOUD_GREEN_EXPORT VoiceAsyncScanResultsResult : public ServiceResult
{
public:
VoiceAsyncScanResultsResult();
explicit VoiceAsyncScanResultsResult(const std::string &payload);
~VoiceAsyncScanResultsResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_GREEN_MODEL_VOICEASYNCSCANRESULTSRESULT_H_

953
green/src/GreenClient.cc Normal file
View File

@@ -0,0 +1,953 @@
/*
* 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/green/GreenClient.h>
#include <alibabacloud/core/SimpleCredentialsProvider.h>
using namespace AlibabaCloud;
using namespace AlibabaCloud::Location;
using namespace AlibabaCloud::Green;
using namespace AlibabaCloud::Green::Model;
namespace
{
const std::string SERVICE_NAME = "Green";
}
GreenClient::GreenClient(const Credentials &credentials, const ClientConfiguration &configuration) :
RoaServiceClient(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, "green");
}
GreenClient::GreenClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
RoaServiceClient(SERVICE_NAME, credentialsProvider, configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "green");
}
GreenClient::GreenClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
RoaServiceClient(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, "green");
}
GreenClient::~GreenClient()
{}
GreenClient::ImageSyncScanOutcome GreenClient::imageSyncScan(const ImageSyncScanRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ImageSyncScanOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ImageSyncScanOutcome(ImageSyncScanResult(outcome.result()));
else
return ImageSyncScanOutcome(outcome.error());
}
void GreenClient::imageSyncScanAsync(const ImageSyncScanRequest& request, const ImageSyncScanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, imageSyncScan(request), context);
};
asyncExecute(new Runnable(fn));
}
GreenClient::ImageSyncScanOutcomeCallable GreenClient::imageSyncScanCallable(const ImageSyncScanRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ImageSyncScanOutcome()>>(
[this, request]()
{
return this->imageSyncScan(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
GreenClient::GetPersonsOutcome GreenClient::getPersons(const GetPersonsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetPersonsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetPersonsOutcome(GetPersonsResult(outcome.result()));
else
return GetPersonsOutcome(outcome.error());
}
void GreenClient::getPersonsAsync(const GetPersonsRequest& request, const GetPersonsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getPersons(request), context);
};
asyncExecute(new Runnable(fn));
}
GreenClient::GetPersonsOutcomeCallable GreenClient::getPersonsCallable(const GetPersonsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetPersonsOutcome()>>(
[this, request]()
{
return this->getPersons(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
GreenClient::GetPersonOutcome GreenClient::getPerson(const GetPersonRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetPersonOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetPersonOutcome(GetPersonResult(outcome.result()));
else
return GetPersonOutcome(outcome.error());
}
void GreenClient::getPersonAsync(const GetPersonRequest& request, const GetPersonAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getPerson(request), context);
};
asyncExecute(new Runnable(fn));
}
GreenClient::GetPersonOutcomeCallable GreenClient::getPersonCallable(const GetPersonRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetPersonOutcome()>>(
[this, request]()
{
return this->getPerson(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
GreenClient::DeleteFacesOutcome GreenClient::deleteFaces(const DeleteFacesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteFacesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteFacesOutcome(DeleteFacesResult(outcome.result()));
else
return DeleteFacesOutcome(outcome.error());
}
void GreenClient::deleteFacesAsync(const DeleteFacesRequest& request, const DeleteFacesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteFaces(request), context);
};
asyncExecute(new Runnable(fn));
}
GreenClient::DeleteFacesOutcomeCallable GreenClient::deleteFacesCallable(const DeleteFacesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteFacesOutcome()>>(
[this, request]()
{
return this->deleteFaces(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
GreenClient::VideoFeedbackOutcome GreenClient::videoFeedback(const VideoFeedbackRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return VideoFeedbackOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return VideoFeedbackOutcome(VideoFeedbackResult(outcome.result()));
else
return VideoFeedbackOutcome(outcome.error());
}
void GreenClient::videoFeedbackAsync(const VideoFeedbackRequest& request, const VideoFeedbackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, videoFeedback(request), context);
};
asyncExecute(new Runnable(fn));
}
GreenClient::VideoFeedbackOutcomeCallable GreenClient::videoFeedbackCallable(const VideoFeedbackRequest &request) const
{
auto task = std::make_shared<std::packaged_task<VideoFeedbackOutcome()>>(
[this, request]()
{
return this->videoFeedback(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
GreenClient::DeletePersonOutcome GreenClient::deletePerson(const DeletePersonRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeletePersonOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeletePersonOutcome(DeletePersonResult(outcome.result()));
else
return DeletePersonOutcome(outcome.error());
}
void GreenClient::deletePersonAsync(const DeletePersonRequest& request, const DeletePersonAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deletePerson(request), context);
};
asyncExecute(new Runnable(fn));
}
GreenClient::DeletePersonOutcomeCallable GreenClient::deletePersonCallable(const DeletePersonRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeletePersonOutcome()>>(
[this, request]()
{
return this->deletePerson(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
GreenClient::VideoAsyncScanResultsOutcome GreenClient::videoAsyncScanResults(const VideoAsyncScanResultsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return VideoAsyncScanResultsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return VideoAsyncScanResultsOutcome(VideoAsyncScanResultsResult(outcome.result()));
else
return VideoAsyncScanResultsOutcome(outcome.error());
}
void GreenClient::videoAsyncScanResultsAsync(const VideoAsyncScanResultsRequest& request, const VideoAsyncScanResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, videoAsyncScanResults(request), context);
};
asyncExecute(new Runnable(fn));
}
GreenClient::VideoAsyncScanResultsOutcomeCallable GreenClient::videoAsyncScanResultsCallable(const VideoAsyncScanResultsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<VideoAsyncScanResultsOutcome()>>(
[this, request]()
{
return this->videoAsyncScanResults(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
GreenClient::AddGroupsOutcome GreenClient::addGroups(const AddGroupsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return AddGroupsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return AddGroupsOutcome(AddGroupsResult(outcome.result()));
else
return AddGroupsOutcome(outcome.error());
}
void GreenClient::addGroupsAsync(const AddGroupsRequest& request, const AddGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, addGroups(request), context);
};
asyncExecute(new Runnable(fn));
}
GreenClient::AddGroupsOutcomeCallable GreenClient::addGroupsCallable(const AddGroupsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<AddGroupsOutcome()>>(
[this, request]()
{
return this->addGroups(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
GreenClient::FileAsyncScanOutcome GreenClient::fileAsyncScan(const FileAsyncScanRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return FileAsyncScanOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return FileAsyncScanOutcome(FileAsyncScanResult(outcome.result()));
else
return FileAsyncScanOutcome(outcome.error());
}
void GreenClient::fileAsyncScanAsync(const FileAsyncScanRequest& request, const FileAsyncScanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, fileAsyncScan(request), context);
};
asyncExecute(new Runnable(fn));
}
GreenClient::FileAsyncScanOutcomeCallable GreenClient::fileAsyncScanCallable(const FileAsyncScanRequest &request) const
{
auto task = std::make_shared<std::packaged_task<FileAsyncScanOutcome()>>(
[this, request]()
{
return this->fileAsyncScan(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
GreenClient::SetPersonOutcome GreenClient::setPerson(const SetPersonRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SetPersonOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SetPersonOutcome(SetPersonResult(outcome.result()));
else
return SetPersonOutcome(outcome.error());
}
void GreenClient::setPersonAsync(const SetPersonRequest& request, const SetPersonAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, setPerson(request), context);
};
asyncExecute(new Runnable(fn));
}
GreenClient::SetPersonOutcomeCallable GreenClient::setPersonCallable(const SetPersonRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SetPersonOutcome()>>(
[this, request]()
{
return this->setPerson(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
GreenClient::TextFeedbackOutcome GreenClient::textFeedback(const TextFeedbackRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return TextFeedbackOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return TextFeedbackOutcome(TextFeedbackResult(outcome.result()));
else
return TextFeedbackOutcome(outcome.error());
}
void GreenClient::textFeedbackAsync(const TextFeedbackRequest& request, const TextFeedbackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, textFeedback(request), context);
};
asyncExecute(new Runnable(fn));
}
GreenClient::TextFeedbackOutcomeCallable GreenClient::textFeedbackCallable(const TextFeedbackRequest &request) const
{
auto task = std::make_shared<std::packaged_task<TextFeedbackOutcome()>>(
[this, request]()
{
return this->textFeedback(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
GreenClient::SearchOutcome GreenClient::search(const SearchRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SearchOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SearchOutcome(SearchResult(outcome.result()));
else
return SearchOutcome(outcome.error());
}
void GreenClient::searchAsync(const SearchRequest& request, const SearchAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, search(request), context);
};
asyncExecute(new Runnable(fn));
}
GreenClient::SearchOutcomeCallable GreenClient::searchCallable(const SearchRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SearchOutcome()>>(
[this, request]()
{
return this->search(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
GreenClient::FileAsyncScanResultsOutcome GreenClient::fileAsyncScanResults(const FileAsyncScanResultsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return FileAsyncScanResultsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return FileAsyncScanResultsOutcome(FileAsyncScanResultsResult(outcome.result()));
else
return FileAsyncScanResultsOutcome(outcome.error());
}
void GreenClient::fileAsyncScanResultsAsync(const FileAsyncScanResultsRequest& request, const FileAsyncScanResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, fileAsyncScanResults(request), context);
};
asyncExecute(new Runnable(fn));
}
GreenClient::FileAsyncScanResultsOutcomeCallable GreenClient::fileAsyncScanResultsCallable(const FileAsyncScanResultsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<FileAsyncScanResultsOutcome()>>(
[this, request]()
{
return this->fileAsyncScanResults(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
GreenClient::DeleteGroupsOutcome GreenClient::deleteGroups(const DeleteGroupsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteGroupsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteGroupsOutcome(DeleteGroupsResult(outcome.result()));
else
return DeleteGroupsOutcome(outcome.error());
}
void GreenClient::deleteGroupsAsync(const DeleteGroupsRequest& request, const DeleteGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteGroups(request), context);
};
asyncExecute(new Runnable(fn));
}
GreenClient::DeleteGroupsOutcomeCallable GreenClient::deleteGroupsCallable(const DeleteGroupsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteGroupsOutcome()>>(
[this, request]()
{
return this->deleteGroups(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
GreenClient::ImageAsyncScanOutcome GreenClient::imageAsyncScan(const ImageAsyncScanRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ImageAsyncScanOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ImageAsyncScanOutcome(ImageAsyncScanResult(outcome.result()));
else
return ImageAsyncScanOutcome(outcome.error());
}
void GreenClient::imageAsyncScanAsync(const ImageAsyncScanRequest& request, const ImageAsyncScanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, imageAsyncScan(request), context);
};
asyncExecute(new Runnable(fn));
}
GreenClient::ImageAsyncScanOutcomeCallable GreenClient::imageAsyncScanCallable(const ImageAsyncScanRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ImageAsyncScanOutcome()>>(
[this, request]()
{
return this->imageAsyncScan(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
GreenClient::VideoAsyncScanOutcome GreenClient::videoAsyncScan(const VideoAsyncScanRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return VideoAsyncScanOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return VideoAsyncScanOutcome(VideoAsyncScanResult(outcome.result()));
else
return VideoAsyncScanOutcome(outcome.error());
}
void GreenClient::videoAsyncScanAsync(const VideoAsyncScanRequest& request, const VideoAsyncScanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, videoAsyncScan(request), context);
};
asyncExecute(new Runnable(fn));
}
GreenClient::VideoAsyncScanOutcomeCallable GreenClient::videoAsyncScanCallable(const VideoAsyncScanRequest &request) const
{
auto task = std::make_shared<std::packaged_task<VideoAsyncScanOutcome()>>(
[this, request]()
{
return this->videoAsyncScan(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
GreenClient::ImageAsyncScanResultsOutcome GreenClient::imageAsyncScanResults(const ImageAsyncScanResultsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ImageAsyncScanResultsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ImageAsyncScanResultsOutcome(ImageAsyncScanResultsResult(outcome.result()));
else
return ImageAsyncScanResultsOutcome(outcome.error());
}
void GreenClient::imageAsyncScanResultsAsync(const ImageAsyncScanResultsRequest& request, const ImageAsyncScanResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, imageAsyncScanResults(request), context);
};
asyncExecute(new Runnable(fn));
}
GreenClient::ImageAsyncScanResultsOutcomeCallable GreenClient::imageAsyncScanResultsCallable(const ImageAsyncScanResultsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ImageAsyncScanResultsOutcome()>>(
[this, request]()
{
return this->imageAsyncScanResults(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
GreenClient::VoiceAsyncScanResultsOutcome GreenClient::voiceAsyncScanResults(const VoiceAsyncScanResultsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return VoiceAsyncScanResultsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return VoiceAsyncScanResultsOutcome(VoiceAsyncScanResultsResult(outcome.result()));
else
return VoiceAsyncScanResultsOutcome(outcome.error());
}
void GreenClient::voiceAsyncScanResultsAsync(const VoiceAsyncScanResultsRequest& request, const VoiceAsyncScanResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, voiceAsyncScanResults(request), context);
};
asyncExecute(new Runnable(fn));
}
GreenClient::VoiceAsyncScanResultsOutcomeCallable GreenClient::voiceAsyncScanResultsCallable(const VoiceAsyncScanResultsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<VoiceAsyncScanResultsOutcome()>>(
[this, request]()
{
return this->voiceAsyncScanResults(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
GreenClient::GetFacesOutcome GreenClient::getFaces(const GetFacesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetFacesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetFacesOutcome(GetFacesResult(outcome.result()));
else
return GetFacesOutcome(outcome.error());
}
void GreenClient::getFacesAsync(const GetFacesRequest& request, const GetFacesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getFaces(request), context);
};
asyncExecute(new Runnable(fn));
}
GreenClient::GetFacesOutcomeCallable GreenClient::getFacesCallable(const GetFacesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetFacesOutcome()>>(
[this, request]()
{
return this->getFaces(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
GreenClient::VoiceAsyncScanOutcome GreenClient::voiceAsyncScan(const VoiceAsyncScanRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return VoiceAsyncScanOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return VoiceAsyncScanOutcome(VoiceAsyncScanResult(outcome.result()));
else
return VoiceAsyncScanOutcome(outcome.error());
}
void GreenClient::voiceAsyncScanAsync(const VoiceAsyncScanRequest& request, const VoiceAsyncScanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, voiceAsyncScan(request), context);
};
asyncExecute(new Runnable(fn));
}
GreenClient::VoiceAsyncScanOutcomeCallable GreenClient::voiceAsyncScanCallable(const VoiceAsyncScanRequest &request) const
{
auto task = std::make_shared<std::packaged_task<VoiceAsyncScanOutcome()>>(
[this, request]()
{
return this->voiceAsyncScan(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
GreenClient::GetGroupsOutcome GreenClient::getGroups(const GetGroupsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetGroupsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetGroupsOutcome(GetGroupsResult(outcome.result()));
else
return GetGroupsOutcome(outcome.error());
}
void GreenClient::getGroupsAsync(const GetGroupsRequest& request, const GetGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getGroups(request), context);
};
asyncExecute(new Runnable(fn));
}
GreenClient::GetGroupsOutcomeCallable GreenClient::getGroupsCallable(const GetGroupsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetGroupsOutcome()>>(
[this, request]()
{
return this->getGroups(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
GreenClient::TextScanOutcome GreenClient::textScan(const TextScanRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return TextScanOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return TextScanOutcome(TextScanResult(outcome.result()));
else
return TextScanOutcome(outcome.error());
}
void GreenClient::textScanAsync(const TextScanRequest& request, const TextScanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, textScan(request), context);
};
asyncExecute(new Runnable(fn));
}
GreenClient::TextScanOutcomeCallable GreenClient::textScanCallable(const TextScanRequest &request) const
{
auto task = std::make_shared<std::packaged_task<TextScanOutcome()>>(
[this, request]()
{
return this->textScan(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
GreenClient::ImageScanFeedbackOutcome GreenClient::imageScanFeedback(const ImageScanFeedbackRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ImageScanFeedbackOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ImageScanFeedbackOutcome(ImageScanFeedbackResult(outcome.result()));
else
return ImageScanFeedbackOutcome(outcome.error());
}
void GreenClient::imageScanFeedbackAsync(const ImageScanFeedbackRequest& request, const ImageScanFeedbackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, imageScanFeedback(request), context);
};
asyncExecute(new Runnable(fn));
}
GreenClient::ImageScanFeedbackOutcomeCallable GreenClient::imageScanFeedbackCallable(const ImageScanFeedbackRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ImageScanFeedbackOutcome()>>(
[this, request]()
{
return this->imageScanFeedback(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
GreenClient::AddPersonOutcome GreenClient::addPerson(const AddPersonRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return AddPersonOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return AddPersonOutcome(AddPersonResult(outcome.result()));
else
return AddPersonOutcome(outcome.error());
}
void GreenClient::addPersonAsync(const AddPersonRequest& request, const AddPersonAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, addPerson(request), context);
};
asyncExecute(new Runnable(fn));
}
GreenClient::AddPersonOutcomeCallable GreenClient::addPersonCallable(const AddPersonRequest &request) const
{
auto task = std::make_shared<std::packaged_task<AddPersonOutcome()>>(
[this, request]()
{
return this->addPerson(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
GreenClient::AddFacesOutcome GreenClient::addFaces(const AddFacesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return AddFacesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return AddFacesOutcome(AddFacesResult(outcome.result()));
else
return AddFacesOutcome(outcome.error());
}
void GreenClient::addFacesAsync(const AddFacesRequest& request, const AddFacesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, addFaces(request), context);
};
asyncExecute(new Runnable(fn));
}
GreenClient::AddFacesOutcomeCallable GreenClient::addFacesCallable(const AddFacesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<AddFacesOutcome()>>(
[this, request]()
{
return this->addFaces(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}

View File

@@ -0,0 +1,49 @@
/*
* 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/green/model/AddFacesRequest.h>
using AlibabaCloud::Green::Model::AddFacesRequest;
AddFacesRequest::AddFacesRequest() :
RoaServiceRequest("green", "2017-08-25")
{}
AddFacesRequest::~AddFacesRequest()
{}
std::string AddFacesRequest::getRegionId()const
{
return regionId_;
}
void AddFacesRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string AddFacesRequest::getClientInfo()const
{
return clientInfo_;
}
void AddFacesRequest::setClientInfo(const std::string& clientInfo)
{
clientInfo_ = clientInfo;
setParameter("ClientInfo", clientInfo);
}

View File

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

View File

@@ -0,0 +1,49 @@
/*
* 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/green/model/AddGroupsRequest.h>
using AlibabaCloud::Green::Model::AddGroupsRequest;
AddGroupsRequest::AddGroupsRequest() :
RoaServiceRequest("green", "2017-08-25")
{}
AddGroupsRequest::~AddGroupsRequest()
{}
std::string AddGroupsRequest::getRegionId()const
{
return regionId_;
}
void AddGroupsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string AddGroupsRequest::getClientInfo()const
{
return clientInfo_;
}
void AddGroupsRequest::setClientInfo(const std::string& clientInfo)
{
clientInfo_ = clientInfo;
setParameter("ClientInfo", clientInfo);
}

View File

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

View File

@@ -0,0 +1,49 @@
/*
* 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/green/model/AddPersonRequest.h>
using AlibabaCloud::Green::Model::AddPersonRequest;
AddPersonRequest::AddPersonRequest() :
RoaServiceRequest("green", "2017-08-25")
{}
AddPersonRequest::~AddPersonRequest()
{}
std::string AddPersonRequest::getRegionId()const
{
return regionId_;
}
void AddPersonRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string AddPersonRequest::getClientInfo()const
{
return clientInfo_;
}
void AddPersonRequest::setClientInfo(const std::string& clientInfo)
{
clientInfo_ = clientInfo;
setParameter("ClientInfo", clientInfo);
}

View File

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

View File

@@ -0,0 +1,49 @@
/*
* 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/green/model/DeleteFacesRequest.h>
using AlibabaCloud::Green::Model::DeleteFacesRequest;
DeleteFacesRequest::DeleteFacesRequest() :
RoaServiceRequest("green", "2017-08-25")
{}
DeleteFacesRequest::~DeleteFacesRequest()
{}
std::string DeleteFacesRequest::getRegionId()const
{
return regionId_;
}
void DeleteFacesRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DeleteFacesRequest::getClientInfo()const
{
return clientInfo_;
}
void DeleteFacesRequest::setClientInfo(const std::string& clientInfo)
{
clientInfo_ = clientInfo;
setParameter("ClientInfo", clientInfo);
}

View File

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

View File

@@ -0,0 +1,49 @@
/*
* 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/green/model/DeleteGroupsRequest.h>
using AlibabaCloud::Green::Model::DeleteGroupsRequest;
DeleteGroupsRequest::DeleteGroupsRequest() :
RoaServiceRequest("green", "2017-08-25")
{}
DeleteGroupsRequest::~DeleteGroupsRequest()
{}
std::string DeleteGroupsRequest::getRegionId()const
{
return regionId_;
}
void DeleteGroupsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DeleteGroupsRequest::getClientInfo()const
{
return clientInfo_;
}
void DeleteGroupsRequest::setClientInfo(const std::string& clientInfo)
{
clientInfo_ = clientInfo;
setParameter("ClientInfo", clientInfo);
}

View File

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

View File

@@ -0,0 +1,49 @@
/*
* 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/green/model/DeletePersonRequest.h>
using AlibabaCloud::Green::Model::DeletePersonRequest;
DeletePersonRequest::DeletePersonRequest() :
RoaServiceRequest("green", "2017-08-25")
{}
DeletePersonRequest::~DeletePersonRequest()
{}
std::string DeletePersonRequest::getRegionId()const
{
return regionId_;
}
void DeletePersonRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DeletePersonRequest::getClientInfo()const
{
return clientInfo_;
}
void DeletePersonRequest::setClientInfo(const std::string& clientInfo)
{
clientInfo_ = clientInfo;
setParameter("ClientInfo", clientInfo);
}

View File

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

View File

@@ -0,0 +1,38 @@
/*
* 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/green/model/FileAsyncScanRequest.h>
using AlibabaCloud::Green::Model::FileAsyncScanRequest;
FileAsyncScanRequest::FileAsyncScanRequest() :
RoaServiceRequest("green", "2017-08-25")
{}
FileAsyncScanRequest::~FileAsyncScanRequest()
{}
std::string FileAsyncScanRequest::getClientInfo()const
{
return clientInfo_;
}
void FileAsyncScanRequest::setClientInfo(const std::string& clientInfo)
{
clientInfo_ = clientInfo;
setParameter("ClientInfo", clientInfo);
}

View File

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

View File

@@ -0,0 +1,38 @@
/*
* 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/green/model/FileAsyncScanResultsRequest.h>
using AlibabaCloud::Green::Model::FileAsyncScanResultsRequest;
FileAsyncScanResultsRequest::FileAsyncScanResultsRequest() :
RoaServiceRequest("green", "2017-08-25")
{}
FileAsyncScanResultsRequest::~FileAsyncScanResultsRequest()
{}
std::string FileAsyncScanResultsRequest::getClientInfo()const
{
return clientInfo_;
}
void FileAsyncScanResultsRequest::setClientInfo(const std::string& clientInfo)
{
clientInfo_ = clientInfo;
setParameter("ClientInfo", clientInfo);
}

View File

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

View File

@@ -0,0 +1,49 @@
/*
* 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/green/model/GetFacesRequest.h>
using AlibabaCloud::Green::Model::GetFacesRequest;
GetFacesRequest::GetFacesRequest() :
RoaServiceRequest("green", "2017-08-25")
{}
GetFacesRequest::~GetFacesRequest()
{}
std::string GetFacesRequest::getRegionId()const
{
return regionId_;
}
void GetFacesRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string GetFacesRequest::getClientInfo()const
{
return clientInfo_;
}
void GetFacesRequest::setClientInfo(const std::string& clientInfo)
{
clientInfo_ = clientInfo;
setParameter("ClientInfo", clientInfo);
}

View File

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

View File

@@ -0,0 +1,49 @@
/*
* 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/green/model/GetGroupsRequest.h>
using AlibabaCloud::Green::Model::GetGroupsRequest;
GetGroupsRequest::GetGroupsRequest() :
RoaServiceRequest("green", "2017-08-25")
{}
GetGroupsRequest::~GetGroupsRequest()
{}
std::string GetGroupsRequest::getRegionId()const
{
return regionId_;
}
void GetGroupsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string GetGroupsRequest::getClientInfo()const
{
return clientInfo_;
}
void GetGroupsRequest::setClientInfo(const std::string& clientInfo)
{
clientInfo_ = clientInfo;
setParameter("ClientInfo", clientInfo);
}

View File

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

View File

@@ -0,0 +1,49 @@
/*
* 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/green/model/GetPersonRequest.h>
using AlibabaCloud::Green::Model::GetPersonRequest;
GetPersonRequest::GetPersonRequest() :
RoaServiceRequest("green", "2017-08-25")
{}
GetPersonRequest::~GetPersonRequest()
{}
std::string GetPersonRequest::getRegionId()const
{
return regionId_;
}
void GetPersonRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string GetPersonRequest::getClientInfo()const
{
return clientInfo_;
}
void GetPersonRequest::setClientInfo(const std::string& clientInfo)
{
clientInfo_ = clientInfo;
setParameter("ClientInfo", clientInfo);
}

View File

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

View File

@@ -0,0 +1,49 @@
/*
* 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/green/model/GetPersonsRequest.h>
using AlibabaCloud::Green::Model::GetPersonsRequest;
GetPersonsRequest::GetPersonsRequest() :
RoaServiceRequest("green", "2017-08-25")
{}
GetPersonsRequest::~GetPersonsRequest()
{}
std::string GetPersonsRequest::getRegionId()const
{
return regionId_;
}
void GetPersonsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string GetPersonsRequest::getClientInfo()const
{
return clientInfo_;
}
void GetPersonsRequest::setClientInfo(const std::string& clientInfo)
{
clientInfo_ = clientInfo;
setParameter("ClientInfo", clientInfo);
}

View File

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

View File

@@ -0,0 +1,38 @@
/*
* 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/green/model/ImageAsyncScanRequest.h>
using AlibabaCloud::Green::Model::ImageAsyncScanRequest;
ImageAsyncScanRequest::ImageAsyncScanRequest() :
RoaServiceRequest("green", "2017-08-25")
{}
ImageAsyncScanRequest::~ImageAsyncScanRequest()
{}
std::string ImageAsyncScanRequest::getClientInfo()const
{
return clientInfo_;
}
void ImageAsyncScanRequest::setClientInfo(const std::string& clientInfo)
{
clientInfo_ = clientInfo;
setParameter("ClientInfo", clientInfo);
}

View File

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

View File

@@ -0,0 +1,38 @@
/*
* 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/green/model/ImageAsyncScanResultsRequest.h>
using AlibabaCloud::Green::Model::ImageAsyncScanResultsRequest;
ImageAsyncScanResultsRequest::ImageAsyncScanResultsRequest() :
RoaServiceRequest("green", "2017-08-25")
{}
ImageAsyncScanResultsRequest::~ImageAsyncScanResultsRequest()
{}
std::string ImageAsyncScanResultsRequest::getClientInfo()const
{
return clientInfo_;
}
void ImageAsyncScanResultsRequest::setClientInfo(const std::string& clientInfo)
{
clientInfo_ = clientInfo;
setParameter("ClientInfo", clientInfo);
}

View File

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

View File

@@ -0,0 +1,38 @@
/*
* 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/green/model/ImageScanFeedbackRequest.h>
using AlibabaCloud::Green::Model::ImageScanFeedbackRequest;
ImageScanFeedbackRequest::ImageScanFeedbackRequest() :
RoaServiceRequest("green", "2017-08-25")
{}
ImageScanFeedbackRequest::~ImageScanFeedbackRequest()
{}
std::string ImageScanFeedbackRequest::getClientInfo()const
{
return clientInfo_;
}
void ImageScanFeedbackRequest::setClientInfo(const std::string& clientInfo)
{
clientInfo_ = clientInfo;
setParameter("ClientInfo", clientInfo);
}

View File

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

View File

@@ -0,0 +1,38 @@
/*
* 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/green/model/ImageSyncScanRequest.h>
using AlibabaCloud::Green::Model::ImageSyncScanRequest;
ImageSyncScanRequest::ImageSyncScanRequest() :
RoaServiceRequest("green", "2017-08-25")
{}
ImageSyncScanRequest::~ImageSyncScanRequest()
{}
std::string ImageSyncScanRequest::getClientInfo()const
{
return clientInfo_;
}
void ImageSyncScanRequest::setClientInfo(const std::string& clientInfo)
{
clientInfo_ = clientInfo;
setParameter("ClientInfo", clientInfo);
}

View File

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

View File

@@ -0,0 +1,49 @@
/*
* 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/green/model/SearchRequest.h>
using AlibabaCloud::Green::Model::SearchRequest;
SearchRequest::SearchRequest() :
RoaServiceRequest("green", "2017-08-25")
{}
SearchRequest::~SearchRequest()
{}
std::string SearchRequest::getRegionId()const
{
return regionId_;
}
void SearchRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string SearchRequest::getClientInfo()const
{
return clientInfo_;
}
void SearchRequest::setClientInfo(const std::string& clientInfo)
{
clientInfo_ = clientInfo;
setParameter("ClientInfo", clientInfo);
}

View File

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

View File

@@ -0,0 +1,49 @@
/*
* 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/green/model/SetPersonRequest.h>
using AlibabaCloud::Green::Model::SetPersonRequest;
SetPersonRequest::SetPersonRequest() :
RoaServiceRequest("green", "2017-08-25")
{}
SetPersonRequest::~SetPersonRequest()
{}
std::string SetPersonRequest::getRegionId()const
{
return regionId_;
}
void SetPersonRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string SetPersonRequest::getClientInfo()const
{
return clientInfo_;
}
void SetPersonRequest::setClientInfo(const std::string& clientInfo)
{
clientInfo_ = clientInfo;
setParameter("ClientInfo", clientInfo);
}

View File

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

View File

@@ -0,0 +1,38 @@
/*
* 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/green/model/TextFeedbackRequest.h>
using AlibabaCloud::Green::Model::TextFeedbackRequest;
TextFeedbackRequest::TextFeedbackRequest() :
RoaServiceRequest("green", "2017-08-25")
{}
TextFeedbackRequest::~TextFeedbackRequest()
{}
std::string TextFeedbackRequest::getClientInfo()const
{
return clientInfo_;
}
void TextFeedbackRequest::setClientInfo(const std::string& clientInfo)
{
clientInfo_ = clientInfo;
setParameter("ClientInfo", clientInfo);
}

View File

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

View File

@@ -0,0 +1,38 @@
/*
* 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/green/model/TextScanRequest.h>
using AlibabaCloud::Green::Model::TextScanRequest;
TextScanRequest::TextScanRequest() :
RoaServiceRequest("green", "2017-08-25")
{}
TextScanRequest::~TextScanRequest()
{}
std::string TextScanRequest::getClientInfo()const
{
return clientInfo_;
}
void TextScanRequest::setClientInfo(const std::string& clientInfo)
{
clientInfo_ = clientInfo;
setParameter("ClientInfo", clientInfo);
}

View File

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

View File

@@ -0,0 +1,38 @@
/*
* 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/green/model/VideoAsyncScanRequest.h>
using AlibabaCloud::Green::Model::VideoAsyncScanRequest;
VideoAsyncScanRequest::VideoAsyncScanRequest() :
RoaServiceRequest("green", "2017-08-25")
{}
VideoAsyncScanRequest::~VideoAsyncScanRequest()
{}
std::string VideoAsyncScanRequest::getClientInfo()const
{
return clientInfo_;
}
void VideoAsyncScanRequest::setClientInfo(const std::string& clientInfo)
{
clientInfo_ = clientInfo;
setParameter("ClientInfo", clientInfo);
}

View File

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

View File

@@ -0,0 +1,38 @@
/*
* 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/green/model/VideoAsyncScanResultsRequest.h>
using AlibabaCloud::Green::Model::VideoAsyncScanResultsRequest;
VideoAsyncScanResultsRequest::VideoAsyncScanResultsRequest() :
RoaServiceRequest("green", "2017-08-25")
{}
VideoAsyncScanResultsRequest::~VideoAsyncScanResultsRequest()
{}
std::string VideoAsyncScanResultsRequest::getClientInfo()const
{
return clientInfo_;
}
void VideoAsyncScanResultsRequest::setClientInfo(const std::string& clientInfo)
{
clientInfo_ = clientInfo;
setParameter("ClientInfo", clientInfo);
}

View File

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

View File

@@ -0,0 +1,38 @@
/*
* 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/green/model/VideoFeedbackRequest.h>
using AlibabaCloud::Green::Model::VideoFeedbackRequest;
VideoFeedbackRequest::VideoFeedbackRequest() :
RoaServiceRequest("green", "2017-08-25")
{}
VideoFeedbackRequest::~VideoFeedbackRequest()
{}
std::string VideoFeedbackRequest::getClientInfo()const
{
return clientInfo_;
}
void VideoFeedbackRequest::setClientInfo(const std::string& clientInfo)
{
clientInfo_ = clientInfo;
setParameter("ClientInfo", clientInfo);
}

View File

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

Some files were not shown because too many files have changed in this diff Show More