Generated 2020-06-29 for alinlp.

This commit is contained in:
sdk-team
2020-07-30 14:05:55 +08:00
parent 49e97628f4
commit b60a834a97
46 changed files with 2961 additions and 1 deletions

122
alinlp/CMakeLists.txt Normal file
View File

@@ -0,0 +1,122 @@
#
# Copyright 2009-2017 Alibaba Cloud All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include)
set(alinlp_public_header
include/alibabacloud/alinlp/AlinlpClient.h
include/alibabacloud/alinlp/AlinlpExport.h )
set(alinlp_public_header_model
include/alibabacloud/alinlp/model/GetDpChEcomRequest.h
include/alibabacloud/alinlp/model/GetDpChEcomResult.h
include/alibabacloud/alinlp/model/GetEcChGeneralRequest.h
include/alibabacloud/alinlp/model/GetEcChGeneralResult.h
include/alibabacloud/alinlp/model/GetNerChMedicalRequest.h
include/alibabacloud/alinlp/model/GetNerChMedicalResult.h
include/alibabacloud/alinlp/model/GetNerCustomizedChEcomRequest.h
include/alibabacloud/alinlp/model/GetNerCustomizedChEcomResult.h
include/alibabacloud/alinlp/model/GetPosChEcomRequest.h
include/alibabacloud/alinlp/model/GetPosChEcomResult.h
include/alibabacloud/alinlp/model/GetSummaryChEcomRequest.h
include/alibabacloud/alinlp/model/GetSummaryChEcomResult.h
include/alibabacloud/alinlp/model/GetTsChEcomRequest.h
include/alibabacloud/alinlp/model/GetTsChEcomResult.h
include/alibabacloud/alinlp/model/GetWeChEcomRequest.h
include/alibabacloud/alinlp/model/GetWeChEcomResult.h
include/alibabacloud/alinlp/model/GetWsCustomizedChGeneralRequest.h
include/alibabacloud/alinlp/model/GetWsCustomizedChGeneralResult.h
include/alibabacloud/alinlp/model/GetWsCustomizedSeaGeneralRequest.h
include/alibabacloud/alinlp/model/GetWsCustomizedSeaGeneralResult.h )
set(alinlp_src
src/AlinlpClient.cc
src/model/GetDpChEcomRequest.cc
src/model/GetDpChEcomResult.cc
src/model/GetEcChGeneralRequest.cc
src/model/GetEcChGeneralResult.cc
src/model/GetNerChMedicalRequest.cc
src/model/GetNerChMedicalResult.cc
src/model/GetNerCustomizedChEcomRequest.cc
src/model/GetNerCustomizedChEcomResult.cc
src/model/GetPosChEcomRequest.cc
src/model/GetPosChEcomResult.cc
src/model/GetSummaryChEcomRequest.cc
src/model/GetSummaryChEcomResult.cc
src/model/GetTsChEcomRequest.cc
src/model/GetTsChEcomResult.cc
src/model/GetWeChEcomRequest.cc
src/model/GetWeChEcomResult.cc
src/model/GetWsCustomizedChGeneralRequest.cc
src/model/GetWsCustomizedChGeneralResult.cc
src/model/GetWsCustomizedSeaGeneralRequest.cc
src/model/GetWsCustomizedSeaGeneralResult.cc )
add_library(alinlp ${LIB_TYPE}
${alinlp_public_header}
${alinlp_public_header_model}
${alinlp_src})
set_target_properties(alinlp
PROPERTIES
LINKER_LANGUAGE CXX
ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
OUTPUT_NAME ${TARGET_OUTPUT_NAME_PREFIX}alinlp
)
if(${LIB_TYPE} STREQUAL "SHARED")
set_target_properties(alinlp
PROPERTIES
DEFINE_SYMBOL ALIBABACLOUD_ALINLP_LIBRARY)
endif()
target_include_directories(alinlp
PRIVATE include
${CMAKE_SOURCE_DIR}/core/include
)
target_link_libraries(alinlp
core)
if(CMAKE_HOST_WIN32)
ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
set(jsoncpp_install_dir ${INSTALL_DIR})
add_dependencies(alinlp
jsoncpp)
target_include_directories(alinlp
PRIVATE ${jsoncpp_install_dir}/include)
target_link_libraries(alinlp
${jsoncpp_install_dir}/lib/jsoncpp.lib)
set_target_properties(alinlp
PROPERTIES
COMPILE_OPTIONS "/bigobj")
else()
target_include_directories(alinlp
PRIVATE /usr/include/jsoncpp)
target_link_libraries(alinlp
jsoncpp)
endif()
install(FILES ${alinlp_public_header}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/alinlp)
install(FILES ${alinlp_public_header_model}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/alinlp/model)
install(TARGETS alinlp
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)

View File

@@ -0,0 +1,126 @@
/*
* 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_ALINLP_ALINLPCLIENT_H_
#define ALIBABACLOUD_ALINLP_ALINLPCLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "AlinlpExport.h"
#include "model/GetDpChEcomRequest.h"
#include "model/GetDpChEcomResult.h"
#include "model/GetEcChGeneralRequest.h"
#include "model/GetEcChGeneralResult.h"
#include "model/GetNerChMedicalRequest.h"
#include "model/GetNerChMedicalResult.h"
#include "model/GetNerCustomizedChEcomRequest.h"
#include "model/GetNerCustomizedChEcomResult.h"
#include "model/GetPosChEcomRequest.h"
#include "model/GetPosChEcomResult.h"
#include "model/GetSummaryChEcomRequest.h"
#include "model/GetSummaryChEcomResult.h"
#include "model/GetTsChEcomRequest.h"
#include "model/GetTsChEcomResult.h"
#include "model/GetWeChEcomRequest.h"
#include "model/GetWeChEcomResult.h"
#include "model/GetWsCustomizedChGeneralRequest.h"
#include "model/GetWsCustomizedChGeneralResult.h"
#include "model/GetWsCustomizedSeaGeneralRequest.h"
#include "model/GetWsCustomizedSeaGeneralResult.h"
namespace AlibabaCloud
{
namespace Alinlp
{
class ALIBABACLOUD_ALINLP_EXPORT AlinlpClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::GetDpChEcomResult> GetDpChEcomOutcome;
typedef std::future<GetDpChEcomOutcome> GetDpChEcomOutcomeCallable;
typedef std::function<void(const AlinlpClient*, const Model::GetDpChEcomRequest&, const GetDpChEcomOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDpChEcomAsyncHandler;
typedef Outcome<Error, Model::GetEcChGeneralResult> GetEcChGeneralOutcome;
typedef std::future<GetEcChGeneralOutcome> GetEcChGeneralOutcomeCallable;
typedef std::function<void(const AlinlpClient*, const Model::GetEcChGeneralRequest&, const GetEcChGeneralOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetEcChGeneralAsyncHandler;
typedef Outcome<Error, Model::GetNerChMedicalResult> GetNerChMedicalOutcome;
typedef std::future<GetNerChMedicalOutcome> GetNerChMedicalOutcomeCallable;
typedef std::function<void(const AlinlpClient*, const Model::GetNerChMedicalRequest&, const GetNerChMedicalOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetNerChMedicalAsyncHandler;
typedef Outcome<Error, Model::GetNerCustomizedChEcomResult> GetNerCustomizedChEcomOutcome;
typedef std::future<GetNerCustomizedChEcomOutcome> GetNerCustomizedChEcomOutcomeCallable;
typedef std::function<void(const AlinlpClient*, const Model::GetNerCustomizedChEcomRequest&, const GetNerCustomizedChEcomOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetNerCustomizedChEcomAsyncHandler;
typedef Outcome<Error, Model::GetPosChEcomResult> GetPosChEcomOutcome;
typedef std::future<GetPosChEcomOutcome> GetPosChEcomOutcomeCallable;
typedef std::function<void(const AlinlpClient*, const Model::GetPosChEcomRequest&, const GetPosChEcomOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetPosChEcomAsyncHandler;
typedef Outcome<Error, Model::GetSummaryChEcomResult> GetSummaryChEcomOutcome;
typedef std::future<GetSummaryChEcomOutcome> GetSummaryChEcomOutcomeCallable;
typedef std::function<void(const AlinlpClient*, const Model::GetSummaryChEcomRequest&, const GetSummaryChEcomOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetSummaryChEcomAsyncHandler;
typedef Outcome<Error, Model::GetTsChEcomResult> GetTsChEcomOutcome;
typedef std::future<GetTsChEcomOutcome> GetTsChEcomOutcomeCallable;
typedef std::function<void(const AlinlpClient*, const Model::GetTsChEcomRequest&, const GetTsChEcomOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetTsChEcomAsyncHandler;
typedef Outcome<Error, Model::GetWeChEcomResult> GetWeChEcomOutcome;
typedef std::future<GetWeChEcomOutcome> GetWeChEcomOutcomeCallable;
typedef std::function<void(const AlinlpClient*, const Model::GetWeChEcomRequest&, const GetWeChEcomOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetWeChEcomAsyncHandler;
typedef Outcome<Error, Model::GetWsCustomizedChGeneralResult> GetWsCustomizedChGeneralOutcome;
typedef std::future<GetWsCustomizedChGeneralOutcome> GetWsCustomizedChGeneralOutcomeCallable;
typedef std::function<void(const AlinlpClient*, const Model::GetWsCustomizedChGeneralRequest&, const GetWsCustomizedChGeneralOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetWsCustomizedChGeneralAsyncHandler;
typedef Outcome<Error, Model::GetWsCustomizedSeaGeneralResult> GetWsCustomizedSeaGeneralOutcome;
typedef std::future<GetWsCustomizedSeaGeneralOutcome> GetWsCustomizedSeaGeneralOutcomeCallable;
typedef std::function<void(const AlinlpClient*, const Model::GetWsCustomizedSeaGeneralRequest&, const GetWsCustomizedSeaGeneralOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetWsCustomizedSeaGeneralAsyncHandler;
AlinlpClient(const Credentials &credentials, const ClientConfiguration &configuration);
AlinlpClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
AlinlpClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~AlinlpClient();
GetDpChEcomOutcome getDpChEcom(const Model::GetDpChEcomRequest &request)const;
void getDpChEcomAsync(const Model::GetDpChEcomRequest& request, const GetDpChEcomAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetDpChEcomOutcomeCallable getDpChEcomCallable(const Model::GetDpChEcomRequest& request) const;
GetEcChGeneralOutcome getEcChGeneral(const Model::GetEcChGeneralRequest &request)const;
void getEcChGeneralAsync(const Model::GetEcChGeneralRequest& request, const GetEcChGeneralAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetEcChGeneralOutcomeCallable getEcChGeneralCallable(const Model::GetEcChGeneralRequest& request) const;
GetNerChMedicalOutcome getNerChMedical(const Model::GetNerChMedicalRequest &request)const;
void getNerChMedicalAsync(const Model::GetNerChMedicalRequest& request, const GetNerChMedicalAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetNerChMedicalOutcomeCallable getNerChMedicalCallable(const Model::GetNerChMedicalRequest& request) const;
GetNerCustomizedChEcomOutcome getNerCustomizedChEcom(const Model::GetNerCustomizedChEcomRequest &request)const;
void getNerCustomizedChEcomAsync(const Model::GetNerCustomizedChEcomRequest& request, const GetNerCustomizedChEcomAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetNerCustomizedChEcomOutcomeCallable getNerCustomizedChEcomCallable(const Model::GetNerCustomizedChEcomRequest& request) const;
GetPosChEcomOutcome getPosChEcom(const Model::GetPosChEcomRequest &request)const;
void getPosChEcomAsync(const Model::GetPosChEcomRequest& request, const GetPosChEcomAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetPosChEcomOutcomeCallable getPosChEcomCallable(const Model::GetPosChEcomRequest& request) const;
GetSummaryChEcomOutcome getSummaryChEcom(const Model::GetSummaryChEcomRequest &request)const;
void getSummaryChEcomAsync(const Model::GetSummaryChEcomRequest& request, const GetSummaryChEcomAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetSummaryChEcomOutcomeCallable getSummaryChEcomCallable(const Model::GetSummaryChEcomRequest& request) const;
GetTsChEcomOutcome getTsChEcom(const Model::GetTsChEcomRequest &request)const;
void getTsChEcomAsync(const Model::GetTsChEcomRequest& request, const GetTsChEcomAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetTsChEcomOutcomeCallable getTsChEcomCallable(const Model::GetTsChEcomRequest& request) const;
GetWeChEcomOutcome getWeChEcom(const Model::GetWeChEcomRequest &request)const;
void getWeChEcomAsync(const Model::GetWeChEcomRequest& request, const GetWeChEcomAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetWeChEcomOutcomeCallable getWeChEcomCallable(const Model::GetWeChEcomRequest& request) const;
GetWsCustomizedChGeneralOutcome getWsCustomizedChGeneral(const Model::GetWsCustomizedChGeneralRequest &request)const;
void getWsCustomizedChGeneralAsync(const Model::GetWsCustomizedChGeneralRequest& request, const GetWsCustomizedChGeneralAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetWsCustomizedChGeneralOutcomeCallable getWsCustomizedChGeneralCallable(const Model::GetWsCustomizedChGeneralRequest& request) const;
GetWsCustomizedSeaGeneralOutcome getWsCustomizedSeaGeneral(const Model::GetWsCustomizedSeaGeneralRequest &request)const;
void getWsCustomizedSeaGeneralAsync(const Model::GetWsCustomizedSeaGeneralRequest& request, const GetWsCustomizedSeaGeneralAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetWsCustomizedSeaGeneralOutcomeCallable getWsCustomizedSeaGeneralCallable(const Model::GetWsCustomizedSeaGeneralRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_ALINLP_ALINLPCLIENT_H_

View File

@@ -0,0 +1,32 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ALINLP_ALINLPEXPORT_H_
#define ALIBABACLOUD_ALINLP_ALINLPEXPORT_H_
#include <alibabacloud/core/Global.h>
#if defined(ALIBABACLOUD_SHARED)
# if defined(ALIBABACLOUD_ALINLP_LIBRARY)
# define ALIBABACLOUD_ALINLP_EXPORT ALIBABACLOUD_DECL_EXPORT
# else
# define ALIBABACLOUD_ALINLP_EXPORT ALIBABACLOUD_DECL_IMPORT
# endif
#else
# define ALIBABACLOUD_ALINLP_EXPORT
#endif
#endif // !ALIBABACLOUD_ALINLP_ALINLPEXPORT_H_

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@@ -0,0 +1,54 @@
/*
* 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_ALINLP_MODEL_GETNERCUSTOMIZEDCHECOMREQUEST_H_
#define ALIBABACLOUD_ALINLP_MODEL_GETNERCUSTOMIZEDCHECOMREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/alinlp/AlinlpExport.h>
namespace AlibabaCloud
{
namespace Alinlp
{
namespace Model
{
class ALIBABACLOUD_ALINLP_EXPORT GetNerCustomizedChEcomRequest : public RpcServiceRequest
{
public:
GetNerCustomizedChEcomRequest();
~GetNerCustomizedChEcomRequest();
std::string getLexerId()const;
void setLexerId(const std::string& lexerId);
std::string getServiceCode()const;
void setServiceCode(const std::string& serviceCode);
std::string getText()const;
void setText(const std::string& text);
private:
std::string lexerId_;
std::string serviceCode_;
std::string text_;
};
}
}
}
#endif // !ALIBABACLOUD_ALINLP_MODEL_GETNERCUSTOMIZEDCHECOMREQUEST_H_

View File

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

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_ALINLP_MODEL_GETPOSCHECOMREQUEST_H_
#define ALIBABACLOUD_ALINLP_MODEL_GETPOSCHECOMREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/alinlp/AlinlpExport.h>
namespace AlibabaCloud
{
namespace Alinlp
{
namespace Model
{
class ALIBABACLOUD_ALINLP_EXPORT GetPosChEcomRequest : public RpcServiceRequest
{
public:
GetPosChEcomRequest();
~GetPosChEcomRequest();
std::string getServiceCode()const;
void setServiceCode(const std::string& serviceCode);
std::string getTokenizerId()const;
void setTokenizerId(const std::string& tokenizerId);
std::string getText()const;
void setText(const std::string& text);
std::string getOutType()const;
void setOutType(const std::string& outType);
private:
std::string serviceCode_;
std::string tokenizerId_;
std::string text_;
std::string outType_;
};
}
}
}
#endif // !ALIBABACLOUD_ALINLP_MODEL_GETPOSCHECOMREQUEST_H_

View File

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

View File

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

View File

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

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_ALINLP_MODEL_GETTSCHECOMREQUEST_H_
#define ALIBABACLOUD_ALINLP_MODEL_GETTSCHECOMREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/alinlp/AlinlpExport.h>
namespace AlibabaCloud
{
namespace Alinlp
{
namespace Model
{
class ALIBABACLOUD_ALINLP_EXPORT GetTsChEcomRequest : public RpcServiceRequest
{
public:
GetTsChEcomRequest();
~GetTsChEcomRequest();
std::string getType()const;
void setType(const std::string& type);
std::string getServiceCode()const;
void setServiceCode(const std::string& serviceCode);
std::string getOriginT()const;
void setOriginT(const std::string& originT);
std::string getOriginQ()const;
void setOriginQ(const std::string& originQ);
private:
std::string type_;
std::string serviceCode_;
std::string originT_;
std::string originQ_;
};
}
}
}
#endif // !ALIBABACLOUD_ALINLP_MODEL_GETTSCHECOMREQUEST_H_

View File

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

View File

@@ -0,0 +1,75 @@
/*
* 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_ALINLP_MODEL_GETWECHECOMREQUEST_H_
#define ALIBABACLOUD_ALINLP_MODEL_GETWECHECOMREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/alinlp/AlinlpExport.h>
namespace AlibabaCloud
{
namespace Alinlp
{
namespace Model
{
class ALIBABACLOUD_ALINLP_EXPORT GetWeChEcomRequest : public RpcServiceRequest
{
public:
GetWeChEcomRequest();
~GetWeChEcomRequest();
std::string getWordVectorDelimiter()const;
void setWordVectorDelimiter(const std::string& wordVectorDelimiter);
std::string getType()const;
void setType(const std::string& type);
std::string getUuid()const;
void setUuid(const std::string& uuid);
std::string getDelimiter()const;
void setDelimiter(const std::string& delimiter);
std::string getText()const;
void setText(const std::string& text);
std::string getToken()const;
void setToken(const std::string& token);
std::string getServiceCode()const;
void setServiceCode(const std::string& serviceCode);
std::string getSize()const;
void setSize(const std::string& size);
std::string getWordDelimiter()const;
void setWordDelimiter(const std::string& wordDelimiter);
std::string getOperation()const;
void setOperation(const std::string& operation);
private:
std::string wordVectorDelimiter_;
std::string type_;
std::string uuid_;
std::string delimiter_;
std::string text_;
std::string token_;
std::string serviceCode_;
std::string size_;
std::string wordDelimiter_;
std::string operation_;
};
}
}
}
#endif // !ALIBABACLOUD_ALINLP_MODEL_GETWECHECOMREQUEST_H_

View File

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

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_ALINLP_MODEL_GETWSCUSTOMIZEDCHGENERALREQUEST_H_
#define ALIBABACLOUD_ALINLP_MODEL_GETWSCUSTOMIZEDCHGENERALREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/alinlp/AlinlpExport.h>
namespace AlibabaCloud
{
namespace Alinlp
{
namespace Model
{
class ALIBABACLOUD_ALINLP_EXPORT GetWsCustomizedChGeneralRequest : public RpcServiceRequest
{
public:
GetWsCustomizedChGeneralRequest();
~GetWsCustomizedChGeneralRequest();
std::string getServiceCode()const;
void setServiceCode(const std::string& serviceCode);
std::string getTokenizerId()const;
void setTokenizerId(const std::string& tokenizerId);
std::string getText()const;
void setText(const std::string& text);
std::string getOutType()const;
void setOutType(const std::string& outType);
private:
std::string serviceCode_;
std::string tokenizerId_;
std::string text_;
std::string outType_;
};
}
}
}
#endif // !ALIBABACLOUD_ALINLP_MODEL_GETWSCUSTOMIZEDCHGENERALREQUEST_H_

View File

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

View File

@@ -0,0 +1,54 @@
/*
* 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_ALINLP_MODEL_GETWSCUSTOMIZEDSEAGENERALREQUEST_H_
#define ALIBABACLOUD_ALINLP_MODEL_GETWSCUSTOMIZEDSEAGENERALREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/alinlp/AlinlpExport.h>
namespace AlibabaCloud
{
namespace Alinlp
{
namespace Model
{
class ALIBABACLOUD_ALINLP_EXPORT GetWsCustomizedSeaGeneralRequest : public RpcServiceRequest
{
public:
GetWsCustomizedSeaGeneralRequest();
~GetWsCustomizedSeaGeneralRequest();
std::string getLanguage()const;
void setLanguage(const std::string& language);
std::string getServiceCode()const;
void setServiceCode(const std::string& serviceCode);
std::string getText()const;
void setText(const std::string& text);
private:
std::string language_;
std::string serviceCode_;
std::string text_;
};
}
}
}
#endif // !ALIBABACLOUD_ALINLP_MODEL_GETWSCUSTOMIZEDSEAGENERALREQUEST_H_

View File

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

413
alinlp/src/AlinlpClient.cc Normal file
View File

@@ -0,0 +1,413 @@
/*
* 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/alinlp/AlinlpClient.h>
#include <alibabacloud/core/SimpleCredentialsProvider.h>
using namespace AlibabaCloud;
using namespace AlibabaCloud::Location;
using namespace AlibabaCloud::Alinlp;
using namespace AlibabaCloud::Alinlp::Model;
namespace
{
const std::string SERVICE_NAME = "alinlp";
}
AlinlpClient::AlinlpClient(const Credentials &credentials, const ClientConfiguration &configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "alinlp");
}
AlinlpClient::AlinlpClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "alinlp");
}
AlinlpClient::AlinlpClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
{
auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "alinlp");
}
AlinlpClient::~AlinlpClient()
{}
AlinlpClient::GetDpChEcomOutcome AlinlpClient::getDpChEcom(const GetDpChEcomRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetDpChEcomOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetDpChEcomOutcome(GetDpChEcomResult(outcome.result()));
else
return GetDpChEcomOutcome(outcome.error());
}
void AlinlpClient::getDpChEcomAsync(const GetDpChEcomRequest& request, const GetDpChEcomAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getDpChEcom(request), context);
};
asyncExecute(new Runnable(fn));
}
AlinlpClient::GetDpChEcomOutcomeCallable AlinlpClient::getDpChEcomCallable(const GetDpChEcomRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetDpChEcomOutcome()>>(
[this, request]()
{
return this->getDpChEcom(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
AlinlpClient::GetEcChGeneralOutcome AlinlpClient::getEcChGeneral(const GetEcChGeneralRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetEcChGeneralOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetEcChGeneralOutcome(GetEcChGeneralResult(outcome.result()));
else
return GetEcChGeneralOutcome(outcome.error());
}
void AlinlpClient::getEcChGeneralAsync(const GetEcChGeneralRequest& request, const GetEcChGeneralAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getEcChGeneral(request), context);
};
asyncExecute(new Runnable(fn));
}
AlinlpClient::GetEcChGeneralOutcomeCallable AlinlpClient::getEcChGeneralCallable(const GetEcChGeneralRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetEcChGeneralOutcome()>>(
[this, request]()
{
return this->getEcChGeneral(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
AlinlpClient::GetNerChMedicalOutcome AlinlpClient::getNerChMedical(const GetNerChMedicalRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetNerChMedicalOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetNerChMedicalOutcome(GetNerChMedicalResult(outcome.result()));
else
return GetNerChMedicalOutcome(outcome.error());
}
void AlinlpClient::getNerChMedicalAsync(const GetNerChMedicalRequest& request, const GetNerChMedicalAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getNerChMedical(request), context);
};
asyncExecute(new Runnable(fn));
}
AlinlpClient::GetNerChMedicalOutcomeCallable AlinlpClient::getNerChMedicalCallable(const GetNerChMedicalRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetNerChMedicalOutcome()>>(
[this, request]()
{
return this->getNerChMedical(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
AlinlpClient::GetNerCustomizedChEcomOutcome AlinlpClient::getNerCustomizedChEcom(const GetNerCustomizedChEcomRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetNerCustomizedChEcomOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetNerCustomizedChEcomOutcome(GetNerCustomizedChEcomResult(outcome.result()));
else
return GetNerCustomizedChEcomOutcome(outcome.error());
}
void AlinlpClient::getNerCustomizedChEcomAsync(const GetNerCustomizedChEcomRequest& request, const GetNerCustomizedChEcomAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getNerCustomizedChEcom(request), context);
};
asyncExecute(new Runnable(fn));
}
AlinlpClient::GetNerCustomizedChEcomOutcomeCallable AlinlpClient::getNerCustomizedChEcomCallable(const GetNerCustomizedChEcomRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetNerCustomizedChEcomOutcome()>>(
[this, request]()
{
return this->getNerCustomizedChEcom(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
AlinlpClient::GetPosChEcomOutcome AlinlpClient::getPosChEcom(const GetPosChEcomRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetPosChEcomOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetPosChEcomOutcome(GetPosChEcomResult(outcome.result()));
else
return GetPosChEcomOutcome(outcome.error());
}
void AlinlpClient::getPosChEcomAsync(const GetPosChEcomRequest& request, const GetPosChEcomAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getPosChEcom(request), context);
};
asyncExecute(new Runnable(fn));
}
AlinlpClient::GetPosChEcomOutcomeCallable AlinlpClient::getPosChEcomCallable(const GetPosChEcomRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetPosChEcomOutcome()>>(
[this, request]()
{
return this->getPosChEcom(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
AlinlpClient::GetSummaryChEcomOutcome AlinlpClient::getSummaryChEcom(const GetSummaryChEcomRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetSummaryChEcomOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetSummaryChEcomOutcome(GetSummaryChEcomResult(outcome.result()));
else
return GetSummaryChEcomOutcome(outcome.error());
}
void AlinlpClient::getSummaryChEcomAsync(const GetSummaryChEcomRequest& request, const GetSummaryChEcomAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getSummaryChEcom(request), context);
};
asyncExecute(new Runnable(fn));
}
AlinlpClient::GetSummaryChEcomOutcomeCallable AlinlpClient::getSummaryChEcomCallable(const GetSummaryChEcomRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetSummaryChEcomOutcome()>>(
[this, request]()
{
return this->getSummaryChEcom(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
AlinlpClient::GetTsChEcomOutcome AlinlpClient::getTsChEcom(const GetTsChEcomRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetTsChEcomOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetTsChEcomOutcome(GetTsChEcomResult(outcome.result()));
else
return GetTsChEcomOutcome(outcome.error());
}
void AlinlpClient::getTsChEcomAsync(const GetTsChEcomRequest& request, const GetTsChEcomAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getTsChEcom(request), context);
};
asyncExecute(new Runnable(fn));
}
AlinlpClient::GetTsChEcomOutcomeCallable AlinlpClient::getTsChEcomCallable(const GetTsChEcomRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetTsChEcomOutcome()>>(
[this, request]()
{
return this->getTsChEcom(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
AlinlpClient::GetWeChEcomOutcome AlinlpClient::getWeChEcom(const GetWeChEcomRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetWeChEcomOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetWeChEcomOutcome(GetWeChEcomResult(outcome.result()));
else
return GetWeChEcomOutcome(outcome.error());
}
void AlinlpClient::getWeChEcomAsync(const GetWeChEcomRequest& request, const GetWeChEcomAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getWeChEcom(request), context);
};
asyncExecute(new Runnable(fn));
}
AlinlpClient::GetWeChEcomOutcomeCallable AlinlpClient::getWeChEcomCallable(const GetWeChEcomRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetWeChEcomOutcome()>>(
[this, request]()
{
return this->getWeChEcom(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
AlinlpClient::GetWsCustomizedChGeneralOutcome AlinlpClient::getWsCustomizedChGeneral(const GetWsCustomizedChGeneralRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetWsCustomizedChGeneralOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetWsCustomizedChGeneralOutcome(GetWsCustomizedChGeneralResult(outcome.result()));
else
return GetWsCustomizedChGeneralOutcome(outcome.error());
}
void AlinlpClient::getWsCustomizedChGeneralAsync(const GetWsCustomizedChGeneralRequest& request, const GetWsCustomizedChGeneralAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getWsCustomizedChGeneral(request), context);
};
asyncExecute(new Runnable(fn));
}
AlinlpClient::GetWsCustomizedChGeneralOutcomeCallable AlinlpClient::getWsCustomizedChGeneralCallable(const GetWsCustomizedChGeneralRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetWsCustomizedChGeneralOutcome()>>(
[this, request]()
{
return this->getWsCustomizedChGeneral(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
AlinlpClient::GetWsCustomizedSeaGeneralOutcome AlinlpClient::getWsCustomizedSeaGeneral(const GetWsCustomizedSeaGeneralRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetWsCustomizedSeaGeneralOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetWsCustomizedSeaGeneralOutcome(GetWsCustomizedSeaGeneralResult(outcome.result()));
else
return GetWsCustomizedSeaGeneralOutcome(outcome.error());
}
void AlinlpClient::getWsCustomizedSeaGeneralAsync(const GetWsCustomizedSeaGeneralRequest& request, const GetWsCustomizedSeaGeneralAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getWsCustomizedSeaGeneral(request), context);
};
asyncExecute(new Runnable(fn));
}
AlinlpClient::GetWsCustomizedSeaGeneralOutcomeCallable AlinlpClient::getWsCustomizedSeaGeneralCallable(const GetWsCustomizedSeaGeneralRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetWsCustomizedSeaGeneralOutcome()>>(
[this, request]()
{
return this->getWsCustomizedSeaGeneral(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}

View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/alinlp/model/GetDpChEcomRequest.h>
using AlibabaCloud::Alinlp::Model::GetDpChEcomRequest;
GetDpChEcomRequest::GetDpChEcomRequest() :
RpcServiceRequest("alinlp", "2020-06-29", "GetDpChEcom")
{
setMethod(HttpRequest::Method::Post);
}
GetDpChEcomRequest::~GetDpChEcomRequest()
{}
std::string GetDpChEcomRequest::getServiceCode()const
{
return serviceCode_;
}
void GetDpChEcomRequest::setServiceCode(const std::string& serviceCode)
{
serviceCode_ = serviceCode;
setBodyParameter("ServiceCode", serviceCode);
}
std::string GetDpChEcomRequest::getText()const
{
return text_;
}
void GetDpChEcomRequest::setText(const std::string& text)
{
text_ = text;
setBodyParameter("Text", text);
}

View File

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

View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/alinlp/model/GetEcChGeneralRequest.h>
using AlibabaCloud::Alinlp::Model::GetEcChGeneralRequest;
GetEcChGeneralRequest::GetEcChGeneralRequest() :
RpcServiceRequest("alinlp", "2020-06-29", "GetEcChGeneral")
{
setMethod(HttpRequest::Method::Post);
}
GetEcChGeneralRequest::~GetEcChGeneralRequest()
{}
std::string GetEcChGeneralRequest::getServiceCode()const
{
return serviceCode_;
}
void GetEcChGeneralRequest::setServiceCode(const std::string& serviceCode)
{
serviceCode_ = serviceCode;
setBodyParameter("ServiceCode", serviceCode);
}
std::string GetEcChGeneralRequest::getText()const
{
return text_;
}
void GetEcChGeneralRequest::setText(const std::string& text)
{
text_ = text;
setBodyParameter("Text", text);
}

View File

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

View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/alinlp/model/GetNerChMedicalRequest.h>
using AlibabaCloud::Alinlp::Model::GetNerChMedicalRequest;
GetNerChMedicalRequest::GetNerChMedicalRequest() :
RpcServiceRequest("alinlp", "2020-06-29", "GetNerChMedical")
{
setMethod(HttpRequest::Method::Post);
}
GetNerChMedicalRequest::~GetNerChMedicalRequest()
{}
std::string GetNerChMedicalRequest::getServiceCode()const
{
return serviceCode_;
}
void GetNerChMedicalRequest::setServiceCode(const std::string& serviceCode)
{
serviceCode_ = serviceCode;
setBodyParameter("ServiceCode", serviceCode);
}
std::string GetNerChMedicalRequest::getText()const
{
return text_;
}
void GetNerChMedicalRequest::setText(const std::string& text)
{
text_ = text;
setBodyParameter("Text", text);
}

View File

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

View File

@@ -0,0 +1,62 @@
/*
* 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/alinlp/model/GetNerCustomizedChEcomRequest.h>
using AlibabaCloud::Alinlp::Model::GetNerCustomizedChEcomRequest;
GetNerCustomizedChEcomRequest::GetNerCustomizedChEcomRequest() :
RpcServiceRequest("alinlp", "2020-06-29", "GetNerCustomizedChEcom")
{
setMethod(HttpRequest::Method::Post);
}
GetNerCustomizedChEcomRequest::~GetNerCustomizedChEcomRequest()
{}
std::string GetNerCustomizedChEcomRequest::getLexerId()const
{
return lexerId_;
}
void GetNerCustomizedChEcomRequest::setLexerId(const std::string& lexerId)
{
lexerId_ = lexerId;
setBodyParameter("LexerId", lexerId);
}
std::string GetNerCustomizedChEcomRequest::getServiceCode()const
{
return serviceCode_;
}
void GetNerCustomizedChEcomRequest::setServiceCode(const std::string& serviceCode)
{
serviceCode_ = serviceCode;
setBodyParameter("ServiceCode", serviceCode);
}
std::string GetNerCustomizedChEcomRequest::getText()const
{
return text_;
}
void GetNerCustomizedChEcomRequest::setText(const std::string& text)
{
text_ = text;
setBodyParameter("Text", text);
}

View File

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

View File

@@ -0,0 +1,73 @@
/*
* 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/alinlp/model/GetPosChEcomRequest.h>
using AlibabaCloud::Alinlp::Model::GetPosChEcomRequest;
GetPosChEcomRequest::GetPosChEcomRequest() :
RpcServiceRequest("alinlp", "2020-06-29", "GetPosChEcom")
{
setMethod(HttpRequest::Method::Post);
}
GetPosChEcomRequest::~GetPosChEcomRequest()
{}
std::string GetPosChEcomRequest::getServiceCode()const
{
return serviceCode_;
}
void GetPosChEcomRequest::setServiceCode(const std::string& serviceCode)
{
serviceCode_ = serviceCode;
setBodyParameter("ServiceCode", serviceCode);
}
std::string GetPosChEcomRequest::getTokenizerId()const
{
return tokenizerId_;
}
void GetPosChEcomRequest::setTokenizerId(const std::string& tokenizerId)
{
tokenizerId_ = tokenizerId;
setBodyParameter("TokenizerId", tokenizerId);
}
std::string GetPosChEcomRequest::getText()const
{
return text_;
}
void GetPosChEcomRequest::setText(const std::string& text)
{
text_ = text;
setBodyParameter("Text", text);
}
std::string GetPosChEcomRequest::getOutType()const
{
return outType_;
}
void GetPosChEcomRequest::setOutType(const std::string& outType)
{
outType_ = outType;
setBodyParameter("OutType", outType);
}

View File

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

View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/alinlp/model/GetSummaryChEcomRequest.h>
using AlibabaCloud::Alinlp::Model::GetSummaryChEcomRequest;
GetSummaryChEcomRequest::GetSummaryChEcomRequest() :
RpcServiceRequest("alinlp", "2020-06-29", "GetSummaryChEcom")
{
setMethod(HttpRequest::Method::Post);
}
GetSummaryChEcomRequest::~GetSummaryChEcomRequest()
{}
std::string GetSummaryChEcomRequest::getServiceCode()const
{
return serviceCode_;
}
void GetSummaryChEcomRequest::setServiceCode(const std::string& serviceCode)
{
serviceCode_ = serviceCode;
setBodyParameter("ServiceCode", serviceCode);
}
std::string GetSummaryChEcomRequest::getText()const
{
return text_;
}
void GetSummaryChEcomRequest::setText(const std::string& text)
{
text_ = text;
setBodyParameter("Text", text);
}

View File

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

View File

@@ -0,0 +1,73 @@
/*
* 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/alinlp/model/GetTsChEcomRequest.h>
using AlibabaCloud::Alinlp::Model::GetTsChEcomRequest;
GetTsChEcomRequest::GetTsChEcomRequest() :
RpcServiceRequest("alinlp", "2020-06-29", "GetTsChEcom")
{
setMethod(HttpRequest::Method::Post);
}
GetTsChEcomRequest::~GetTsChEcomRequest()
{}
std::string GetTsChEcomRequest::getType()const
{
return type_;
}
void GetTsChEcomRequest::setType(const std::string& type)
{
type_ = type;
setBodyParameter("Type", type);
}
std::string GetTsChEcomRequest::getServiceCode()const
{
return serviceCode_;
}
void GetTsChEcomRequest::setServiceCode(const std::string& serviceCode)
{
serviceCode_ = serviceCode;
setBodyParameter("ServiceCode", serviceCode);
}
std::string GetTsChEcomRequest::getOriginT()const
{
return originT_;
}
void GetTsChEcomRequest::setOriginT(const std::string& originT)
{
originT_ = originT;
setBodyParameter("OriginT", originT);
}
std::string GetTsChEcomRequest::getOriginQ()const
{
return originQ_;
}
void GetTsChEcomRequest::setOriginQ(const std::string& originQ)
{
originQ_ = originQ;
setBodyParameter("OriginQ", originQ);
}

View File

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

View File

@@ -0,0 +1,139 @@
/*
* 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/alinlp/model/GetWeChEcomRequest.h>
using AlibabaCloud::Alinlp::Model::GetWeChEcomRequest;
GetWeChEcomRequest::GetWeChEcomRequest() :
RpcServiceRequest("alinlp", "2020-06-29", "GetWeChEcom")
{
setMethod(HttpRequest::Method::Post);
}
GetWeChEcomRequest::~GetWeChEcomRequest()
{}
std::string GetWeChEcomRequest::getWordVectorDelimiter()const
{
return wordVectorDelimiter_;
}
void GetWeChEcomRequest::setWordVectorDelimiter(const std::string& wordVectorDelimiter)
{
wordVectorDelimiter_ = wordVectorDelimiter;
setBodyParameter("WordVectorDelimiter", wordVectorDelimiter);
}
std::string GetWeChEcomRequest::getType()const
{
return type_;
}
void GetWeChEcomRequest::setType(const std::string& type)
{
type_ = type;
setBodyParameter("Type", type);
}
std::string GetWeChEcomRequest::getUuid()const
{
return uuid_;
}
void GetWeChEcomRequest::setUuid(const std::string& uuid)
{
uuid_ = uuid;
setBodyParameter("Uuid", uuid);
}
std::string GetWeChEcomRequest::getDelimiter()const
{
return delimiter_;
}
void GetWeChEcomRequest::setDelimiter(const std::string& delimiter)
{
delimiter_ = delimiter;
setBodyParameter("Delimiter", delimiter);
}
std::string GetWeChEcomRequest::getText()const
{
return text_;
}
void GetWeChEcomRequest::setText(const std::string& text)
{
text_ = text;
setBodyParameter("Text", text);
}
std::string GetWeChEcomRequest::getToken()const
{
return token_;
}
void GetWeChEcomRequest::setToken(const std::string& token)
{
token_ = token;
setBodyParameter("Token", token);
}
std::string GetWeChEcomRequest::getServiceCode()const
{
return serviceCode_;
}
void GetWeChEcomRequest::setServiceCode(const std::string& serviceCode)
{
serviceCode_ = serviceCode;
setBodyParameter("ServiceCode", serviceCode);
}
std::string GetWeChEcomRequest::getSize()const
{
return size_;
}
void GetWeChEcomRequest::setSize(const std::string& size)
{
size_ = size;
setBodyParameter("Size", size);
}
std::string GetWeChEcomRequest::getWordDelimiter()const
{
return wordDelimiter_;
}
void GetWeChEcomRequest::setWordDelimiter(const std::string& wordDelimiter)
{
wordDelimiter_ = wordDelimiter;
setBodyParameter("WordDelimiter", wordDelimiter);
}
std::string GetWeChEcomRequest::getOperation()const
{
return operation_;
}
void GetWeChEcomRequest::setOperation(const std::string& operation)
{
operation_ = operation;
setBodyParameter("Operation", operation);
}

View File

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

View File

@@ -0,0 +1,73 @@
/*
* 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/alinlp/model/GetWsCustomizedChGeneralRequest.h>
using AlibabaCloud::Alinlp::Model::GetWsCustomizedChGeneralRequest;
GetWsCustomizedChGeneralRequest::GetWsCustomizedChGeneralRequest() :
RpcServiceRequest("alinlp", "2020-06-29", "GetWsCustomizedChGeneral")
{
setMethod(HttpRequest::Method::Post);
}
GetWsCustomizedChGeneralRequest::~GetWsCustomizedChGeneralRequest()
{}
std::string GetWsCustomizedChGeneralRequest::getServiceCode()const
{
return serviceCode_;
}
void GetWsCustomizedChGeneralRequest::setServiceCode(const std::string& serviceCode)
{
serviceCode_ = serviceCode;
setBodyParameter("ServiceCode", serviceCode);
}
std::string GetWsCustomizedChGeneralRequest::getTokenizerId()const
{
return tokenizerId_;
}
void GetWsCustomizedChGeneralRequest::setTokenizerId(const std::string& tokenizerId)
{
tokenizerId_ = tokenizerId;
setBodyParameter("TokenizerId", tokenizerId);
}
std::string GetWsCustomizedChGeneralRequest::getText()const
{
return text_;
}
void GetWsCustomizedChGeneralRequest::setText(const std::string& text)
{
text_ = text;
setBodyParameter("Text", text);
}
std::string GetWsCustomizedChGeneralRequest::getOutType()const
{
return outType_;
}
void GetWsCustomizedChGeneralRequest::setOutType(const std::string& outType)
{
outType_ = outType;
setBodyParameter("OutType", outType);
}

View File

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

View File

@@ -0,0 +1,62 @@
/*
* 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/alinlp/model/GetWsCustomizedSeaGeneralRequest.h>
using AlibabaCloud::Alinlp::Model::GetWsCustomizedSeaGeneralRequest;
GetWsCustomizedSeaGeneralRequest::GetWsCustomizedSeaGeneralRequest() :
RpcServiceRequest("alinlp", "2020-06-29", "GetWsCustomizedSeaGeneral")
{
setMethod(HttpRequest::Method::Post);
}
GetWsCustomizedSeaGeneralRequest::~GetWsCustomizedSeaGeneralRequest()
{}
std::string GetWsCustomizedSeaGeneralRequest::getLanguage()const
{
return language_;
}
void GetWsCustomizedSeaGeneralRequest::setLanguage(const std::string& language)
{
language_ = language;
setBodyParameter("Language", language);
}
std::string GetWsCustomizedSeaGeneralRequest::getServiceCode()const
{
return serviceCode_;
}
void GetWsCustomizedSeaGeneralRequest::setServiceCode(const std::string& serviceCode)
{
serviceCode_ = serviceCode;
setBodyParameter("ServiceCode", serviceCode);
}
std::string GetWsCustomizedSeaGeneralRequest::getText()const
{
return text_;
}
void GetWsCustomizedSeaGeneralRequest::setText(const std::string& text)
{
text_ = text;
setBodyParameter("Text", text);
}

View File

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