Generate SDK by new Generator

This commit is contained in:
wb-hx510875
2019-09-18 11:18:56 +08:00
parent be86048a76
commit f3eaf1d292
9054 changed files with 325898 additions and 381375 deletions

View File

@@ -21,49 +21,49 @@ set(mopen_public_header
include/alibabacloud/mopen/MoPenExport.h )
set(mopen_public_header_model
include/alibabacloud/mopen/model/MopenCreateGroupRequest.h
include/alibabacloud/mopen/model/MopenCreateGroupResult.h
include/alibabacloud/mopen/model/MoPenQueryCanvasRequest.h
include/alibabacloud/mopen/model/MoPenQueryCanvasResult.h
include/alibabacloud/mopen/model/MoPenAddGroupMemberRequest.h
include/alibabacloud/mopen/model/MoPenAddGroupMemberResult.h
include/alibabacloud/mopen/model/MoPenBindIsvRequest.h
include/alibabacloud/mopen/model/MoPenBindIsvResult.h
include/alibabacloud/mopen/model/MoPenCreateDeviceRequest.h
include/alibabacloud/mopen/model/MoPenCreateDeviceResult.h
include/alibabacloud/mopen/model/MoPenDeleteGroupRequest.h
include/alibabacloud/mopen/model/MoPenDeleteGroupResult.h
include/alibabacloud/mopen/model/MoPenDeleteGroupMemberRequest.h
include/alibabacloud/mopen/model/MoPenDeleteGroupMemberResult.h
include/alibabacloud/mopen/model/MoPenDoRecognizeRequest.h
include/alibabacloud/mopen/model/MoPenDoRecognizeResult.h
include/alibabacloud/mopen/model/MoPenBindIsvRequest.h
include/alibabacloud/mopen/model/MoPenBindIsvResult.h
include/alibabacloud/mopen/model/MoPenAddGroupMemberRequest.h
include/alibabacloud/mopen/model/MoPenAddGroupMemberResult.h
include/alibabacloud/mopen/model/MoPenCreateDeviceRequest.h
include/alibabacloud/mopen/model/MoPenCreateDeviceResult.h
include/alibabacloud/mopen/model/MoPenSendMqttMessageRequest.h
include/alibabacloud/mopen/model/MoPenSendMqttMessageResult.h
include/alibabacloud/mopen/model/MoPenFindGroupRequest.h
include/alibabacloud/mopen/model/MoPenFindGroupResult.h
include/alibabacloud/mopen/model/MoPenDeleteGroupRequest.h
include/alibabacloud/mopen/model/MoPenDeleteGroupResult.h )
include/alibabacloud/mopen/model/MoPenQueryCanvasRequest.h
include/alibabacloud/mopen/model/MoPenQueryCanvasResult.h
include/alibabacloud/mopen/model/MoPenSendMqttMessageRequest.h
include/alibabacloud/mopen/model/MoPenSendMqttMessageResult.h
include/alibabacloud/mopen/model/MopenCreateGroupRequest.h
include/alibabacloud/mopen/model/MopenCreateGroupResult.h )
set(mopen_src
src/MoPenClient.cc
src/model/MopenCreateGroupRequest.cc
src/model/MopenCreateGroupResult.cc
src/model/MoPenQueryCanvasRequest.cc
src/model/MoPenQueryCanvasResult.cc
src/model/MoPenAddGroupMemberRequest.cc
src/model/MoPenAddGroupMemberResult.cc
src/model/MoPenBindIsvRequest.cc
src/model/MoPenBindIsvResult.cc
src/model/MoPenCreateDeviceRequest.cc
src/model/MoPenCreateDeviceResult.cc
src/model/MoPenDeleteGroupRequest.cc
src/model/MoPenDeleteGroupResult.cc
src/model/MoPenDeleteGroupMemberRequest.cc
src/model/MoPenDeleteGroupMemberResult.cc
src/model/MoPenDoRecognizeRequest.cc
src/model/MoPenDoRecognizeResult.cc
src/model/MoPenBindIsvRequest.cc
src/model/MoPenBindIsvResult.cc
src/model/MoPenAddGroupMemberRequest.cc
src/model/MoPenAddGroupMemberResult.cc
src/model/MoPenCreateDeviceRequest.cc
src/model/MoPenCreateDeviceResult.cc
src/model/MoPenSendMqttMessageRequest.cc
src/model/MoPenSendMqttMessageResult.cc
src/model/MoPenFindGroupRequest.cc
src/model/MoPenFindGroupResult.cc
src/model/MoPenDeleteGroupRequest.cc
src/model/MoPenDeleteGroupResult.cc )
src/model/MoPenQueryCanvasRequest.cc
src/model/MoPenQueryCanvasResult.cc
src/model/MoPenSendMqttMessageRequest.cc
src/model/MoPenSendMqttMessageResult.cc
src/model/MopenCreateGroupRequest.cc
src/model/MopenCreateGroupResult.cc )
add_library(mopen ${LIB_TYPE}
${mopen_public_header}

View File

@@ -22,26 +22,26 @@
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "MoPenExport.h"
#include "model/MopenCreateGroupRequest.h"
#include "model/MopenCreateGroupResult.h"
#include "model/MoPenQueryCanvasRequest.h"
#include "model/MoPenQueryCanvasResult.h"
#include "model/MoPenAddGroupMemberRequest.h"
#include "model/MoPenAddGroupMemberResult.h"
#include "model/MoPenBindIsvRequest.h"
#include "model/MoPenBindIsvResult.h"
#include "model/MoPenCreateDeviceRequest.h"
#include "model/MoPenCreateDeviceResult.h"
#include "model/MoPenDeleteGroupRequest.h"
#include "model/MoPenDeleteGroupResult.h"
#include "model/MoPenDeleteGroupMemberRequest.h"
#include "model/MoPenDeleteGroupMemberResult.h"
#include "model/MoPenDoRecognizeRequest.h"
#include "model/MoPenDoRecognizeResult.h"
#include "model/MoPenBindIsvRequest.h"
#include "model/MoPenBindIsvResult.h"
#include "model/MoPenAddGroupMemberRequest.h"
#include "model/MoPenAddGroupMemberResult.h"
#include "model/MoPenCreateDeviceRequest.h"
#include "model/MoPenCreateDeviceResult.h"
#include "model/MoPenSendMqttMessageRequest.h"
#include "model/MoPenSendMqttMessageResult.h"
#include "model/MoPenFindGroupRequest.h"
#include "model/MoPenFindGroupResult.h"
#include "model/MoPenDeleteGroupRequest.h"
#include "model/MoPenDeleteGroupResult.h"
#include "model/MoPenQueryCanvasRequest.h"
#include "model/MoPenQueryCanvasResult.h"
#include "model/MoPenSendMqttMessageRequest.h"
#include "model/MoPenSendMqttMessageResult.h"
#include "model/MopenCreateGroupRequest.h"
#include "model/MopenCreateGroupResult.h"
namespace AlibabaCloud
@@ -51,71 +51,71 @@ namespace AlibabaCloud
class ALIBABACLOUD_MOPEN_EXPORT MoPenClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::MopenCreateGroupResult> MopenCreateGroupOutcome;
typedef std::future<MopenCreateGroupOutcome> MopenCreateGroupOutcomeCallable;
typedef std::function<void(const MoPenClient*, const Model::MopenCreateGroupRequest&, const MopenCreateGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MopenCreateGroupAsyncHandler;
typedef Outcome<Error, Model::MoPenQueryCanvasResult> MoPenQueryCanvasOutcome;
typedef std::future<MoPenQueryCanvasOutcome> MoPenQueryCanvasOutcomeCallable;
typedef std::function<void(const MoPenClient*, const Model::MoPenQueryCanvasRequest&, const MoPenQueryCanvasOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MoPenQueryCanvasAsyncHandler;
typedef Outcome<Error, Model::MoPenAddGroupMemberResult> MoPenAddGroupMemberOutcome;
typedef std::future<MoPenAddGroupMemberOutcome> MoPenAddGroupMemberOutcomeCallable;
typedef std::function<void(const MoPenClient*, const Model::MoPenAddGroupMemberRequest&, const MoPenAddGroupMemberOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MoPenAddGroupMemberAsyncHandler;
typedef Outcome<Error, Model::MoPenBindIsvResult> MoPenBindIsvOutcome;
typedef std::future<MoPenBindIsvOutcome> MoPenBindIsvOutcomeCallable;
typedef std::function<void(const MoPenClient*, const Model::MoPenBindIsvRequest&, const MoPenBindIsvOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MoPenBindIsvAsyncHandler;
typedef Outcome<Error, Model::MoPenCreateDeviceResult> MoPenCreateDeviceOutcome;
typedef std::future<MoPenCreateDeviceOutcome> MoPenCreateDeviceOutcomeCallable;
typedef std::function<void(const MoPenClient*, const Model::MoPenCreateDeviceRequest&, const MoPenCreateDeviceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MoPenCreateDeviceAsyncHandler;
typedef Outcome<Error, Model::MoPenDeleteGroupResult> MoPenDeleteGroupOutcome;
typedef std::future<MoPenDeleteGroupOutcome> MoPenDeleteGroupOutcomeCallable;
typedef std::function<void(const MoPenClient*, const Model::MoPenDeleteGroupRequest&, const MoPenDeleteGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MoPenDeleteGroupAsyncHandler;
typedef Outcome<Error, Model::MoPenDeleteGroupMemberResult> MoPenDeleteGroupMemberOutcome;
typedef std::future<MoPenDeleteGroupMemberOutcome> MoPenDeleteGroupMemberOutcomeCallable;
typedef std::function<void(const MoPenClient*, const Model::MoPenDeleteGroupMemberRequest&, const MoPenDeleteGroupMemberOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MoPenDeleteGroupMemberAsyncHandler;
typedef Outcome<Error, Model::MoPenDoRecognizeResult> MoPenDoRecognizeOutcome;
typedef std::future<MoPenDoRecognizeOutcome> MoPenDoRecognizeOutcomeCallable;
typedef std::function<void(const MoPenClient*, const Model::MoPenDoRecognizeRequest&, const MoPenDoRecognizeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MoPenDoRecognizeAsyncHandler;
typedef Outcome<Error, Model::MoPenBindIsvResult> MoPenBindIsvOutcome;
typedef std::future<MoPenBindIsvOutcome> MoPenBindIsvOutcomeCallable;
typedef std::function<void(const MoPenClient*, const Model::MoPenBindIsvRequest&, const MoPenBindIsvOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MoPenBindIsvAsyncHandler;
typedef Outcome<Error, Model::MoPenAddGroupMemberResult> MoPenAddGroupMemberOutcome;
typedef std::future<MoPenAddGroupMemberOutcome> MoPenAddGroupMemberOutcomeCallable;
typedef std::function<void(const MoPenClient*, const Model::MoPenAddGroupMemberRequest&, const MoPenAddGroupMemberOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MoPenAddGroupMemberAsyncHandler;
typedef Outcome<Error, Model::MoPenCreateDeviceResult> MoPenCreateDeviceOutcome;
typedef std::future<MoPenCreateDeviceOutcome> MoPenCreateDeviceOutcomeCallable;
typedef std::function<void(const MoPenClient*, const Model::MoPenCreateDeviceRequest&, const MoPenCreateDeviceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MoPenCreateDeviceAsyncHandler;
typedef Outcome<Error, Model::MoPenSendMqttMessageResult> MoPenSendMqttMessageOutcome;
typedef std::future<MoPenSendMqttMessageOutcome> MoPenSendMqttMessageOutcomeCallable;
typedef std::function<void(const MoPenClient*, const Model::MoPenSendMqttMessageRequest&, const MoPenSendMqttMessageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MoPenSendMqttMessageAsyncHandler;
typedef Outcome<Error, Model::MoPenFindGroupResult> MoPenFindGroupOutcome;
typedef std::future<MoPenFindGroupOutcome> MoPenFindGroupOutcomeCallable;
typedef std::function<void(const MoPenClient*, const Model::MoPenFindGroupRequest&, const MoPenFindGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MoPenFindGroupAsyncHandler;
typedef Outcome<Error, Model::MoPenDeleteGroupResult> MoPenDeleteGroupOutcome;
typedef std::future<MoPenDeleteGroupOutcome> MoPenDeleteGroupOutcomeCallable;
typedef std::function<void(const MoPenClient*, const Model::MoPenDeleteGroupRequest&, const MoPenDeleteGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MoPenDeleteGroupAsyncHandler;
typedef Outcome<Error, Model::MoPenQueryCanvasResult> MoPenQueryCanvasOutcome;
typedef std::future<MoPenQueryCanvasOutcome> MoPenQueryCanvasOutcomeCallable;
typedef std::function<void(const MoPenClient*, const Model::MoPenQueryCanvasRequest&, const MoPenQueryCanvasOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MoPenQueryCanvasAsyncHandler;
typedef Outcome<Error, Model::MoPenSendMqttMessageResult> MoPenSendMqttMessageOutcome;
typedef std::future<MoPenSendMqttMessageOutcome> MoPenSendMqttMessageOutcomeCallable;
typedef std::function<void(const MoPenClient*, const Model::MoPenSendMqttMessageRequest&, const MoPenSendMqttMessageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MoPenSendMqttMessageAsyncHandler;
typedef Outcome<Error, Model::MopenCreateGroupResult> MopenCreateGroupOutcome;
typedef std::future<MopenCreateGroupOutcome> MopenCreateGroupOutcomeCallable;
typedef std::function<void(const MoPenClient*, const Model::MopenCreateGroupRequest&, const MopenCreateGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MopenCreateGroupAsyncHandler;
MoPenClient(const Credentials &credentials, const ClientConfiguration &configuration);
MoPenClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
MoPenClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~MoPenClient();
MopenCreateGroupOutcome mopenCreateGroup(const Model::MopenCreateGroupRequest &request)const;
void mopenCreateGroupAsync(const Model::MopenCreateGroupRequest& request, const MopenCreateGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
MopenCreateGroupOutcomeCallable mopenCreateGroupCallable(const Model::MopenCreateGroupRequest& request) const;
MoPenQueryCanvasOutcome moPenQueryCanvas(const Model::MoPenQueryCanvasRequest &request)const;
void moPenQueryCanvasAsync(const Model::MoPenQueryCanvasRequest& request, const MoPenQueryCanvasAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
MoPenQueryCanvasOutcomeCallable moPenQueryCanvasCallable(const Model::MoPenQueryCanvasRequest& request) const;
MoPenAddGroupMemberOutcome moPenAddGroupMember(const Model::MoPenAddGroupMemberRequest &request)const;
void moPenAddGroupMemberAsync(const Model::MoPenAddGroupMemberRequest& request, const MoPenAddGroupMemberAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
MoPenAddGroupMemberOutcomeCallable moPenAddGroupMemberCallable(const Model::MoPenAddGroupMemberRequest& request) const;
MoPenBindIsvOutcome moPenBindIsv(const Model::MoPenBindIsvRequest &request)const;
void moPenBindIsvAsync(const Model::MoPenBindIsvRequest& request, const MoPenBindIsvAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
MoPenBindIsvOutcomeCallable moPenBindIsvCallable(const Model::MoPenBindIsvRequest& request) const;
MoPenCreateDeviceOutcome moPenCreateDevice(const Model::MoPenCreateDeviceRequest &request)const;
void moPenCreateDeviceAsync(const Model::MoPenCreateDeviceRequest& request, const MoPenCreateDeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
MoPenCreateDeviceOutcomeCallable moPenCreateDeviceCallable(const Model::MoPenCreateDeviceRequest& request) const;
MoPenDeleteGroupOutcome moPenDeleteGroup(const Model::MoPenDeleteGroupRequest &request)const;
void moPenDeleteGroupAsync(const Model::MoPenDeleteGroupRequest& request, const MoPenDeleteGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
MoPenDeleteGroupOutcomeCallable moPenDeleteGroupCallable(const Model::MoPenDeleteGroupRequest& request) const;
MoPenDeleteGroupMemberOutcome moPenDeleteGroupMember(const Model::MoPenDeleteGroupMemberRequest &request)const;
void moPenDeleteGroupMemberAsync(const Model::MoPenDeleteGroupMemberRequest& request, const MoPenDeleteGroupMemberAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
MoPenDeleteGroupMemberOutcomeCallable moPenDeleteGroupMemberCallable(const Model::MoPenDeleteGroupMemberRequest& request) const;
MoPenDoRecognizeOutcome moPenDoRecognize(const Model::MoPenDoRecognizeRequest &request)const;
void moPenDoRecognizeAsync(const Model::MoPenDoRecognizeRequest& request, const MoPenDoRecognizeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
MoPenDoRecognizeOutcomeCallable moPenDoRecognizeCallable(const Model::MoPenDoRecognizeRequest& request) const;
MoPenBindIsvOutcome moPenBindIsv(const Model::MoPenBindIsvRequest &request)const;
void moPenBindIsvAsync(const Model::MoPenBindIsvRequest& request, const MoPenBindIsvAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
MoPenBindIsvOutcomeCallable moPenBindIsvCallable(const Model::MoPenBindIsvRequest& request) const;
MoPenAddGroupMemberOutcome moPenAddGroupMember(const Model::MoPenAddGroupMemberRequest &request)const;
void moPenAddGroupMemberAsync(const Model::MoPenAddGroupMemberRequest& request, const MoPenAddGroupMemberAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
MoPenAddGroupMemberOutcomeCallable moPenAddGroupMemberCallable(const Model::MoPenAddGroupMemberRequest& request) const;
MoPenCreateDeviceOutcome moPenCreateDevice(const Model::MoPenCreateDeviceRequest &request)const;
void moPenCreateDeviceAsync(const Model::MoPenCreateDeviceRequest& request, const MoPenCreateDeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
MoPenCreateDeviceOutcomeCallable moPenCreateDeviceCallable(const Model::MoPenCreateDeviceRequest& request) const;
MoPenSendMqttMessageOutcome moPenSendMqttMessage(const Model::MoPenSendMqttMessageRequest &request)const;
void moPenSendMqttMessageAsync(const Model::MoPenSendMqttMessageRequest& request, const MoPenSendMqttMessageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
MoPenSendMqttMessageOutcomeCallable moPenSendMqttMessageCallable(const Model::MoPenSendMqttMessageRequest& request) const;
MoPenFindGroupOutcome moPenFindGroup(const Model::MoPenFindGroupRequest &request)const;
void moPenFindGroupAsync(const Model::MoPenFindGroupRequest& request, const MoPenFindGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
MoPenFindGroupOutcomeCallable moPenFindGroupCallable(const Model::MoPenFindGroupRequest& request) const;
MoPenDeleteGroupOutcome moPenDeleteGroup(const Model::MoPenDeleteGroupRequest &request)const;
void moPenDeleteGroupAsync(const Model::MoPenDeleteGroupRequest& request, const MoPenDeleteGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
MoPenDeleteGroupOutcomeCallable moPenDeleteGroupCallable(const Model::MoPenDeleteGroupRequest& request) const;
MoPenQueryCanvasOutcome moPenQueryCanvas(const Model::MoPenQueryCanvasRequest &request)const;
void moPenQueryCanvasAsync(const Model::MoPenQueryCanvasRequest& request, const MoPenQueryCanvasAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
MoPenQueryCanvasOutcomeCallable moPenQueryCanvasCallable(const Model::MoPenQueryCanvasRequest& request) const;
MoPenSendMqttMessageOutcome moPenSendMqttMessage(const Model::MoPenSendMqttMessageRequest &request)const;
void moPenSendMqttMessageAsync(const Model::MoPenSendMqttMessageRequest& request, const MoPenSendMqttMessageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
MoPenSendMqttMessageOutcomeCallable moPenSendMqttMessageCallable(const Model::MoPenSendMqttMessageRequest& request) const;
MopenCreateGroupOutcome mopenCreateGroup(const Model::MopenCreateGroupRequest &request)const;
void mopenCreateGroupAsync(const Model::MopenCreateGroupRequest& request, const MopenCreateGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
MopenCreateGroupOutcomeCallable mopenCreateGroupCallable(const Model::MopenCreateGroupRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;

View File

@@ -37,14 +37,14 @@ namespace AlibabaCloud
long getCanvasId()const;
void setCanvasId(long canvasId);
int getEndY()const;
void setEndY(int endY);
int getEndX()const;
void setEndX(int endX);
std::string getJsonConf()const;
void setJsonConf(const std::string& jsonConf);
std::string getExportType()const;
void setExportType(const std::string& exportType);
int getEndY()const;
void setEndY(int endY);
int getEndX()const;
void setEndX(int endX);
int getStartY()const;
void setStartY(int startY);
int getStartX()const;
@@ -52,10 +52,10 @@ namespace AlibabaCloud
private:
long canvasId_;
int endY_;
int endX_;
std::string jsonConf_;
std::string exportType_;
int endY_;
int endX_;
int startY_;
int startX_;

View File

@@ -51,72 +51,144 @@ MoPenClient::MoPenClient(const std::string & accessKeyId, const std::string & ac
MoPenClient::~MoPenClient()
{}
MoPenClient::MopenCreateGroupOutcome MoPenClient::mopenCreateGroup(const MopenCreateGroupRequest &request) const
MoPenClient::MoPenAddGroupMemberOutcome MoPenClient::moPenAddGroupMember(const MoPenAddGroupMemberRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return MopenCreateGroupOutcome(endpointOutcome.error());
return MoPenAddGroupMemberOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return MopenCreateGroupOutcome(MopenCreateGroupResult(outcome.result()));
return MoPenAddGroupMemberOutcome(MoPenAddGroupMemberResult(outcome.result()));
else
return MopenCreateGroupOutcome(outcome.error());
return MoPenAddGroupMemberOutcome(outcome.error());
}
void MoPenClient::mopenCreateGroupAsync(const MopenCreateGroupRequest& request, const MopenCreateGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void MoPenClient::moPenAddGroupMemberAsync(const MoPenAddGroupMemberRequest& request, const MoPenAddGroupMemberAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, mopenCreateGroup(request), context);
handler(this, request, moPenAddGroupMember(request), context);
};
asyncExecute(new Runnable(fn));
}
MoPenClient::MopenCreateGroupOutcomeCallable MoPenClient::mopenCreateGroupCallable(const MopenCreateGroupRequest &request) const
MoPenClient::MoPenAddGroupMemberOutcomeCallable MoPenClient::moPenAddGroupMemberCallable(const MoPenAddGroupMemberRequest &request) const
{
auto task = std::make_shared<std::packaged_task<MopenCreateGroupOutcome()>>(
auto task = std::make_shared<std::packaged_task<MoPenAddGroupMemberOutcome()>>(
[this, request]()
{
return this->mopenCreateGroup(request);
return this->moPenAddGroupMember(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MoPenClient::MoPenQueryCanvasOutcome MoPenClient::moPenQueryCanvas(const MoPenQueryCanvasRequest &request) const
MoPenClient::MoPenBindIsvOutcome MoPenClient::moPenBindIsv(const MoPenBindIsvRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return MoPenQueryCanvasOutcome(endpointOutcome.error());
return MoPenBindIsvOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return MoPenQueryCanvasOutcome(MoPenQueryCanvasResult(outcome.result()));
return MoPenBindIsvOutcome(MoPenBindIsvResult(outcome.result()));
else
return MoPenQueryCanvasOutcome(outcome.error());
return MoPenBindIsvOutcome(outcome.error());
}
void MoPenClient::moPenQueryCanvasAsync(const MoPenQueryCanvasRequest& request, const MoPenQueryCanvasAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void MoPenClient::moPenBindIsvAsync(const MoPenBindIsvRequest& request, const MoPenBindIsvAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, moPenQueryCanvas(request), context);
handler(this, request, moPenBindIsv(request), context);
};
asyncExecute(new Runnable(fn));
}
MoPenClient::MoPenQueryCanvasOutcomeCallable MoPenClient::moPenQueryCanvasCallable(const MoPenQueryCanvasRequest &request) const
MoPenClient::MoPenBindIsvOutcomeCallable MoPenClient::moPenBindIsvCallable(const MoPenBindIsvRequest &request) const
{
auto task = std::make_shared<std::packaged_task<MoPenQueryCanvasOutcome()>>(
auto task = std::make_shared<std::packaged_task<MoPenBindIsvOutcome()>>(
[this, request]()
{
return this->moPenQueryCanvas(request);
return this->moPenBindIsv(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MoPenClient::MoPenCreateDeviceOutcome MoPenClient::moPenCreateDevice(const MoPenCreateDeviceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return MoPenCreateDeviceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return MoPenCreateDeviceOutcome(MoPenCreateDeviceResult(outcome.result()));
else
return MoPenCreateDeviceOutcome(outcome.error());
}
void MoPenClient::moPenCreateDeviceAsync(const MoPenCreateDeviceRequest& request, const MoPenCreateDeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, moPenCreateDevice(request), context);
};
asyncExecute(new Runnable(fn));
}
MoPenClient::MoPenCreateDeviceOutcomeCallable MoPenClient::moPenCreateDeviceCallable(const MoPenCreateDeviceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<MoPenCreateDeviceOutcome()>>(
[this, request]()
{
return this->moPenCreateDevice(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MoPenClient::MoPenDeleteGroupOutcome MoPenClient::moPenDeleteGroup(const MoPenDeleteGroupRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return MoPenDeleteGroupOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return MoPenDeleteGroupOutcome(MoPenDeleteGroupResult(outcome.result()));
else
return MoPenDeleteGroupOutcome(outcome.error());
}
void MoPenClient::moPenDeleteGroupAsync(const MoPenDeleteGroupRequest& request, const MoPenDeleteGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, moPenDeleteGroup(request), context);
};
asyncExecute(new Runnable(fn));
}
MoPenClient::MoPenDeleteGroupOutcomeCallable MoPenClient::moPenDeleteGroupCallable(const MoPenDeleteGroupRequest &request) const
{
auto task = std::make_shared<std::packaged_task<MoPenDeleteGroupOutcome()>>(
[this, request]()
{
return this->moPenDeleteGroup(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
@@ -195,108 +267,72 @@ MoPenClient::MoPenDoRecognizeOutcomeCallable MoPenClient::moPenDoRecognizeCallab
return task->get_future();
}
MoPenClient::MoPenBindIsvOutcome MoPenClient::moPenBindIsv(const MoPenBindIsvRequest &request) const
MoPenClient::MoPenFindGroupOutcome MoPenClient::moPenFindGroup(const MoPenFindGroupRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return MoPenBindIsvOutcome(endpointOutcome.error());
return MoPenFindGroupOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return MoPenBindIsvOutcome(MoPenBindIsvResult(outcome.result()));
return MoPenFindGroupOutcome(MoPenFindGroupResult(outcome.result()));
else
return MoPenBindIsvOutcome(outcome.error());
return MoPenFindGroupOutcome(outcome.error());
}
void MoPenClient::moPenBindIsvAsync(const MoPenBindIsvRequest& request, const MoPenBindIsvAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void MoPenClient::moPenFindGroupAsync(const MoPenFindGroupRequest& request, const MoPenFindGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, moPenBindIsv(request), context);
handler(this, request, moPenFindGroup(request), context);
};
asyncExecute(new Runnable(fn));
}
MoPenClient::MoPenBindIsvOutcomeCallable MoPenClient::moPenBindIsvCallable(const MoPenBindIsvRequest &request) const
MoPenClient::MoPenFindGroupOutcomeCallable MoPenClient::moPenFindGroupCallable(const MoPenFindGroupRequest &request) const
{
auto task = std::make_shared<std::packaged_task<MoPenBindIsvOutcome()>>(
auto task = std::make_shared<std::packaged_task<MoPenFindGroupOutcome()>>(
[this, request]()
{
return this->moPenBindIsv(request);
return this->moPenFindGroup(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MoPenClient::MoPenAddGroupMemberOutcome MoPenClient::moPenAddGroupMember(const MoPenAddGroupMemberRequest &request) const
MoPenClient::MoPenQueryCanvasOutcome MoPenClient::moPenQueryCanvas(const MoPenQueryCanvasRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return MoPenAddGroupMemberOutcome(endpointOutcome.error());
return MoPenQueryCanvasOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return MoPenAddGroupMemberOutcome(MoPenAddGroupMemberResult(outcome.result()));
return MoPenQueryCanvasOutcome(MoPenQueryCanvasResult(outcome.result()));
else
return MoPenAddGroupMemberOutcome(outcome.error());
return MoPenQueryCanvasOutcome(outcome.error());
}
void MoPenClient::moPenAddGroupMemberAsync(const MoPenAddGroupMemberRequest& request, const MoPenAddGroupMemberAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void MoPenClient::moPenQueryCanvasAsync(const MoPenQueryCanvasRequest& request, const MoPenQueryCanvasAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, moPenAddGroupMember(request), context);
handler(this, request, moPenQueryCanvas(request), context);
};
asyncExecute(new Runnable(fn));
}
MoPenClient::MoPenAddGroupMemberOutcomeCallable MoPenClient::moPenAddGroupMemberCallable(const MoPenAddGroupMemberRequest &request) const
MoPenClient::MoPenQueryCanvasOutcomeCallable MoPenClient::moPenQueryCanvasCallable(const MoPenQueryCanvasRequest &request) const
{
auto task = std::make_shared<std::packaged_task<MoPenAddGroupMemberOutcome()>>(
auto task = std::make_shared<std::packaged_task<MoPenQueryCanvasOutcome()>>(
[this, request]()
{
return this->moPenAddGroupMember(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MoPenClient::MoPenCreateDeviceOutcome MoPenClient::moPenCreateDevice(const MoPenCreateDeviceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return MoPenCreateDeviceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return MoPenCreateDeviceOutcome(MoPenCreateDeviceResult(outcome.result()));
else
return MoPenCreateDeviceOutcome(outcome.error());
}
void MoPenClient::moPenCreateDeviceAsync(const MoPenCreateDeviceRequest& request, const MoPenCreateDeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, moPenCreateDevice(request), context);
};
asyncExecute(new Runnable(fn));
}
MoPenClient::MoPenCreateDeviceOutcomeCallable MoPenClient::moPenCreateDeviceCallable(const MoPenCreateDeviceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<MoPenCreateDeviceOutcome()>>(
[this, request]()
{
return this->moPenCreateDevice(request);
return this->moPenQueryCanvas(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
@@ -339,72 +375,36 @@ MoPenClient::MoPenSendMqttMessageOutcomeCallable MoPenClient::moPenSendMqttMessa
return task->get_future();
}
MoPenClient::MoPenFindGroupOutcome MoPenClient::moPenFindGroup(const MoPenFindGroupRequest &request) const
MoPenClient::MopenCreateGroupOutcome MoPenClient::mopenCreateGroup(const MopenCreateGroupRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return MoPenFindGroupOutcome(endpointOutcome.error());
return MopenCreateGroupOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return MoPenFindGroupOutcome(MoPenFindGroupResult(outcome.result()));
return MopenCreateGroupOutcome(MopenCreateGroupResult(outcome.result()));
else
return MoPenFindGroupOutcome(outcome.error());
return MopenCreateGroupOutcome(outcome.error());
}
void MoPenClient::moPenFindGroupAsync(const MoPenFindGroupRequest& request, const MoPenFindGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void MoPenClient::mopenCreateGroupAsync(const MopenCreateGroupRequest& request, const MopenCreateGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, moPenFindGroup(request), context);
handler(this, request, mopenCreateGroup(request), context);
};
asyncExecute(new Runnable(fn));
}
MoPenClient::MoPenFindGroupOutcomeCallable MoPenClient::moPenFindGroupCallable(const MoPenFindGroupRequest &request) const
MoPenClient::MopenCreateGroupOutcomeCallable MoPenClient::mopenCreateGroupCallable(const MopenCreateGroupRequest &request) const
{
auto task = std::make_shared<std::packaged_task<MoPenFindGroupOutcome()>>(
auto task = std::make_shared<std::packaged_task<MopenCreateGroupOutcome()>>(
[this, request]()
{
return this->moPenFindGroup(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MoPenClient::MoPenDeleteGroupOutcome MoPenClient::moPenDeleteGroup(const MoPenDeleteGroupRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return MoPenDeleteGroupOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return MoPenDeleteGroupOutcome(MoPenDeleteGroupResult(outcome.result()));
else
return MoPenDeleteGroupOutcome(outcome.error());
}
void MoPenClient::moPenDeleteGroupAsync(const MoPenDeleteGroupRequest& request, const MoPenDeleteGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, moPenDeleteGroup(request), context);
};
asyncExecute(new Runnable(fn));
}
MoPenClient::MoPenDeleteGroupOutcomeCallable MoPenClient::moPenDeleteGroupCallable(const MoPenDeleteGroupRequest &request) const
{
auto task = std::make_shared<std::packaged_task<MoPenDeleteGroupOutcome()>>(
[this, request]()
{
return this->moPenDeleteGroup(request);
return this->mopenCreateGroup(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));

View File

@@ -35,13 +35,9 @@ MoPenAddGroupMemberResult::~MoPenAddGroupMemberResult()
void MoPenAddGroupMemberResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";

View File

@@ -35,13 +35,9 @@ MoPenBindIsvResult::~MoPenBindIsvResult()
void MoPenBindIsvResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Code"].isNull())
code_ = value["Code"].asString() == "true";

View File

@@ -35,13 +35,9 @@ MoPenCreateDeviceResult::~MoPenCreateDeviceResult()
void MoPenCreateDeviceResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["DeviceName"].isNull())

View File

@@ -35,13 +35,9 @@ MoPenDeleteGroupMemberResult::~MoPenDeleteGroupMemberResult()
void MoPenDeleteGroupMemberResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Code"].isNull())
code_ = value["Code"].asString();

View File

@@ -35,13 +35,9 @@ MoPenDeleteGroupResult::~MoPenDeleteGroupResult()
void MoPenDeleteGroupResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";

View File

@@ -36,28 +36,6 @@ void MoPenDoRecognizeRequest::setCanvasId(long canvasId)
setCoreParameter("CanvasId", std::to_string(canvasId));
}
int MoPenDoRecognizeRequest::getEndY()const
{
return endY_;
}
void MoPenDoRecognizeRequest::setEndY(int endY)
{
endY_ = endY;
setCoreParameter("EndY", std::to_string(endY));
}
int MoPenDoRecognizeRequest::getEndX()const
{
return endX_;
}
void MoPenDoRecognizeRequest::setEndX(int endX)
{
endX_ = endX;
setCoreParameter("EndX", std::to_string(endX));
}
std::string MoPenDoRecognizeRequest::getJsonConf()const
{
return jsonConf_;
@@ -80,6 +58,28 @@ void MoPenDoRecognizeRequest::setExportType(const std::string& exportType)
setCoreParameter("ExportType", exportType);
}
int MoPenDoRecognizeRequest::getEndY()const
{
return endY_;
}
void MoPenDoRecognizeRequest::setEndY(int endY)
{
endY_ = endY;
setCoreParameter("EndY", std::to_string(endY));
}
int MoPenDoRecognizeRequest::getEndX()const
{
return endX_;
}
void MoPenDoRecognizeRequest::setEndX(int endX)
{
endX_ = endX;
setCoreParameter("EndX", std::to_string(endX));
}
int MoPenDoRecognizeRequest::getStartY()const
{
return startY_;

View File

@@ -35,13 +35,9 @@ MoPenDoRecognizeResult::~MoPenDoRecognizeResult()
void MoPenDoRecognizeResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["Result"].isNull())

View File

@@ -35,13 +35,9 @@ MoPenFindGroupResult::~MoPenFindGroupResult()
void MoPenFindGroupResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["GroupId"].isNull())

View File

@@ -35,13 +35,9 @@ MoPenQueryCanvasResult::~MoPenQueryCanvasResult()
void MoPenQueryCanvasResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
auto allCanvasList = value["CanvasList"]["Canvas"];

View File

@@ -35,13 +35,9 @@ MoPenSendMqttMessageResult::~MoPenSendMqttMessageResult()
void MoPenSendMqttMessageResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Code"].isNull())
code_ = value["Code"].asString();

View File

@@ -35,13 +35,9 @@ MopenCreateGroupResult::~MopenCreateGroupResult()
void MopenCreateGroupResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["GroupId"].isNull())