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

Generated 2015-03-03 for Ft.

Browse Source
This commit is contained in:
sdk-team
2023-08-23 07:51:19 +00:00
parent e65f74a248
commit 3fbe4829ca
32 changed files with 451 additions and 1000 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
VERSION
View File

@@ -1 +1 @@
1.36.1733
1.36.1734

36
ft/CMakeLists.txt
View File

@@ -21,33 +21,21 @@ set(ft_public_header
include/alibabacloud/ft/FtExport.h )
set(ft_public_header_model
include/alibabacloud/ft/model/DataRateLimitTestRequest.h
include/alibabacloud/ft/model/DataRateLimitTestResult.h
include/alibabacloud/ft/model/NormalRpcHsfApiRequest.h
include/alibabacloud/ft/model/NormalRpcHsfApiResult.h
include/alibabacloud/ft/model/NormalRpcHttpApiRequest.h
include/alibabacloud/ft/model/NormalRpcHttpApiResult.h
include/alibabacloud/ft/model/RpcDataUploadRequest.h
include/alibabacloud/ft/model/RpcDataUploadResult.h
include/alibabacloud/ft/model/RpcDataUploadAndDownloadRequest.h
include/alibabacloud/ft/model/RpcDataUploadAndDownloadResult.h
include/alibabacloud/ft/model/RpcDataUploadTestRequest.h
include/alibabacloud/ft/model/RpcDataUploadTestResult.h )
include/alibabacloud/ft/model/CreateInsRequest.h
include/alibabacloud/ft/model/CreateInsResult.h
include/alibabacloud/ft/model/RpcNoDefaultErrorCodeApiRequest.h
include/alibabacloud/ft/model/RpcNoDefaultErrorCodeApiResult.h
include/alibabacloud/ft/model/UpdateInsRequest.h
include/alibabacloud/ft/model/UpdateInsResult.h )
set(ft_src
src/FtClient.cc
src/model/DataRateLimitTestRequest.cc
src/model/DataRateLimitTestResult.cc
src/model/NormalRpcHsfApiRequest.cc
src/model/NormalRpcHsfApiResult.cc
src/model/NormalRpcHttpApiRequest.cc
src/model/NormalRpcHttpApiResult.cc
src/model/RpcDataUploadRequest.cc
src/model/RpcDataUploadResult.cc
src/model/RpcDataUploadAndDownloadRequest.cc
src/model/RpcDataUploadAndDownloadResult.cc
src/model/RpcDataUploadTestRequest.cc
src/model/RpcDataUploadTestResult.cc )
src/model/CreateInsRequest.cc
src/model/CreateInsResult.cc
src/model/RpcNoDefaultErrorCodeApiRequest.cc
src/model/RpcNoDefaultErrorCodeApiResult.cc
src/model/UpdateInsRequest.cc
src/model/UpdateInsResult.cc )
add_library(ft ${LIB_TYPE}
${ft_public_header}

72
ft/include/alibabacloud/ft/FtClient.h
View File

@@ -22,18 +22,12 @@
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "FtExport.h"
#include "model/DataRateLimitTestRequest.h"
#include "model/DataRateLimitTestResult.h"
#include "model/NormalRpcHsfApiRequest.h"
#include "model/NormalRpcHsfApiResult.h"
#include "model/NormalRpcHttpApiRequest.h"
#include "model/NormalRpcHttpApiResult.h"
#include "model/RpcDataUploadRequest.h"
#include "model/RpcDataUploadResult.h"
#include "model/RpcDataUploadAndDownloadRequest.h"
#include "model/RpcDataUploadAndDownloadResult.h"
#include "model/RpcDataUploadTestRequest.h"
#include "model/RpcDataUploadTestResult.h"
#include "model/CreateInsRequest.h"
#include "model/CreateInsResult.h"
#include "model/RpcNoDefaultErrorCodeApiRequest.h"
#include "model/RpcNoDefaultErrorCodeApiResult.h"
#include "model/UpdateInsRequest.h"
#include "model/UpdateInsResult.h"
namespace AlibabaCloud
@@ -43,47 +37,29 @@ namespace AlibabaCloud
class ALIBABACLOUD_FT_EXPORT FtClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::DataRateLimitTestResult> DataRateLimitTestOutcome;
typedef std::future<DataRateLimitTestOutcome> DataRateLimitTestOutcomeCallable;
typedef std::function<void(const FtClient*, const Model::DataRateLimitTestRequest&, const DataRateLimitTestOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DataRateLimitTestAsyncHandler;
typedef Outcome<Error, Model::NormalRpcHsfApiResult> NormalRpcHsfApiOutcome;
typedef std::future<NormalRpcHsfApiOutcome> NormalRpcHsfApiOutcomeCallable;
typedef std::function<void(const FtClient*, const Model::NormalRpcHsfApiRequest&, const NormalRpcHsfApiOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> NormalRpcHsfApiAsyncHandler;
typedef Outcome<Error, Model::NormalRpcHttpApiResult> NormalRpcHttpApiOutcome;
typedef std::future<NormalRpcHttpApiOutcome> NormalRpcHttpApiOutcomeCallable;
typedef std::function<void(const FtClient*, const Model::NormalRpcHttpApiRequest&, const NormalRpcHttpApiOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> NormalRpcHttpApiAsyncHandler;
typedef Outcome<Error, Model::RpcDataUploadResult> RpcDataUploadOutcome;
typedef std::future<RpcDataUploadOutcome> RpcDataUploadOutcomeCallable;
typedef std::function<void(const FtClient*, const Model::RpcDataUploadRequest&, const RpcDataUploadOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RpcDataUploadAsyncHandler;
typedef Outcome<Error, Model::RpcDataUploadAndDownloadResult> RpcDataUploadAndDownloadOutcome;
typedef std::future<RpcDataUploadAndDownloadOutcome> RpcDataUploadAndDownloadOutcomeCallable;
typedef std::function<void(const FtClient*, const Model::RpcDataUploadAndDownloadRequest&, const RpcDataUploadAndDownloadOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RpcDataUploadAndDownloadAsyncHandler;
typedef Outcome<Error, Model::RpcDataUploadTestResult> RpcDataUploadTestOutcome;
typedef std::future<RpcDataUploadTestOutcome> RpcDataUploadTestOutcomeCallable;
typedef std::function<void(const FtClient*, const Model::RpcDataUploadTestRequest&, const RpcDataUploadTestOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RpcDataUploadTestAsyncHandler;
typedef Outcome<Error, Model::CreateInsResult> CreateInsOutcome;
typedef std::future<CreateInsOutcome> CreateInsOutcomeCallable;
typedef std::function<void(const FtClient*, const Model::CreateInsRequest&, const CreateInsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateInsAsyncHandler;
typedef Outcome<Error, Model::RpcNoDefaultErrorCodeApiResult> RpcNoDefaultErrorCodeApiOutcome;
typedef std::future<RpcNoDefaultErrorCodeApiOutcome> RpcNoDefaultErrorCodeApiOutcomeCallable;
typedef std::function<void(const FtClient*, const Model::RpcNoDefaultErrorCodeApiRequest&, const RpcNoDefaultErrorCodeApiOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RpcNoDefaultErrorCodeApiAsyncHandler;
typedef Outcome<Error, Model::UpdateInsResult> UpdateInsOutcome;
typedef std::future<UpdateInsOutcome> UpdateInsOutcomeCallable;
typedef std::function<void(const FtClient*, const Model::UpdateInsRequest&, const UpdateInsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateInsAsyncHandler;
FtClient(const Credentials &credentials, const ClientConfiguration &configuration);
FtClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
FtClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~FtClient();
DataRateLimitTestOutcome dataRateLimitTest(const Model::DataRateLimitTestRequest &request)const;
void dataRateLimitTestAsync(const Model::DataRateLimitTestRequest& request, const DataRateLimitTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DataRateLimitTestOutcomeCallable dataRateLimitTestCallable(const Model::DataRateLimitTestRequest& request) const;
NormalRpcHsfApiOutcome normalRpcHsfApi(const Model::NormalRpcHsfApiRequest &request)const;
void normalRpcHsfApiAsync(const Model::NormalRpcHsfApiRequest& request, const NormalRpcHsfApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
NormalRpcHsfApiOutcomeCallable normalRpcHsfApiCallable(const Model::NormalRpcHsfApiRequest& request) const;
NormalRpcHttpApiOutcome normalRpcHttpApi(const Model::NormalRpcHttpApiRequest &request)const;
void normalRpcHttpApiAsync(const Model::NormalRpcHttpApiRequest& request, const NormalRpcHttpApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
NormalRpcHttpApiOutcomeCallable normalRpcHttpApiCallable(const Model::NormalRpcHttpApiRequest& request) const;
RpcDataUploadOutcome rpcDataUpload(const Model::RpcDataUploadRequest &request)const;
void rpcDataUploadAsync(const Model::RpcDataUploadRequest& request, const RpcDataUploadAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RpcDataUploadOutcomeCallable rpcDataUploadCallable(const Model::RpcDataUploadRequest& request) const;
RpcDataUploadAndDownloadOutcome rpcDataUploadAndDownload(const Model::RpcDataUploadAndDownloadRequest &request)const;
void rpcDataUploadAndDownloadAsync(const Model::RpcDataUploadAndDownloadRequest& request, const RpcDataUploadAndDownloadAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RpcDataUploadAndDownloadOutcomeCallable rpcDataUploadAndDownloadCallable(const Model::RpcDataUploadAndDownloadRequest& request) const;
RpcDataUploadTestOutcome rpcDataUploadTest(const Model::RpcDataUploadTestRequest &request)const;
void rpcDataUploadTestAsync(const Model::RpcDataUploadTestRequest& request, const RpcDataUploadTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RpcDataUploadTestOutcomeCallable rpcDataUploadTestCallable(const Model::RpcDataUploadTestRequest& request) const;
CreateInsOutcome createIns(const Model::CreateInsRequest &request)const;
void createInsAsync(const Model::CreateInsRequest& request, const CreateInsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateInsOutcomeCallable createInsCallable(const Model::CreateInsRequest& request) const;
RpcNoDefaultErrorCodeApiOutcome rpcNoDefaultErrorCodeApi(const Model::RpcNoDefaultErrorCodeApiRequest &request)const;
void rpcNoDefaultErrorCodeApiAsync(const Model::RpcNoDefaultErrorCodeApiRequest& request, const RpcNoDefaultErrorCodeApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RpcNoDefaultErrorCodeApiOutcomeCallable rpcNoDefaultErrorCodeApiCallable(const Model::RpcNoDefaultErrorCodeApiRequest& request) const;
UpdateInsOutcome updateIns(const Model::UpdateInsRequest &request)const;
void updateInsAsync(const Model::UpdateInsRequest& request, const UpdateInsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateInsOutcomeCallable updateInsCallable(const Model::UpdateInsRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;

36
ft/include/alibabacloud/ft/model/DataRateLimitTestRequest.h → ft/include/alibabacloud/ft/model/CreateInsRequest.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FT_MODEL_DATARATELIMITTESTREQUEST_H_
#define ALIBABACLOUD_FT_MODEL_DATARATELIMITTESTREQUEST_H_
#ifndef ALIBABACLOUD_FT_MODEL_CREATEINSREQUEST_H_
#define ALIBABACLOUD_FT_MODEL_CREATEINSREQUEST_H_
#include <alibabacloud/ft/FtExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
@@ -26,26 +26,32 @@
namespace AlibabaCloud {
namespace Ft {
namespace Model {
class ALIBABACLOUD_FT_EXPORT DataRateLimitTestRequest : public RpcServiceRequest {
class ALIBABACLOUD_FT_EXPORT CreateInsRequest : public RpcServiceRequest {
public:
DataRateLimitTestRequest();
~DataRateLimitTestRequest();
std::string getNewparam2() const;
void setNewparam2(const std::string &newparam2);
CreateInsRequest();
~CreateInsRequest();
std::string getNewparam1() const;
void setNewparam1(const std::string &newparam1);
std::string getData() const;
void setData(const std::string &data);
std::string getMap() const;
void setMap(const std::string &map);
std::string getBind() const;
void setBind(const std::string &bind);
std::string getTest() const;
void setTest(const std::string &test);
std::string getSuccess() const;
void setSuccess(const std::string &success);
std::string getTime() const;
void setTime(const std::string &time);
std::string getNewPala() const;
void setNewPala(const std::string &newPala);
private:
std::string newparam2_;
std::string newparam1_;
std::string data_;
std::string map_;
std::string bind_;
std::string test_;
std::string success_;
std::string time_;
std::string newPala_;
};
} // namespace Model
} // namespace Ft
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_FT_MODEL_DATARATELIMITTESTREQUEST_H_
#endif // !ALIBABACLOUD_FT_MODEL_CREATEINSREQUEST_H_

18
ft/include/alibabacloud/ft/model/NormalRpcHttpApiResult.h → ft/include/alibabacloud/ft/model/CreateInsResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FT_MODEL_NORMALRPCHTTPAPIRESULT_H_
#define ALIBABACLOUD_FT_MODEL_NORMALRPCHTTPAPIRESULT_H_
#ifndef ALIBABACLOUD_FT_MODEL_CREATEINSRESULT_H_
#define ALIBABACLOUD_FT_MODEL_CREATEINSRESULT_H_
#include <string>
#include <vector>
@@ -29,21 +29,25 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_FT_EXPORT NormalRpcHttpApiResult : public ServiceResult
class ALIBABACLOUD_FT_EXPORT CreateInsResult : public ServiceResult
{
public:
NormalRpcHttpApiResult();
explicit NormalRpcHttpApiResult(const std::string &payload);
~NormalRpcHttpApiResult();
CreateInsResult();
explicit CreateInsResult(const std::string &payload);
~CreateInsResult();
std::string getCode()const;
std::string getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string code_;
std::string success_;
};
}
}
}
#endif // !ALIBABACLOUD_FT_MODEL_NORMALRPCHTTPAPIRESULT_H_
#endif // !ALIBABACLOUD_FT_MODEL_CREATEINSRESULT_H_

39
ft/include/alibabacloud/ft/model/NormalRpcHsfApiRequest.h
View File

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

49
ft/include/alibabacloud/ft/model/NormalRpcHsfApiResult.h
View File

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

39
ft/include/alibabacloud/ft/model/NormalRpcHttpApiRequest.h
View File

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

42
ft/include/alibabacloud/ft/model/RpcDataUploadAndDownloadRequest.h
View File

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

48
ft/include/alibabacloud/ft/model/RpcDataUploadRequest.h
View File

@@ -1,48 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADREQUEST_H_
#define ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADREQUEST_H_
#include <alibabacloud/ft/FtExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ft {
namespace Model {
class ALIBABACLOUD_FT_EXPORT RpcDataUploadRequest : public RpcServiceRequest {
public:
RpcDataUploadRequest();
~RpcDataUploadRequest();
std::string getQuery1() const;
void setQuery1(const std::string &query1);
long getQuery2() const;
void setQuery2(long query2);
std::string getLargeParam() const;
void setLargeParam(const std::string &largeParam);
private:
std::string query1_;
long query2_;
std::string largeParam_;
};
} // namespace Model
} // namespace Ft
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADREQUEST_H_

61
ft/include/alibabacloud/ft/model/RpcDataUploadResult.h
View File

@@ -1,61 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADRESULT_H_
#define ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ft/FtExport.h>
namespace AlibabaCloud
{
namespace Ft
{
namespace Model
{
class ALIBABACLOUD_FT_EXPORT RpcDataUploadResult : public ServiceResult
{
public:
RpcDataUploadResult();
explicit RpcDataUploadResult(const std::string &payload);
~RpcDataUploadResult();
std::string getSpeed()const;
std::string getHeaders()const;
long getTotalBytes()const;
long getTotalTime()const;
std::string getParams()const;
std::string getUrl()const;
protected:
void parse(const std::string &payload);
private:
std::string speed_;
std::string headers_;
long totalBytes_;
long totalTime_;
std::string params_;
std::string url_;
};
}
}
}
#endif // !ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADRESULT_H_

49
ft/include/alibabacloud/ft/model/RpcDataUploadTestResult.h
View File

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

57
ft/include/alibabacloud/ft/model/RpcNoDefaultErrorCodeApiRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FT_MODEL_RPCNODEFAULTERRORCODEAPIREQUEST_H_
#define ALIBABACLOUD_FT_MODEL_RPCNODEFAULTERRORCODEAPIREQUEST_H_
#include <alibabacloud/ft/FtExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ft {
namespace Model {
class ALIBABACLOUD_FT_EXPORT RpcNoDefaultErrorCodeApiRequest : public RpcServiceRequest {
public:
RpcNoDefaultErrorCodeApiRequest();
~RpcNoDefaultErrorCodeApiRequest();
std::string getHttpMe() const;
void setHttpMe(const std::string &httpMe);
std::string getHttpStatusCode() const;
void setHttpStatusCode(const std::string &httpStatusCode);
std::string getSetUser() const;
void setSetUser(const std::string &setUser);
std::string getCode() const;
void setCode(const std::string &code);
std::string getSuccess() const;
void setSuccess(const std::string &success);
std::string getMessage() const;
void setMessage(const std::string &message);
private:
std::string httpMe_;
std::string httpStatusCode_;
std::string setUser_;
std::string code_;
std::string success_;
std::string message_;
};
} // namespace Model
} // namespace Ft
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_FT_MODEL_RPCNODEFAULTERRORCODEAPIREQUEST_H_

18
ft/include/alibabacloud/ft/model/RpcDataUploadAndDownloadResult.h → ft/include/alibabacloud/ft/model/RpcNoDefaultErrorCodeApiResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADANDDOWNLOADRESULT_H_
#define ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADANDDOWNLOADRESULT_H_
#ifndef ALIBABACLOUD_FT_MODEL_RPCNODEFAULTERRORCODEAPIRESULT_H_
#define ALIBABACLOUD_FT_MODEL_RPCNODEFAULTERRORCODEAPIRESULT_H_
#include <string>
#include <vector>
@@ -29,21 +29,25 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_FT_EXPORT RpcDataUploadAndDownloadResult : public ServiceResult
class ALIBABACLOUD_FT_EXPORT RpcNoDefaultErrorCodeApiResult : public ServiceResult
{
public:
RpcDataUploadAndDownloadResult();
explicit RpcDataUploadAndDownloadResult(const std::string &payload);
~RpcDataUploadAndDownloadResult();
RpcNoDefaultErrorCodeApiResult();
explicit RpcNoDefaultErrorCodeApiResult(const std::string &payload);
~RpcNoDefaultErrorCodeApiResult();
std::string getCode()const;
std::string getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string code_;
std::string success_;
};
}
}
}
#endif // !ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADANDDOWNLOADRESULT_H_
#endif // !ALIBABACLOUD_FT_MODEL_RPCNODEFAULTERRORCODEAPIRESULT_H_

18
ft/include/alibabacloud/ft/model/RpcDataUploadTestRequest.h → ft/include/alibabacloud/ft/model/UpdateInsRequest.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADTESTREQUEST_H_
#define ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADTESTREQUEST_H_
#ifndef ALIBABACLOUD_FT_MODEL_UPDATEINSREQUEST_H_
#define ALIBABACLOUD_FT_MODEL_UPDATEINSREQUEST_H_
#include <alibabacloud/ft/FtExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
@@ -26,14 +26,20 @@
namespace AlibabaCloud {
namespace Ft {
namespace Model {
class ALIBABACLOUD_FT_EXPORT RpcDataUploadTestRequest : public RpcServiceRequest {
class ALIBABACLOUD_FT_EXPORT UpdateInsRequest : public RpcServiceRequest {
public:
RpcDataUploadTestRequest();
~RpcDataUploadTestRequest();
UpdateInsRequest();
~UpdateInsRequest();
std::string getSucceed() const;
void setSucceed(const std::string &succeed);
std::string getHttpStatusCode1() const;
void setHttpStatusCode1(const std::string &httpStatusCode1);
private:
std::string succeed_;
std::string httpStatusCode1_;
};
} // namespace Model
} // namespace Ft
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADTESTREQUEST_H_
#endif // !ALIBABACLOUD_FT_MODEL_UPDATEINSREQUEST_H_

18
ft/include/alibabacloud/ft/model/DataRateLimitTestResult.h → ft/include/alibabacloud/ft/model/UpdateInsResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FT_MODEL_DATARATELIMITTESTRESULT_H_
#define ALIBABACLOUD_FT_MODEL_DATARATELIMITTESTRESULT_H_
#ifndef ALIBABACLOUD_FT_MODEL_UPDATEINSRESULT_H_
#define ALIBABACLOUD_FT_MODEL_UPDATEINSRESULT_H_
#include <string>
#include <vector>
@@ -29,21 +29,25 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_FT_EXPORT DataRateLimitTestResult : public ServiceResult
class ALIBABACLOUD_FT_EXPORT UpdateInsResult : public ServiceResult
{
public:
DataRateLimitTestResult();
explicit DataRateLimitTestResult(const std::string &payload);
~DataRateLimitTestResult();
UpdateInsResult();
explicit UpdateInsResult(const std::string &payload);
~UpdateInsResult();
std::string getCode()const;
std::string getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string code_;
std::string success_;
};
}
}
}
#endif // !ALIBABACLOUD_FT_MODEL_DATARATELIMITTESTRESULT_H_
#endif // !ALIBABACLOUD_FT_MODEL_UPDATEINSRESULT_H_

162
ft/src/FtClient.cc
View File

@@ -51,216 +51,108 @@ FtClient::FtClient(const std::string & accessKeyId, const std::string & accessKe
FtClient::~FtClient()
{}
FtClient::DataRateLimitTestOutcome FtClient::dataRateLimitTest(const DataRateLimitTestRequest &request) const
FtClient::CreateInsOutcome FtClient::createIns(const CreateInsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DataRateLimitTestOutcome(endpointOutcome.error());
return CreateInsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DataRateLimitTestOutcome(DataRateLimitTestResult(outcome.result()));
return CreateInsOutcome(CreateInsResult(outcome.result()));
else
return DataRateLimitTestOutcome(outcome.error());
return CreateInsOutcome(outcome.error());
}
void FtClient::dataRateLimitTestAsync(const DataRateLimitTestRequest& request, const DataRateLimitTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void FtClient::createInsAsync(const CreateInsRequest& request, const CreateInsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, dataRateLimitTest(request), context);
handler(this, request, createIns(request), context);
};
asyncExecute(new Runnable(fn));
}
FtClient::DataRateLimitTestOutcomeCallable FtClient::dataRateLimitTestCallable(const DataRateLimitTestRequest &request) const
FtClient::CreateInsOutcomeCallable FtClient::createInsCallable(const CreateInsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DataRateLimitTestOutcome()>>(
auto task = std::make_shared<std::packaged_task<CreateInsOutcome()>>(
[this, request]()
{
return this->dataRateLimitTest(request);
return this->createIns(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FtClient::NormalRpcHsfApiOutcome FtClient::normalRpcHsfApi(const NormalRpcHsfApiRequest &request) const
FtClient::RpcNoDefaultErrorCodeApiOutcome FtClient::rpcNoDefaultErrorCodeApi(const RpcNoDefaultErrorCodeApiRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return NormalRpcHsfApiOutcome(endpointOutcome.error());
return RpcNoDefaultErrorCodeApiOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return NormalRpcHsfApiOutcome(NormalRpcHsfApiResult(outcome.result()));
return RpcNoDefaultErrorCodeApiOutcome(RpcNoDefaultErrorCodeApiResult(outcome.result()));
else
return NormalRpcHsfApiOutcome(outcome.error());
return RpcNoDefaultErrorCodeApiOutcome(outcome.error());
}
void FtClient::normalRpcHsfApiAsync(const NormalRpcHsfApiRequest& request, const NormalRpcHsfApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void FtClient::rpcNoDefaultErrorCodeApiAsync(const RpcNoDefaultErrorCodeApiRequest& request, const RpcNoDefaultErrorCodeApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, normalRpcHsfApi(request), context);
handler(this, request, rpcNoDefaultErrorCodeApi(request), context);
};
asyncExecute(new Runnable(fn));
}
FtClient::NormalRpcHsfApiOutcomeCallable FtClient::normalRpcHsfApiCallable(const NormalRpcHsfApiRequest &request) const
FtClient::RpcNoDefaultErrorCodeApiOutcomeCallable FtClient::rpcNoDefaultErrorCodeApiCallable(const RpcNoDefaultErrorCodeApiRequest &request) const
{
auto task = std::make_shared<std::packaged_task<NormalRpcHsfApiOutcome()>>(
auto task = std::make_shared<std::packaged_task<RpcNoDefaultErrorCodeApiOutcome()>>(
[this, request]()
{
return this->normalRpcHsfApi(request);
return this->rpcNoDefaultErrorCodeApi(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FtClient::NormalRpcHttpApiOutcome FtClient::normalRpcHttpApi(const NormalRpcHttpApiRequest &request) const
FtClient::UpdateInsOutcome FtClient::updateIns(const UpdateInsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return NormalRpcHttpApiOutcome(endpointOutcome.error());
return UpdateInsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return NormalRpcHttpApiOutcome(NormalRpcHttpApiResult(outcome.result()));
return UpdateInsOutcome(UpdateInsResult(outcome.result()));
else
return NormalRpcHttpApiOutcome(outcome.error());
return UpdateInsOutcome(outcome.error());
}
void FtClient::normalRpcHttpApiAsync(const NormalRpcHttpApiRequest& request, const NormalRpcHttpApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void FtClient::updateInsAsync(const UpdateInsRequest& request, const UpdateInsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, normalRpcHttpApi(request), context);
handler(this, request, updateIns(request), context);
};
asyncExecute(new Runnable(fn));
}
FtClient::NormalRpcHttpApiOutcomeCallable FtClient::normalRpcHttpApiCallable(const NormalRpcHttpApiRequest &request) const
FtClient::UpdateInsOutcomeCallable FtClient::updateInsCallable(const UpdateInsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<NormalRpcHttpApiOutcome()>>(
auto task = std::make_shared<std::packaged_task<UpdateInsOutcome()>>(
[this, request]()
{
return this->normalRpcHttpApi(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FtClient::RpcDataUploadOutcome FtClient::rpcDataUpload(const RpcDataUploadRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RpcDataUploadOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RpcDataUploadOutcome(RpcDataUploadResult(outcome.result()));
else
return RpcDataUploadOutcome(outcome.error());
}
void FtClient::rpcDataUploadAsync(const RpcDataUploadRequest& request, const RpcDataUploadAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, rpcDataUpload(request), context);
};
asyncExecute(new Runnable(fn));
}
FtClient::RpcDataUploadOutcomeCallable FtClient::rpcDataUploadCallable(const RpcDataUploadRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RpcDataUploadOutcome()>>(
[this, request]()
{
return this->rpcDataUpload(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FtClient::RpcDataUploadAndDownloadOutcome FtClient::rpcDataUploadAndDownload(const RpcDataUploadAndDownloadRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RpcDataUploadAndDownloadOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RpcDataUploadAndDownloadOutcome(RpcDataUploadAndDownloadResult(outcome.result()));
else
return RpcDataUploadAndDownloadOutcome(outcome.error());
}
void FtClient::rpcDataUploadAndDownloadAsync(const RpcDataUploadAndDownloadRequest& request, const RpcDataUploadAndDownloadAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, rpcDataUploadAndDownload(request), context);
};
asyncExecute(new Runnable(fn));
}
FtClient::RpcDataUploadAndDownloadOutcomeCallable FtClient::rpcDataUploadAndDownloadCallable(const RpcDataUploadAndDownloadRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RpcDataUploadAndDownloadOutcome()>>(
[this, request]()
{
return this->rpcDataUploadAndDownload(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FtClient::RpcDataUploadTestOutcome FtClient::rpcDataUploadTest(const RpcDataUploadTestRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RpcDataUploadTestOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RpcDataUploadTestOutcome(RpcDataUploadTestResult(outcome.result()));
else
return RpcDataUploadTestOutcome(outcome.error());
}
void FtClient::rpcDataUploadTestAsync(const RpcDataUploadTestRequest& request, const RpcDataUploadTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, rpcDataUploadTest(request), context);
};
asyncExecute(new Runnable(fn));
}
FtClient::RpcDataUploadTestOutcomeCallable FtClient::rpcDataUploadTestCallable(const RpcDataUploadTestRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RpcDataUploadTestOutcome()>>(
[this, request]()
{
return this->rpcDataUploadTest(request);
return this->updateIns(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));

81
ft/src/model/CreateInsRequest.cc Normal file
View File

@@ -0,0 +1,81 @@
/*
* 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/ft/model/CreateInsRequest.h>
using AlibabaCloud::Ft::Model::CreateInsRequest;
CreateInsRequest::CreateInsRequest()
: RpcServiceRequest("ft", "2015-03-03", "CreateIns") {
setMethod(HttpRequest::Method::Post);
}
CreateInsRequest::~CreateInsRequest() {}
std::string CreateInsRequest::getNewparam1() const {
return newparam1_;
}
void CreateInsRequest::setNewparam1(const std::string &newparam1) {
newparam1_ = newparam1;
setParameter(std::string("new-param-1"), newparam1);
}
std::string CreateInsRequest::getBind() const {
return bind_;
}
void CreateInsRequest::setBind(const std::string &bind) {
bind_ = bind;
setParameter(std::string("Bind"), bind);
}
std::string CreateInsRequest::getTest() const {
return test_;
}
void CreateInsRequest::setTest(const std::string &test) {
test_ = test;
setParameter(std::string("Test"), test);
}
std::string CreateInsRequest::getSuccess() const {
return success_;
}
void CreateInsRequest::setSuccess(const std::string &success) {
success_ = success;
setParameter(std::string("Success"), success);
}
std::string CreateInsRequest::getTime() const {
return time_;
}
void CreateInsRequest::setTime(const std::string &time) {
time_ = time;
setParameter(std::string("Time"), time);
}
std::string CreateInsRequest::getNewPala() const {
return newPala_;
}
void CreateInsRequest::setNewPala(const std::string &newPala) {
newPala_ = newPala;
setParameter(std::string("NewPala"), newPala);
}

24
ft/src/model/RpcDataUploadAndDownloadResult.cc → ft/src/model/CreateInsResult.cc
View File

@@ -14,31 +14,45 @@
* limitations under the License.
*/
#include <alibabacloud/ft/model/RpcDataUploadAndDownloadResult.h>
#include <alibabacloud/ft/model/CreateInsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ft;
using namespace AlibabaCloud::Ft::Model;
RpcDataUploadAndDownloadResult::RpcDataUploadAndDownloadResult() :
CreateInsResult::CreateInsResult() :
ServiceResult()
{}
RpcDataUploadAndDownloadResult::RpcDataUploadAndDownloadResult(const std::string &payload) :
CreateInsResult::CreateInsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
RpcDataUploadAndDownloadResult::~RpcDataUploadAndDownloadResult()
CreateInsResult::~CreateInsResult()
{}
void RpcDataUploadAndDownloadResult::parse(const std::string &payload)
void CreateInsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString();
}
std::string CreateInsResult::getCode()const
{
return code_;
}
std::string CreateInsResult::getSuccess()const
{
return success_;
}

63
ft/src/model/DataRateLimitTestRequest.cc
View File

@@ -1,63 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ft/model/DataRateLimitTestRequest.h>
using AlibabaCloud::Ft::Model::DataRateLimitTestRequest;
DataRateLimitTestRequest::DataRateLimitTestRequest()
: RpcServiceRequest("ft", "2021-01-01", "DataRateLimitTest") {
setMethod(HttpRequest::Method::Post);
}
DataRateLimitTestRequest::~DataRateLimitTestRequest() {}
std::string DataRateLimitTestRequest::getNewparam2() const {
return newparam2_;
}
void DataRateLimitTestRequest::setNewparam2(const std::string &newparam2) {
newparam2_ = newparam2;
setParameter(std::string("new-param-2"), newparam2);
}
std::string DataRateLimitTestRequest::getNewparam1() const {
return newparam1_;
}
void DataRateLimitTestRequest::setNewparam1(const std::string &newparam1) {
newparam1_ = newparam1;
setParameter(std::string("new-param-1"), newparam1);
}
std::string DataRateLimitTestRequest::getData() const {
return data_;
}
void DataRateLimitTestRequest::setData(const std::string &data) {
data_ = data;
setParameter(std::string("Data"), data);
}
std::string DataRateLimitTestRequest::getMap() const {
return map_;
}
void DataRateLimitTestRequest::setMap(const std::string &map) {
map_ = map;
setParameter(std::string("Map"), map);
}

27
ft/src/model/NormalRpcHsfApiRequest.cc
View File

@@ -1,27 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ft/model/NormalRpcHsfApiRequest.h>
using AlibabaCloud::Ft::Model::NormalRpcHsfApiRequest;
NormalRpcHsfApiRequest::NormalRpcHsfApiRequest()
: RpcServiceRequest("ft", "2021-01-01", "NormalRpcHsfApi") {
setMethod(HttpRequest::Method::Get);
}
NormalRpcHsfApiRequest::~NormalRpcHsfApiRequest() {}

27
ft/src/model/NormalRpcHttpApiRequest.cc
View File

@@ -1,27 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ft/model/NormalRpcHttpApiRequest.h>
using AlibabaCloud::Ft::Model::NormalRpcHttpApiRequest;
NormalRpcHttpApiRequest::NormalRpcHttpApiRequest()
: RpcServiceRequest("ft", "2021-01-01", "NormalRpcHttpApi") {
setMethod(HttpRequest::Method::Get);
}
NormalRpcHttpApiRequest::~NormalRpcHttpApiRequest() {}

44
ft/src/model/NormalRpcHttpApiResult.cc
View File

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

36
ft/src/model/RpcDataUploadAndDownloadRequest.cc
View File

@@ -1,36 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ft/model/RpcDataUploadAndDownloadRequest.h>
using AlibabaCloud::Ft::Model::RpcDataUploadAndDownloadRequest;
RpcDataUploadAndDownloadRequest::RpcDataUploadAndDownloadRequest()
: RpcServiceRequest("ft", "2021-01-01", "RpcDataUploadAndDownload") {
setMethod(HttpRequest::Method::Post);
}
RpcDataUploadAndDownloadRequest::~RpcDataUploadAndDownloadRequest() {}
std::string RpcDataUploadAndDownloadRequest::getQuery1() const {
return query1_;
}
void RpcDataUploadAndDownloadRequest::setQuery1(const std::string &query1) {
query1_ = query1;
setParameter(std::string("query1"), query1);
}

54
ft/src/model/RpcDataUploadRequest.cc
View File

@@ -1,54 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ft/model/RpcDataUploadRequest.h>
using AlibabaCloud::Ft::Model::RpcDataUploadRequest;
RpcDataUploadRequest::RpcDataUploadRequest()
: RpcServiceRequest("ft", "2021-01-01", "RpcDataUpload") {
setMethod(HttpRequest::Method::Post);
}
RpcDataUploadRequest::~RpcDataUploadRequest() {}
std::string RpcDataUploadRequest::getQuery1() const {
return query1_;
}
void RpcDataUploadRequest::setQuery1(const std::string &query1) {
query1_ = query1;
setParameter(std::string("query1"), query1);
}
long RpcDataUploadRequest::getQuery2() const {
return query2_;
}
void RpcDataUploadRequest::setQuery2(long query2) {
query2_ = query2;
setParameter(std::string("query2"), std::to_string(query2));
}
std::string RpcDataUploadRequest::getLargeParam() const {
return largeParam_;
}
void RpcDataUploadRequest::setLargeParam(const std::string &largeParam) {
largeParam_ = largeParam;
setBodyParameter(std::string("largeParam"), largeParam);
}

86
ft/src/model/RpcDataUploadResult.cc
View File

@@ -1,86 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ft/model/RpcDataUploadResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ft;
using namespace AlibabaCloud::Ft::Model;
RpcDataUploadResult::RpcDataUploadResult() :
ServiceResult()
{}
RpcDataUploadResult::RpcDataUploadResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
RpcDataUploadResult::~RpcDataUploadResult()
{}
void RpcDataUploadResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["url"].isNull())
url_ = value["url"].asString();
if(!value["totalBytes"].isNull())
totalBytes_ = std::stol(value["totalBytes"].asString());
if(!value["totalTime"].isNull())
totalTime_ = std::stol(value["totalTime"].asString());
if(!value["speed"].isNull())
speed_ = value["speed"].asString();
if(!value["params"].isNull())
params_ = value["params"].asString();
if(!value["headers"].isNull())
headers_ = value["headers"].asString();
}
std::string RpcDataUploadResult::getSpeed()const
{
return speed_;
}
std::string RpcDataUploadResult::getHeaders()const
{
return headers_;
}
long RpcDataUploadResult::getTotalBytes()const
{
return totalBytes_;
}
long RpcDataUploadResult::getTotalTime()const
{
return totalTime_;
}
std::string RpcDataUploadResult::getParams()const
{
return params_;
}
std::string RpcDataUploadResult::getUrl()const
{
return url_;
}

27
ft/src/model/RpcDataUploadTestRequest.cc
View File

@@ -1,27 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ft/model/RpcDataUploadTestRequest.h>
using AlibabaCloud::Ft::Model::RpcDataUploadTestRequest;
RpcDataUploadTestRequest::RpcDataUploadTestRequest()
: RpcServiceRequest("ft", "2021-01-01", "RpcDataUploadTest") {
setMethod(HttpRequest::Method::Get);
}
RpcDataUploadTestRequest::~RpcDataUploadTestRequest() {}

44
ft/src/model/RpcDataUploadTestResult.cc
View File

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

81
ft/src/model/RpcNoDefaultErrorCodeApiRequest.cc Normal file
View File

@@ -0,0 +1,81 @@
/*
* 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/ft/model/RpcNoDefaultErrorCodeApiRequest.h>
using AlibabaCloud::Ft::Model::RpcNoDefaultErrorCodeApiRequest;
RpcNoDefaultErrorCodeApiRequest::RpcNoDefaultErrorCodeApiRequest()
: RpcServiceRequest("ft", "2015-03-03", "RpcNoDefaultErrorCodeApi") {
setMethod(HttpRequest::Method::Post);
}
RpcNoDefaultErrorCodeApiRequest::~RpcNoDefaultErrorCodeApiRequest() {}
std::string RpcNoDefaultErrorCodeApiRequest::getHttpMe() const {
return httpMe_;
}
void RpcNoDefaultErrorCodeApiRequest::setHttpMe(const std::string &httpMe) {
httpMe_ = httpMe;
setParameter(std::string("HttpMe"), httpMe);
}
std::string RpcNoDefaultErrorCodeApiRequest::getHttpStatusCode() const {
return httpStatusCode_;
}
void RpcNoDefaultErrorCodeApiRequest::setHttpStatusCode(const std::string &httpStatusCode) {
httpStatusCode_ = httpStatusCode;
setParameter(std::string("HttpStatusCode"), httpStatusCode);
}
std::string RpcNoDefaultErrorCodeApiRequest::getSetUser() const {
return setUser_;
}
void RpcNoDefaultErrorCodeApiRequest::setSetUser(const std::string &setUser) {
setUser_ = setUser;
setParameter(std::string("SetUser"), setUser);
}
std::string RpcNoDefaultErrorCodeApiRequest::getCode() const {
return code_;
}
void RpcNoDefaultErrorCodeApiRequest::setCode(const std::string &code) {
code_ = code;
setParameter(std::string("Code"), code);
}
std::string RpcNoDefaultErrorCodeApiRequest::getSuccess() const {
return success_;
}
void RpcNoDefaultErrorCodeApiRequest::setSuccess(const std::string &success) {
success_ = success;
setParameter(std::string("Success"), success);
}
std::string RpcNoDefaultErrorCodeApiRequest::getMessage() const {
return message_;
}
void RpcNoDefaultErrorCodeApiRequest::setMessage(const std::string &message) {
message_ = message;
setParameter(std::string("Message"), message);
}

24
ft/src/model/NormalRpcHsfApiResult.cc → ft/src/model/RpcNoDefaultErrorCodeApiResult.cc
View File

@@ -14,31 +14,45 @@
* limitations under the License.
*/
#include <alibabacloud/ft/model/NormalRpcHsfApiResult.h>
#include <alibabacloud/ft/model/RpcNoDefaultErrorCodeApiResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ft;
using namespace AlibabaCloud::Ft::Model;
NormalRpcHsfApiResult::NormalRpcHsfApiResult() :
RpcNoDefaultErrorCodeApiResult::RpcNoDefaultErrorCodeApiResult() :
ServiceResult()
{}
NormalRpcHsfApiResult::NormalRpcHsfApiResult(const std::string &payload) :
RpcNoDefaultErrorCodeApiResult::RpcNoDefaultErrorCodeApiResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
NormalRpcHsfApiResult::~NormalRpcHsfApiResult()
RpcNoDefaultErrorCodeApiResult::~RpcNoDefaultErrorCodeApiResult()
{}
void NormalRpcHsfApiResult::parse(const std::string &payload)
void RpcNoDefaultErrorCodeApiResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString();
}
std::string RpcNoDefaultErrorCodeApiResult::getCode()const
{
return code_;
}
std::string RpcNoDefaultErrorCodeApiResult::getSuccess()const
{
return success_;
}

45
ft/src/model/UpdateInsRequest.cc Normal file
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/ft/model/UpdateInsRequest.h>
using AlibabaCloud::Ft::Model::UpdateInsRequest;
UpdateInsRequest::UpdateInsRequest()
: RpcServiceRequest("ft", "2015-03-03", "UpdateIns") {
setMethod(HttpRequest::Method::Post);
}
UpdateInsRequest::~UpdateInsRequest() {}
std::string UpdateInsRequest::getSucceed() const {
return succeed_;
}
void UpdateInsRequest::setSucceed(const std::string &succeed) {
succeed_ = succeed;
setParameter(std::string("Succeed"), succeed);
}
std::string UpdateInsRequest::getHttpStatusCode1() const {
return httpStatusCode1_;
}
void UpdateInsRequest::setHttpStatusCode1(const std::string &httpStatusCode1) {
httpStatusCode1_ = httpStatusCode1;
setParameter(std::string("HttpStatusCode1"), httpStatusCode1);
}

24
ft/src/model/DataRateLimitTestResult.cc → ft/src/model/UpdateInsResult.cc
View File

@@ -14,31 +14,45 @@
* limitations under the License.
*/
#include <alibabacloud/ft/model/DataRateLimitTestResult.h>
#include <alibabacloud/ft/model/UpdateInsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ft;
using namespace AlibabaCloud::Ft::Model;
DataRateLimitTestResult::DataRateLimitTestResult() :
UpdateInsResult::UpdateInsResult() :
ServiceResult()
{}
DataRateLimitTestResult::DataRateLimitTestResult(const std::string &payload) :
UpdateInsResult::UpdateInsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DataRateLimitTestResult::~DataRateLimitTestResult()
UpdateInsResult::~UpdateInsResult()
{}
void DataRateLimitTestResult::parse(const std::string &payload)
void UpdateInsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString();
}
std::string UpdateInsResult::getCode()const
{
return code_;
}
std::string UpdateInsResult::getSuccess()const
{
return success_;
}