Change DescribeEventDetail Data.

sddp/src/model/BatchDeleteDataLimitRequest.cc

@@ -1,62 +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/sddp/model/BatchDeleteDataLimitRequest.h>
-
-using AlibabaCloud::Sddp::Model::BatchDeleteDataLimitRequest;
-
-BatchDeleteDataLimitRequest::BatchDeleteDataLimitRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "BatchDeleteDataLimit")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-BatchDeleteDataLimitRequest::~BatchDeleteDataLimitRequest()
-{}
-
-long BatchDeleteDataLimitRequest::getResourceType()const
-{
-	return resourceType_;
-}
-
-void BatchDeleteDataLimitRequest::setResourceType(long resourceType)
-{
-	resourceType_ = resourceType;
-	setParameter("ResourceType", std::to_string(resourceType));
-}
-
-std::string BatchDeleteDataLimitRequest::getSourceIp()const
-{
-	return sourceIp_;
-}
-
-void BatchDeleteDataLimitRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
-}
-
-std::string BatchDeleteDataLimitRequest::getDataLimitList()const
-{
-	return dataLimitList_;
-}
-
-void BatchDeleteDataLimitRequest::setDataLimitList(const std::string& dataLimitList)
-{
-	dataLimitList_ = dataLimitList;
-	setParameter("DataLimitList", dataLimitList);
-}
-

sddp/src/model/CreateConfigRequest.cc

@@ -1,106 +1,90 @@
 /*
  * 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/sddp/model/CreateConfigRequest.h>
-
-using AlibabaCloud::Sddp::Model::CreateConfigRequest;
-
-CreateConfigRequest::CreateConfigRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "CreateConfig")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateConfigRequest::~CreateConfigRequest()
-{}
-
-std::string CreateConfigRequest::getCode()const
-{
-	return code_;
+ */
+
+#include <alibabacloud/sddp/model/CreateConfigRequest.h>
+
+using AlibabaCloud::Sddp::Model::CreateConfigRequest;
+
+CreateConfigRequest::CreateConfigRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "CreateConfig") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CreateConfigRequest::setCode(const std::string& code)
-{
-	code_ = code;
-	setParameter("Code", code);
+CreateConfigRequest::~CreateConfigRequest() {}
+
+std::string CreateConfigRequest::getCode() const {
+  return code_;
 }
 
-std::string CreateConfigRequest::getDescription()const
-{
-	return description_;
+void CreateConfigRequest::setCode(const std::string &code) {
+  code_ = code;
+  setParameter(std::string("Code"), code);
 }
 
-void CreateConfigRequest::setDescription(const std::string& description)
-{
-	description_ = description;
-	setParameter("Description", description);
+std::string CreateConfigRequest::getDescription() const {
+  return description_;
 }
 
-std::string CreateConfigRequest::getSourceIp()const
-{
-	return sourceIp_;
+void CreateConfigRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
 }
 
-void CreateConfigRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+std::string CreateConfigRequest::getSourceIp() const {
+  return sourceIp_;
 }
 
-std::string CreateConfigRequest::getLang()const
-{
-	return lang_;
+void CreateConfigRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
 }
 
-void CreateConfigRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
+std::string CreateConfigRequest::getLang() const {
+  return lang_;
 }
 
-std::string CreateConfigRequest::getValue()const
-{
-	return value_;
+void CreateConfigRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 
-void CreateConfigRequest::setValue(const std::string& value)
-{
-	value_ = value;
-	setParameter("Value", value);
+std::string CreateConfigRequest::getValue() const {
+  return value_;
 }
 
-int CreateConfigRequest::getFeatureType()const
-{
-	return featureType_;
+void CreateConfigRequest::setValue(const std::string &value) {
+  value_ = value;
+  setParameter(std::string("Value"), value);
 }
 
-void CreateConfigRequest::setFeatureType(int featureType)
-{
-	featureType_ = featureType;
-	setParameter("FeatureType", std::to_string(featureType));
+int CreateConfigRequest::getFeatureType() const {
+  return featureType_;
 }
 
-std::string CreateConfigRequest::getConfigList()const
-{
-	return configList_;
+void CreateConfigRequest::setFeatureType(int featureType) {
+  featureType_ = featureType;
+  setParameter(std::string("FeatureType"), std::to_string(featureType));
 }
 
-void CreateConfigRequest::setConfigList(const std::string& configList)
-{
-	configList_ = configList;
-	setParameter("ConfigList", configList);
+std::string CreateConfigRequest::getConfigList() const {
+  return configList_;
+}
+
+void CreateConfigRequest::setConfigList(const std::string &configList) {
+  configList_ = configList;
+  setParameter(std::string("ConfigList"), configList);
 }
 

sddp/src/model/CreateDataLimitRequest.cc

@@ -1,216 +1,180 @@
 /*
  * 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/sddp/model/CreateDataLimitRequest.h>
-
-using AlibabaCloud::Sddp::Model::CreateDataLimitRequest;
-
-CreateDataLimitRequest::CreateDataLimitRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "CreateDataLimit")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateDataLimitRequest::~CreateDataLimitRequest()
-{}
-
-int CreateDataLimitRequest::getOcrStatus()const
-{
-	return ocrStatus_;
+ */
+
+#include <alibabacloud/sddp/model/CreateDataLimitRequest.h>
+
+using AlibabaCloud::Sddp::Model::CreateDataLimitRequest;
+
+CreateDataLimitRequest::CreateDataLimitRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "CreateDataLimit") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CreateDataLimitRequest::setOcrStatus(int ocrStatus)
-{
-	ocrStatus_ = ocrStatus;
-	setParameter("OcrStatus", std::to_string(ocrStatus));
+CreateDataLimitRequest::~CreateDataLimitRequest() {}
+
+int CreateDataLimitRequest::getOcrStatus() const {
+  return ocrStatus_;
 }
 
-std::string CreateDataLimitRequest::getParentId()const
-{
-	return parentId_;
+void CreateDataLimitRequest::setOcrStatus(int ocrStatus) {
+  ocrStatus_ = ocrStatus;
+  setParameter(std::string("OcrStatus"), std::to_string(ocrStatus));
 }
 
-void CreateDataLimitRequest::setParentId(const std::string& parentId)
-{
-	parentId_ = parentId;
-	setParameter("ParentId", parentId);
+std::string CreateDataLimitRequest::getParentId() const {
+  return parentId_;
 }
 
-std::string CreateDataLimitRequest::getPassword()const
-{
-	return password_;
+void CreateDataLimitRequest::setParentId(const std::string &parentId) {
+  parentId_ = parentId;
+  setParameter(std::string("ParentId"), parentId);
 }
 
-void CreateDataLimitRequest::setPassword(const std::string& password)
-{
-	password_ = password;
-	setParameter("Password", password);
+std::string CreateDataLimitRequest::getPassword() const {
+  return password_;
 }
 
-bool CreateDataLimitRequest::getBatchCreate()const
-{
-	return batchCreate_;
+void CreateDataLimitRequest::setPassword(const std::string &password) {
+  password_ = password;
+  setParameter(std::string("Password"), password);
 }
 
-void CreateDataLimitRequest::setBatchCreate(bool batchCreate)
-{
-	batchCreate_ = batchCreate;
-	setParameter("BatchCreate", batchCreate ? "true" : "false");
+bool CreateDataLimitRequest::getBatchCreate() const {
+  return batchCreate_;
 }
 
-std::string CreateDataLimitRequest::getSourceIp()const
-{
-	return sourceIp_;
+void CreateDataLimitRequest::setBatchCreate(bool batchCreate) {
+  batchCreate_ = batchCreate;
+  setParameter(std::string("BatchCreate"), batchCreate ? "true" : "false");
 }
 
-void CreateDataLimitRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+std::string CreateDataLimitRequest::getSourceIp() const {
+  return sourceIp_;
 }
 
-std::string CreateDataLimitRequest::getDataLimitList()const
-{
-	return dataLimitList_;
+void CreateDataLimitRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
 }
 
-void CreateDataLimitRequest::setDataLimitList(const std::string& dataLimitList)
-{
-	dataLimitList_ = dataLimitList;
-	setParameter("DataLimitList", dataLimitList);
+std::string CreateDataLimitRequest::getDataLimitList() const {
+  return dataLimitList_;
 }
 
-std::string CreateDataLimitRequest::getLang()const
-{
-	return lang_;
+void CreateDataLimitRequest::setDataLimitList(const std::string &dataLimitList) {
+  dataLimitList_ = dataLimitList;
+  setParameter(std::string("DataLimitList"), dataLimitList);
 }
 
-void CreateDataLimitRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
+std::string CreateDataLimitRequest::getLang() const {
+  return lang_;
 }
 
-std::string CreateDataLimitRequest::getServiceRegionId()const
-{
-	return serviceRegionId_;
+void CreateDataLimitRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 
-void CreateDataLimitRequest::setServiceRegionId(const std::string& serviceRegionId)
-{
-	serviceRegionId_ = serviceRegionId;
-	setParameter("ServiceRegionId", serviceRegionId);
+std::string CreateDataLimitRequest::getServiceRegionId() const {
+  return serviceRegionId_;
 }
 
-std::string CreateDataLimitRequest::getEngineType()const
-{
-	return engineType_;
+void CreateDataLimitRequest::setServiceRegionId(const std::string &serviceRegionId) {
+  serviceRegionId_ = serviceRegionId;
+  setParameter(std::string("ServiceRegionId"), serviceRegionId);
 }
 
-void CreateDataLimitRequest::setEngineType(const std::string& engineType)
-{
-	engineType_ = engineType;
-	setParameter("EngineType", engineType);
+std::string CreateDataLimitRequest::getEngineType() const {
+  return engineType_;
 }
 
-int CreateDataLimitRequest::getAuditStatus()const
-{
-	return auditStatus_;
+void CreateDataLimitRequest::setEngineType(const std::string &engineType) {
+  engineType_ = engineType;
+  setParameter(std::string("EngineType"), engineType);
 }
 
-void CreateDataLimitRequest::setAuditStatus(int auditStatus)
-{
-	auditStatus_ = auditStatus;
-	setParameter("AuditStatus", std::to_string(auditStatus));
+int CreateDataLimitRequest::getAuditStatus() const {
+  return auditStatus_;
 }
 
-int CreateDataLimitRequest::getAutoScan()const
-{
-	return autoScan_;
+void CreateDataLimitRequest::setAuditStatus(int auditStatus) {
+  auditStatus_ = auditStatus;
+  setParameter(std::string("AuditStatus"), std::to_string(auditStatus));
 }
 
-void CreateDataLimitRequest::setAutoScan(int autoScan)
-{
-	autoScan_ = autoScan;
-	setParameter("AutoScan", std::to_string(autoScan));
+int CreateDataLimitRequest::getAutoScan() const {
+  return autoScan_;
 }
 
-int CreateDataLimitRequest::getLogStoreDay()const
-{
-	return logStoreDay_;
+void CreateDataLimitRequest::setAutoScan(int autoScan) {
+  autoScan_ = autoScan;
+  setParameter(std::string("AutoScan"), std::to_string(autoScan));
 }
 
-void CreateDataLimitRequest::setLogStoreDay(int logStoreDay)
-{
-	logStoreDay_ = logStoreDay;
-	setParameter("LogStoreDay", std::to_string(logStoreDay));
+int CreateDataLimitRequest::getLogStoreDay() const {
+  return logStoreDay_;
 }
 
-int CreateDataLimitRequest::getResourceType()const
-{
-	return resourceType_;
+void CreateDataLimitRequest::setLogStoreDay(int logStoreDay) {
+  logStoreDay_ = logStoreDay;
+  setParameter(std::string("LogStoreDay"), std::to_string(logStoreDay));
 }
 
-void CreateDataLimitRequest::setResourceType(int resourceType)
-{
-	resourceType_ = resourceType;
-	setParameter("ResourceType", std::to_string(resourceType));
+int CreateDataLimitRequest::getResourceType() const {
+  return resourceType_;
 }
 
-std::string CreateDataLimitRequest::getConnector()const
-{
-	return connector_;
+void CreateDataLimitRequest::setResourceType(int resourceType) {
+  resourceType_ = resourceType;
+  setParameter(std::string("ResourceType"), std::to_string(resourceType));
 }
 
-void CreateDataLimitRequest::setConnector(const std::string& connector)
-{
-	connector_ = connector;
-	setParameter("Connector", connector);
+std::string CreateDataLimitRequest::getConnector() const {
+  return connector_;
 }
 
-int CreateDataLimitRequest::getPort()const
-{
-	return port_;
+void CreateDataLimitRequest::setConnector(const std::string &connector) {
+  connector_ = connector;
+  setParameter(std::string("Connector"), connector);
 }
 
-void CreateDataLimitRequest::setPort(int port)
-{
-	port_ = port;
-	setParameter("Port", std::to_string(port));
+int CreateDataLimitRequest::getPort() const {
+  return port_;
 }
 
-int CreateDataLimitRequest::getEventStatus()const
-{
-	return eventStatus_;
+void CreateDataLimitRequest::setPort(int port) {
+  port_ = port;
+  setParameter(std::string("Port"), std::to_string(port));
 }
 
-void CreateDataLimitRequest::setEventStatus(int eventStatus)
-{
-	eventStatus_ = eventStatus;
-	setParameter("EventStatus", std::to_string(eventStatus));
+int CreateDataLimitRequest::getEventStatus() const {
+  return eventStatus_;
 }
 
-std::string CreateDataLimitRequest::getUserName()const
-{
-	return userName_;
+void CreateDataLimitRequest::setEventStatus(int eventStatus) {
+  eventStatus_ = eventStatus;
+  setParameter(std::string("EventStatus"), std::to_string(eventStatus));
 }
 
-void CreateDataLimitRequest::setUserName(const std::string& userName)
-{
-	userName_ = userName;
-	setParameter("UserName", userName);
+std::string CreateDataLimitRequest::getUserName() const {
+  return userName_;
+}
+
+void CreateDataLimitRequest::setUserName(const std::string &userName) {
+  userName_ = userName;
+  setParameter(std::string("UserName"), userName);
 }
 

sddp/src/model/CreateRuleRequest.cc

@@ -1,216 +1,180 @@
 /*
  * 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/sddp/model/CreateRuleRequest.h>
-
-using AlibabaCloud::Sddp::Model::CreateRuleRequest;
-
-CreateRuleRequest::CreateRuleRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "CreateRule")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateRuleRequest::~CreateRuleRequest()
-{}
-
-int CreateRuleRequest::getWarnLevel()const
-{
-	return warnLevel_;
+ */
+
+#include <alibabacloud/sddp/model/CreateRuleRequest.h>
+
+using AlibabaCloud::Sddp::Model::CreateRuleRequest;
+
+CreateRuleRequest::CreateRuleRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "CreateRule") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CreateRuleRequest::setWarnLevel(int warnLevel)
-{
-	warnLevel_ = warnLevel;
-	setParameter("WarnLevel", std::to_string(warnLevel));
+CreateRuleRequest::~CreateRuleRequest() {}
+
+int CreateRuleRequest::getWarnLevel() const {
+  return warnLevel_;
 }
 
-std::string CreateRuleRequest::getProductCode()const
-{
-	return productCode_;
+void CreateRuleRequest::setWarnLevel(int warnLevel) {
+  warnLevel_ = warnLevel;
+  setParameter(std::string("WarnLevel"), std::to_string(warnLevel));
 }
 
-void CreateRuleRequest::setProductCode(const std::string& productCode)
-{
-	productCode_ = productCode;
-	setParameter("ProductCode", productCode);
+std::string CreateRuleRequest::getProductCode() const {
+  return productCode_;
 }
 
-long CreateRuleRequest::getProductId()const
-{
-	return productId_;
+void CreateRuleRequest::setProductCode(const std::string &productCode) {
+  productCode_ = productCode;
+  setParameter(std::string("ProductCode"), productCode);
 }
 
-void CreateRuleRequest::setProductId(long productId)
-{
-	productId_ = productId;
-	setParameter("ProductId", std::to_string(productId));
+long CreateRuleRequest::getProductId() const {
+  return productId_;
 }
 
-std::string CreateRuleRequest::getDescription()const
-{
-	return description_;
+void CreateRuleRequest::setProductId(long productId) {
+  productId_ = productId;
+  setParameter(std::string("ProductId"), std::to_string(productId));
 }
 
-void CreateRuleRequest::setDescription(const std::string& description)
-{
-	description_ = description;
-	setParameter("Description", description);
+std::string CreateRuleRequest::getDescription() const {
+  return description_;
 }
 
-long CreateRuleRequest::getRiskLevelId()const
-{
-	return riskLevelId_;
+void CreateRuleRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
 }
 
-void CreateRuleRequest::setRiskLevelId(long riskLevelId)
-{
-	riskLevelId_ = riskLevelId;
-	setParameter("RiskLevelId", std::to_string(riskLevelId));
+long CreateRuleRequest::getRiskLevelId() const {
+  return riskLevelId_;
 }
 
-std::string CreateRuleRequest::getContent()const
-{
-	return content_;
+void CreateRuleRequest::setRiskLevelId(long riskLevelId) {
+  riskLevelId_ = riskLevelId;
+  setParameter(std::string("RiskLevelId"), std::to_string(riskLevelId));
 }
 
-void CreateRuleRequest::setContent(const std::string& content)
-{
-	content_ = content;
-	setParameter("Content", content);
+std::string CreateRuleRequest::getContent() const {
+  return content_;
 }
 
-std::string CreateRuleRequest::getSourceIp()const
-{
-	return sourceIp_;
+void CreateRuleRequest::setContent(const std::string &content) {
+  content_ = content;
+  setParameter(std::string("Content"), content);
 }
 
-void CreateRuleRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+std::string CreateRuleRequest::getSourceIp() const {
+  return sourceIp_;
 }
 
-std::string CreateRuleRequest::getLang()const
-{
-	return lang_;
+void CreateRuleRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
 }
 
-void CreateRuleRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
+std::string CreateRuleRequest::getLang() const {
+  return lang_;
 }
 
-int CreateRuleRequest::getFeatureType()const
-{
-	return featureType_;
+void CreateRuleRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 
-void CreateRuleRequest::setFeatureType(int featureType)
-{
-	featureType_ = featureType;
-	setParameter("FeatureType", std::to_string(featureType));
+int CreateRuleRequest::getFeatureType() const {
+  return featureType_;
 }
 
-int CreateRuleRequest::getRuleType()const
-{
-	return ruleType_;
+void CreateRuleRequest::setFeatureType(int featureType) {
+  featureType_ = featureType;
+  setParameter(std::string("FeatureType"), std::to_string(featureType));
 }
 
-void CreateRuleRequest::setRuleType(int ruleType)
-{
-	ruleType_ = ruleType;
-	setParameter("RuleType", std::to_string(ruleType));
+int CreateRuleRequest::getRuleType() const {
+  return ruleType_;
 }
 
-std::string CreateRuleRequest::getStatExpress()const
-{
-	return statExpress_;
+void CreateRuleRequest::setRuleType(int ruleType) {
+  ruleType_ = ruleType;
+  setParameter(std::string("RuleType"), std::to_string(ruleType));
 }
 
-void CreateRuleRequest::setStatExpress(const std::string& statExpress)
-{
-	statExpress_ = statExpress;
-	setParameter("StatExpress", statExpress);
+std::string CreateRuleRequest::getStatExpress() const {
+  return statExpress_;
 }
 
-int CreateRuleRequest::getContentCategory()const
-{
-	return contentCategory_;
+void CreateRuleRequest::setStatExpress(const std::string &statExpress) {
+  statExpress_ = statExpress;
+  setParameter(std::string("StatExpress"), statExpress);
 }
 
-void CreateRuleRequest::setContentCategory(int contentCategory)
-{
-	contentCategory_ = contentCategory;
-	setParameter("ContentCategory", std::to_string(contentCategory));
+int CreateRuleRequest::getContentCategory() const {
+  return contentCategory_;
 }
 
-long CreateRuleRequest::getCustomType()const
-{
-	return customType_;
+void CreateRuleRequest::setContentCategory(int contentCategory) {
+  contentCategory_ = contentCategory;
+  setParameter(std::string("ContentCategory"), std::to_string(contentCategory));
 }
 
-void CreateRuleRequest::setCustomType(long customType)
-{
-	customType_ = customType;
-	setParameter("CustomType", std::to_string(customType));
+long CreateRuleRequest::getCustomType() const {
+  return customType_;
 }
 
-std::string CreateRuleRequest::getTarget()const
-{
-	return target_;
+void CreateRuleRequest::setCustomType(long customType) {
+  customType_ = customType;
+  setParameter(std::string("CustomType"), std::to_string(customType));
 }
 
-void CreateRuleRequest::setTarget(const std::string& target)
-{
-	target_ = target;
-	setParameter("Target", target);
+std::string CreateRuleRequest::getTarget() const {
+  return target_;
 }
 
-std::string CreateRuleRequest::getName()const
-{
-	return name_;
+void CreateRuleRequest::setTarget(const std::string &target) {
+  target_ = target;
+  setParameter(std::string("Target"), target);
 }
 
-void CreateRuleRequest::setName(const std::string& name)
-{
-	name_ = name;
-	setParameter("Name", name);
+std::string CreateRuleRequest::getName() const {
+  return name_;
 }
 
-int CreateRuleRequest::getCategory()const
-{
-	return category_;
+void CreateRuleRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
 }
 
-void CreateRuleRequest::setCategory(int category)
-{
-	category_ = category;
-	setParameter("Category", std::to_string(category));
+int CreateRuleRequest::getCategory() const {
+  return category_;
 }
 
-int CreateRuleRequest::getStatus()const
-{
-	return status_;
+void CreateRuleRequest::setCategory(int category) {
+  category_ = category;
+  setParameter(std::string("Category"), std::to_string(category));
 }
 
-void CreateRuleRequest::setStatus(int status)
-{
-	status_ = status;
-	setParameter("Status", std::to_string(status));
+int CreateRuleRequest::getStatus() const {
+  return status_;
+}
+
+void CreateRuleRequest::setStatus(int status) {
+  status_ = status;
+  setParameter(std::string("Status"), std::to_string(status));
 }
 

sddp/src/model/CreateScanTaskRequest.cc

@@ -1,150 +1,135 @@
 /*
  * 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/sddp/model/CreateScanTaskRequest.h>
-
-using AlibabaCloud::Sddp::Model::CreateScanTaskRequest;
-
-CreateScanTaskRequest::CreateScanTaskRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "CreateScanTask")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateScanTaskRequest::~CreateScanTaskRequest()
-{}
-
-int CreateScanTaskRequest::getRunHour()const
-{
-	return runHour_;
+ */
+
+#include <alibabacloud/sddp/model/CreateScanTaskRequest.h>
+
+using AlibabaCloud::Sddp::Model::CreateScanTaskRequest;
+
+CreateScanTaskRequest::CreateScanTaskRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "CreateScanTask") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CreateScanTaskRequest::setRunHour(int runHour)
-{
-	runHour_ = runHour;
-	setParameter("RunHour", std::to_string(runHour));
+CreateScanTaskRequest::~CreateScanTaskRequest() {}
+
+int CreateScanTaskRequest::getRunHour() const {
+  return runHour_;
 }
 
-std::string CreateScanTaskRequest::getScanRangeContent()const
-{
-	return scanRangeContent_;
+void CreateScanTaskRequest::setRunHour(int runHour) {
+  runHour_ = runHour;
+  setParameter(std::string("RunHour"), std::to_string(runHour));
 }
 
-void CreateScanTaskRequest::setScanRangeContent(const std::string& scanRangeContent)
-{
-	scanRangeContent_ = scanRangeContent;
-	setParameter("ScanRangeContent", scanRangeContent);
+std::string CreateScanTaskRequest::getScanRangeContent() const {
+  return scanRangeContent_;
 }
 
-std::string CreateScanTaskRequest::getTaskName()const
-{
-	return taskName_;
+void CreateScanTaskRequest::setScanRangeContent(const std::string &scanRangeContent) {
+  scanRangeContent_ = scanRangeContent;
+  setParameter(std::string("ScanRangeContent"), scanRangeContent);
 }
 
-void CreateScanTaskRequest::setTaskName(const std::string& taskName)
-{
-	taskName_ = taskName;
-	setParameter("TaskName", taskName);
+std::string CreateScanTaskRequest::getTaskName() const {
+  return taskName_;
 }
 
-long CreateScanTaskRequest::getDataLimitId()const
-{
-	return dataLimitId_;
+void CreateScanTaskRequest::setTaskName(const std::string &taskName) {
+  taskName_ = taskName;
+  setParameter(std::string("TaskName"), taskName);
 }
 
-void CreateScanTaskRequest::setDataLimitId(long dataLimitId)
-{
-	dataLimitId_ = dataLimitId;
-	setParameter("DataLimitId", std::to_string(dataLimitId));
+long CreateScanTaskRequest::getDataLimitId() const {
+  return dataLimitId_;
 }
 
-int CreateScanTaskRequest::getRunMinute()const
-{
-	return runMinute_;
+void CreateScanTaskRequest::setDataLimitId(long dataLimitId) {
+  dataLimitId_ = dataLimitId;
+  setParameter(std::string("DataLimitId"), std::to_string(dataLimitId));
 }
 
-void CreateScanTaskRequest::setRunMinute(int runMinute)
-{
-	runMinute_ = runMinute;
-	setParameter("RunMinute", std::to_string(runMinute));
+int CreateScanTaskRequest::getRunMinute() const {
+  return runMinute_;
 }
 
-std::string CreateScanTaskRequest::getSourceIp()const
-{
-	return sourceIp_;
+void CreateScanTaskRequest::setRunMinute(int runMinute) {
+  runMinute_ = runMinute;
+  setParameter(std::string("RunMinute"), std::to_string(runMinute));
 }
 
-void CreateScanTaskRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+std::string CreateScanTaskRequest::getSourceIp() const {
+  return sourceIp_;
 }
 
-int CreateScanTaskRequest::getIntervalDay()const
-{
-	return intervalDay_;
+void CreateScanTaskRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
 }
 
-void CreateScanTaskRequest::setIntervalDay(int intervalDay)
-{
-	intervalDay_ = intervalDay;
-	setParameter("IntervalDay", std::to_string(intervalDay));
+int CreateScanTaskRequest::getIntervalDay() const {
+  return intervalDay_;
 }
 
-int CreateScanTaskRequest::getScanRange()const
-{
-	return scanRange_;
+void CreateScanTaskRequest::setIntervalDay(int intervalDay) {
+  intervalDay_ = intervalDay;
+  setParameter(std::string("IntervalDay"), std::to_string(intervalDay));
 }
 
-void CreateScanTaskRequest::setScanRange(int scanRange)
-{
-	scanRange_ = scanRange;
-	setParameter("ScanRange", std::to_string(scanRange));
+int CreateScanTaskRequest::getScanRange() const {
+  return scanRange_;
 }
 
-std::string CreateScanTaskRequest::getOssScanPath()const
-{
-	return ossScanPath_;
+void CreateScanTaskRequest::setScanRange(int scanRange) {
+  scanRange_ = scanRange;
+  setParameter(std::string("ScanRange"), std::to_string(scanRange));
 }
 
-void CreateScanTaskRequest::setOssScanPath(const std::string& ossScanPath)
-{
-	ossScanPath_ = ossScanPath;
-	setParameter("OssScanPath", ossScanPath);
+std::string CreateScanTaskRequest::getLang() const {
+  return lang_;
 }
 
-long CreateScanTaskRequest::getResourceType()const
-{
-	return resourceType_;
+void CreateScanTaskRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 
-void CreateScanTaskRequest::setResourceType(long resourceType)
-{
-	resourceType_ = resourceType;
-	setParameter("ResourceType", std::to_string(resourceType));
+std::string CreateScanTaskRequest::getOssScanPath() const {
+  return ossScanPath_;
 }
 
-std::string CreateScanTaskRequest::getTaskUserName()const
-{
-	return taskUserName_;
+void CreateScanTaskRequest::setOssScanPath(const std::string &ossScanPath) {
+  ossScanPath_ = ossScanPath;
+  setParameter(std::string("OssScanPath"), ossScanPath);
 }
 
-void CreateScanTaskRequest::setTaskUserName(const std::string& taskUserName)
-{
-	taskUserName_ = taskUserName;
-	setParameter("TaskUserName", taskUserName);
+long CreateScanTaskRequest::getResourceType() const {
+  return resourceType_;
+}
+
+void CreateScanTaskRequest::setResourceType(long resourceType) {
+  resourceType_ = resourceType;
+  setParameter(std::string("ResourceType"), std::to_string(resourceType));
+}
+
+std::string CreateScanTaskRequest::getTaskUserName() const {
+  return taskUserName_;
+}
+
+void CreateScanTaskRequest::setTaskUserName(const std::string &taskUserName) {
+  taskUserName_ = taskUserName;
+  setParameter(std::string("TaskUserName"), taskUserName);
 }
 

sddp/src/model/CreateSlrRoleRequest.cc

@@ -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/sddp/model/CreateSlrRoleRequest.h>
+
+using AlibabaCloud::Sddp::Model::CreateSlrRoleRequest;
+
+CreateSlrRoleRequest::CreateSlrRoleRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "CreateSlrRole") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateSlrRoleRequest::~CreateSlrRoleRequest() {}
+
+std::string CreateSlrRoleRequest::getSourceIp() const {
+  return sourceIp_;
+}
+
+void CreateSlrRoleRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
+}
+
+std::string CreateSlrRoleRequest::getLang() const {
+  return lang_;
+}
+
+void CreateSlrRoleRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
+}
+

sddp/src/model/CreateSlrRoleResult.cc

@@ -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/sddp/model/CreateSlrRoleResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Sddp;
+using namespace AlibabaCloud::Sddp::Model;
+
+CreateSlrRoleResult::CreateSlrRoleResult() :
+	ServiceResult()
+{}
+
+CreateSlrRoleResult::CreateSlrRoleResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateSlrRoleResult::~CreateSlrRoleResult()
+{}
+
+void CreateSlrRoleResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["HasPermission"].isNull())
+		hasPermission_ = value["HasPermission"].asString() == "true";
+
+}
+
+bool CreateSlrRoleResult::getHasPermission()const
+{
+	return hasPermission_;
+}
+

sddp/src/model/DeleteDataLimitRequest.cc

@@ -1,73 +1,63 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
-
-#include <alibabacloud/sddp/model/DeleteDataLimitRequest.h>
-
-using AlibabaCloud::Sddp::Model::DeleteDataLimitRequest;
-
-DeleteDataLimitRequest::DeleteDataLimitRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "DeleteDataLimit")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DeleteDataLimitRequest::~DeleteDataLimitRequest()
-{}
-
-int DeleteDataLimitRequest::getFeatureType()const
-{
-	return featureType_;
+ */
+
+#include <alibabacloud/sddp/model/DeleteDataLimitRequest.h>
+
+using AlibabaCloud::Sddp::Model::DeleteDataLimitRequest;
+
+DeleteDataLimitRequest::DeleteDataLimitRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "DeleteDataLimit") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DeleteDataLimitRequest::setFeatureType(int featureType)
-{
-	featureType_ = featureType;
-	setParameter("FeatureType", std::to_string(featureType));
+DeleteDataLimitRequest::~DeleteDataLimitRequest() {}
+
+int DeleteDataLimitRequest::getFeatureType() const {
+  return featureType_;
 }
 
-std::string DeleteDataLimitRequest::getSourceIp()const
-{
-	return sourceIp_;
+void DeleteDataLimitRequest::setFeatureType(int featureType) {
+  featureType_ = featureType;
+  setParameter(std::string("FeatureType"), std::to_string(featureType));
 }
 
-void DeleteDataLimitRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+std::string DeleteDataLimitRequest::getSourceIp() const {
+  return sourceIp_;
 }
 
-long DeleteDataLimitRequest::getId()const
-{
-	return id_;
+void DeleteDataLimitRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
 }
 
-void DeleteDataLimitRequest::setId(long id)
-{
-	id_ = id;
-	setParameter("Id", std::to_string(id));
+long DeleteDataLimitRequest::getId() const {
+  return id_;
 }
 
-std::string DeleteDataLimitRequest::getLang()const
-{
-	return lang_;
+void DeleteDataLimitRequest::setId(long id) {
+  id_ = id;
+  setParameter(std::string("Id"), std::to_string(id));
 }
 
-void DeleteDataLimitRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
+std::string DeleteDataLimitRequest::getLang() const {
+  return lang_;
+}
+
+void DeleteDataLimitRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 

sddp/src/model/DeleteRuleRequest.cc

@@ -1,73 +1,63 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
-
-#include <alibabacloud/sddp/model/DeleteRuleRequest.h>
-
-using AlibabaCloud::Sddp::Model::DeleteRuleRequest;
-
-DeleteRuleRequest::DeleteRuleRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "DeleteRule")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DeleteRuleRequest::~DeleteRuleRequest()
-{}
-
-int DeleteRuleRequest::getFeatureType()const
-{
-	return featureType_;
+ */
+
+#include <alibabacloud/sddp/model/DeleteRuleRequest.h>
+
+using AlibabaCloud::Sddp::Model::DeleteRuleRequest;
+
+DeleteRuleRequest::DeleteRuleRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "DeleteRule") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DeleteRuleRequest::setFeatureType(int featureType)
-{
-	featureType_ = featureType;
-	setParameter("FeatureType", std::to_string(featureType));
+DeleteRuleRequest::~DeleteRuleRequest() {}
+
+int DeleteRuleRequest::getFeatureType() const {
+  return featureType_;
 }
 
-std::string DeleteRuleRequest::getSourceIp()const
-{
-	return sourceIp_;
+void DeleteRuleRequest::setFeatureType(int featureType) {
+  featureType_ = featureType;
+  setParameter(std::string("FeatureType"), std::to_string(featureType));
 }
 
-void DeleteRuleRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+std::string DeleteRuleRequest::getSourceIp() const {
+  return sourceIp_;
 }
 
-long DeleteRuleRequest::getId()const
-{
-	return id_;
+void DeleteRuleRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
 }
 
-void DeleteRuleRequest::setId(long id)
-{
-	id_ = id;
-	setParameter("Id", std::to_string(id));
+long DeleteRuleRequest::getId() const {
+  return id_;
 }
 
-std::string DeleteRuleRequest::getLang()const
-{
-	return lang_;
+void DeleteRuleRequest::setId(long id) {
+  id_ = id;
+  setParameter(std::string("Id"), std::to_string(id));
 }
 
-void DeleteRuleRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
+std::string DeleteRuleRequest::getLang() const {
+  return lang_;
+}
+
+void DeleteRuleRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 

sddp/src/model/DescribeAccountDetailRequest.cc

@@ -1,73 +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/sddp/model/DescribeAccountDetailRequest.h>
-
-using AlibabaCloud::Sddp::Model::DescribeAccountDetailRequest;
-
-DescribeAccountDetailRequest::DescribeAccountDetailRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "DescribeAccountDetail")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeAccountDetailRequest::~DescribeAccountDetailRequest()
-{}
-
-long DescribeAccountDetailRequest::getUserId()const
-{
-	return userId_;
-}
-
-void DescribeAccountDetailRequest::setUserId(long userId)
-{
-	userId_ = userId;
-	setParameter("UserId", std::to_string(userId));
-}
-
-long DescribeAccountDetailRequest::getAccountTypeId()const
-{
-	return accountTypeId_;
-}
-
-void DescribeAccountDetailRequest::setAccountTypeId(long accountTypeId)
-{
-	accountTypeId_ = accountTypeId;
-	setParameter("AccountTypeId", std::to_string(accountTypeId));
-}
-
-std::string DescribeAccountDetailRequest::getSourceIp()const
-{
-	return sourceIp_;
-}
-
-void DescribeAccountDetailRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
-}
-
-std::string DescribeAccountDetailRequest::getLang()const
-{
-	return lang_;
-}
-
-void DescribeAccountDetailRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
-}
-

sddp/src/model/DescribeAccountDetailResult.cc

@@ -1,112 +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/sddp/model/DescribeAccountDetailResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Sddp;
-using namespace AlibabaCloud::Sddp::Model;
-
-DescribeAccountDetailResult::DescribeAccountDetailResult() :
-	ServiceResult()
-{}
-
-DescribeAccountDetailResult::DescribeAccountDetailResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-DescribeAccountDetailResult::~DescribeAccountDetailResult()
-{}
-
-void DescribeAccountDetailResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto accountNode = value["Account"];
-	if(!accountNode["Id"].isNull())
-		account_.id = std::stol(accountNode["Id"].asString());
-	if(!accountNode["UserId"].isNull())
-		account_.userId = std::stol(accountNode["UserId"].asString());
-	if(!accountNode["FirstLevelDepartId"].isNull())
-		account_.firstLevelDepartId = std::stol(accountNode["FirstLevelDepartId"].asString());
-	if(!accountNode["LoginName"].isNull())
-		account_.loginName = accountNode["LoginName"].asString();
-	if(!accountNode["FullName"].isNull())
-		account_.fullName = accountNode["FullName"].asString();
-	if(!accountNode["CellphoneNum"].isNull())
-		account_.cellphoneNum = accountNode["CellphoneNum"].asString();
-	if(!accountNode["TelephoneNum"].isNull())
-		account_.telephoneNum = accountNode["TelephoneNum"].asString();
-	if(!accountNode["Email"].isNull())
-		account_.email = accountNode["Email"].asString();
-	if(!accountNode["ActiveStatus"].isNull())
-		account_.activeStatus = accountNode["ActiveStatus"].asString();
-	if(!accountNode["DeleteStatus"].isNull())
-		account_.deleteStatus = accountNode["DeleteStatus"].asString();
-	if(!accountNode["DataInstance"].isNull())
-		account_.dataInstance = accountNode["DataInstance"].asString();
-	if(!accountNode["CreateTime"].isNull())
-		account_.createTime = std::stol(accountNode["CreateTime"].asString());
-	if(!accountNode["LoginDataTime"].isNull())
-		account_.loginDataTime = std::stol(accountNode["LoginDataTime"].asString());
-	if(!accountNode["LoginPolicyName"].isNull())
-		account_.loginPolicyName = accountNode["LoginPolicyName"].asString();
-	if(!accountNode["FirstLevelDepartName"].isNull())
-		account_.firstLevelDepartName = accountNode["FirstLevelDepartName"].asString();
-	if(!accountNode["RoleNames"].isNull())
-		account_.roleNames = accountNode["RoleNames"].asString();
-	if(!accountNode["AliUid"].isNull())
-		account_.aliUid = std::stol(accountNode["AliUid"].asString());
-	auto allPrivilegeListNode = accountNode["PrivilegeList"]["Privilege"];
-	for (auto accountNodePrivilegeListPrivilege : allPrivilegeListNode)
-	{
-		Account::Privilege privilegeObject;
-		if(!accountNodePrivilegeListPrivilege["ProductName"].isNull())
-			privilegeObject.productName = accountNodePrivilegeListPrivilege["ProductName"].asString();
-		if(!accountNodePrivilegeListPrivilege["UseAccountId"].isNull())
-			privilegeObject.useAccountId = accountNodePrivilegeListPrivilege["UseAccountId"].asString();
-		if(!accountNodePrivilegeListPrivilege["UseAccountType"].isNull())
-			privilegeObject.useAccountType = std::stoi(accountNodePrivilegeListPrivilege["UseAccountType"].asString());
-		if(!accountNodePrivilegeListPrivilege["UseAccountTypeName"].isNull())
-			privilegeObject.useAccountTypeName = accountNodePrivilegeListPrivilege["UseAccountTypeName"].asString();
-		if(!accountNodePrivilegeListPrivilege["UseAccountCreateTime"].isNull())
-			privilegeObject.useAccountCreateTime = std::stol(accountNodePrivilegeListPrivilege["UseAccountCreateTime"].asString());
-		if(!accountNodePrivilegeListPrivilege["UseAccountName"].isNull())
-			privilegeObject.useAccountName = accountNodePrivilegeListPrivilege["UseAccountName"].asString();
-		account_.privilegeList.push_back(privilegeObject);
-	}
-	auto eventCountNode = accountNode["EventCount"];
-	auto totalNode = eventCountNode["Total"];
-	if(!totalNode["TotalCount"].isNull())
-		account_.eventCount.total.totalCount = std::stol(totalNode["TotalCount"].asString());
-	if(!totalNode["UndealCount"].isNull())
-		account_.eventCount.total.undealCount = std::stol(totalNode["UndealCount"].asString());
-	if(!totalNode["ConfirmCount"].isNull())
-		account_.eventCount.total.confirmCount = std::stol(totalNode["ConfirmCount"].asString());
-	if(!totalNode["ExcludeCount"].isNull())
-		account_.eventCount.total.excludeCount = std::stol(totalNode["ExcludeCount"].asString());
-
-}
-
-DescribeAccountDetailResult::Account DescribeAccountDetailResult::getAccount()const
-{
-	return account_;
-}
-

sddp/src/model/DescribeAccountsRequest.cc

@@ -1,194 +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/sddp/model/DescribeAccountsRequest.h>
-
-using AlibabaCloud::Sddp::Model::DescribeAccountsRequest;
-
-DescribeAccountsRequest::DescribeAccountsRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "DescribeAccounts")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeAccountsRequest::~DescribeAccountsRequest()
-{}
-
-std::string DescribeAccountsRequest::getProductCode()const
-{
-	return productCode_;
-}
-
-void DescribeAccountsRequest::setProductCode(const std::string& productCode)
-{
-	productCode_ = productCode;
-	setParameter("ProductCode", productCode);
-}
-
-std::string DescribeAccountsRequest::getPackageId()const
-{
-	return packageId_;
-}
-
-void DescribeAccountsRequest::setPackageId(const std::string& packageId)
-{
-	packageId_ = packageId;
-	setParameter("PackageId", packageId);
-}
-
-std::string DescribeAccountsRequest::getSourceIp()const
-{
-	return sourceIp_;
-}
-
-void DescribeAccountsRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
-}
-
-int DescribeAccountsRequest::getPageSize()const
-{
-	return pageSize_;
-}
-
-void DescribeAccountsRequest::setPageSize(int pageSize)
-{
-	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
-}
-
-std::string DescribeAccountsRequest::getTableId()const
-{
-	return tableId_;
-}
-
-void DescribeAccountsRequest::setTableId(const std::string& tableId)
-{
-	tableId_ = tableId;
-	setParameter("TableId", tableId);
-}
-
-std::string DescribeAccountsRequest::getLang()const
-{
-	return lang_;
-}
-
-void DescribeAccountsRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
-}
-
-std::string DescribeAccountsRequest::getKey()const
-{
-	return key_;
-}
-
-void DescribeAccountsRequest::setKey(const std::string& key)
-{
-	key_ = key;
-	setParameter("Key", key);
-}
-
-int DescribeAccountsRequest::getQueryType()const
-{
-	return queryType_;
-}
-
-void DescribeAccountsRequest::setQueryType(int queryType)
-{
-	queryType_ = queryType;
-	setParameter("QueryType", std::to_string(queryType));
-}
-
-std::string DescribeAccountsRequest::getLoginName()const
-{
-	return loginName_;
-}
-
-void DescribeAccountsRequest::setLoginName(const std::string& loginName)
-{
-	loginName_ = loginName;
-	setParameter("LoginName", loginName);
-}
-
-int DescribeAccountsRequest::getFeatureType()const
-{
-	return featureType_;
-}
-
-void DescribeAccountsRequest::setFeatureType(int featureType)
-{
-	featureType_ = featureType;
-	setParameter("FeatureType", std::to_string(featureType));
-}
-
-std::string DescribeAccountsRequest::getColumnId()const
-{
-	return columnId_;
-}
-
-void DescribeAccountsRequest::setColumnId(const std::string& columnId)
-{
-	columnId_ = columnId;
-	setParameter("ColumnId", columnId);
-}
-
-int DescribeAccountsRequest::getCurrentPage()const
-{
-	return currentPage_;
-}
-
-void DescribeAccountsRequest::setCurrentPage(int currentPage)
-{
-	currentPage_ = currentPage;
-	setParameter("CurrentPage", std::to_string(currentPage));
-}
-
-std::string DescribeAccountsRequest::getInstanceId()const
-{
-	return instanceId_;
-}
-
-void DescribeAccountsRequest::setInstanceId(const std::string& instanceId)
-{
-	instanceId_ = instanceId;
-	setParameter("InstanceId", instanceId);
-}
-
-long DescribeAccountsRequest::getDepartId()const
-{
-	return departId_;
-}
-
-void DescribeAccountsRequest::setDepartId(long departId)
-{
-	departId_ = departId;
-	setParameter("DepartId", std::to_string(departId));
-}
-
-int DescribeAccountsRequest::getOperationId()const
-{
-	return operationId_;
-}
-
-void DescribeAccountsRequest::setOperationId(int operationId)
-{
-	operationId_ = operationId;
-	setParameter("OperationId", std::to_string(operationId));
-}
-

sddp/src/model/DescribeAccountsResult.cc

@@ -1,124 +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/sddp/model/DescribeAccountsResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Sddp;
-using namespace AlibabaCloud::Sddp::Model;
-
-DescribeAccountsResult::DescribeAccountsResult() :
-	ServiceResult()
-{}
-
-DescribeAccountsResult::DescribeAccountsResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-DescribeAccountsResult::~DescribeAccountsResult()
-{}
-
-void DescribeAccountsResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto allItemsNode = value["Items"]["Account"];
-	for (auto valueItemsAccount : allItemsNode)
-	{
-		Account itemsObject;
-		if(!valueItemsAccount["Id"].isNull())
-			itemsObject.id = std::stol(valueItemsAccount["Id"].asString());
-		if(!valueItemsAccount["UserId"].isNull())
-			itemsObject.userId = std::stol(valueItemsAccount["UserId"].asString());
-		if(!valueItemsAccount["FirstLevelDepartId"].isNull())
-			itemsObject.firstLevelDepartId = std::stol(valueItemsAccount["FirstLevelDepartId"].asString());
-		if(!valueItemsAccount["LoginName"].isNull())
-			itemsObject.loginName = valueItemsAccount["LoginName"].asString();
-		if(!valueItemsAccount["FullName"].isNull())
-			itemsObject.fullName = valueItemsAccount["FullName"].asString();
-		if(!valueItemsAccount["CellphoneNum"].isNull())
-			itemsObject.cellphoneNum = valueItemsAccount["CellphoneNum"].asString();
-		if(!valueItemsAccount["TelephoneNum"].isNull())
-			itemsObject.telephoneNum = valueItemsAccount["TelephoneNum"].asString();
-		if(!valueItemsAccount["Email"].isNull())
-			itemsObject.email = valueItemsAccount["Email"].asString();
-		if(!valueItemsAccount["ActiveStatus"].isNull())
-			itemsObject.activeStatus = valueItemsAccount["ActiveStatus"].asString();
-		if(!valueItemsAccount["DeleteStatus"].isNull())
-			itemsObject.deleteStatus = valueItemsAccount["DeleteStatus"].asString();
-		if(!valueItemsAccount["DataInstance"].isNull())
-			itemsObject.dataInstance = valueItemsAccount["DataInstance"].asString();
-		if(!valueItemsAccount["CreateTime"].isNull())
-			itemsObject.createTime = std::stol(valueItemsAccount["CreateTime"].asString());
-		if(!valueItemsAccount["LoginDataTime"].isNull())
-			itemsObject.loginDataTime = std::stol(valueItemsAccount["LoginDataTime"].asString());
-		if(!valueItemsAccount["LoginPolicyName"].isNull())
-			itemsObject.loginPolicyName = valueItemsAccount["LoginPolicyName"].asString();
-		if(!valueItemsAccount["FirstLevelDepartName"].isNull())
-			itemsObject.firstLevelDepartName = valueItemsAccount["FirstLevelDepartName"].asString();
-		if(!valueItemsAccount["RoleNames"].isNull())
-			itemsObject.roleNames = valueItemsAccount["RoleNames"].asString();
-		if(!valueItemsAccount["InstanceName"].isNull())
-			itemsObject.instanceName = valueItemsAccount["InstanceName"].asString();
-		if(!valueItemsAccount["AliUid"].isNull())
-			itemsObject.aliUid = std::stol(valueItemsAccount["AliUid"].asString());
-		if(!valueItemsAccount["AccountTypeId"].isNull())
-			itemsObject.accountTypeId = std::stol(valueItemsAccount["AccountTypeId"].asString());
-		auto eventCountNode = value["EventCount"];
-		auto totalNode = eventCountNode["Total"];
-		if(!totalNode["TotalCount"].isNull())
-			itemsObject.eventCount.total.totalCount = std::stol(totalNode["TotalCount"].asString());
-		if(!totalNode["UndealCount"].isNull())
-			itemsObject.eventCount.total.undealCount = std::stol(totalNode["UndealCount"].asString());
-		if(!totalNode["ConfirmCount"].isNull())
-			itemsObject.eventCount.total.confirmCount = std::stol(totalNode["ConfirmCount"].asString());
-		if(!totalNode["ExcludeCount"].isNull())
-			itemsObject.eventCount.total.excludeCount = std::stol(totalNode["ExcludeCount"].asString());
-		items_.push_back(itemsObject);
-	}
-	if(!value["PageSize"].isNull())
-		pageSize_ = std::stoi(value["PageSize"].asString());
-	if(!value["CurrentPage"].isNull())
-		currentPage_ = std::stoi(value["CurrentPage"].asString());
-	if(!value["TotalCount"].isNull())
-		totalCount_ = std::stoi(value["TotalCount"].asString());
-
-}
-
-int DescribeAccountsResult::getTotalCount()const
-{
-	return totalCount_;
-}
-
-int DescribeAccountsResult::getPageSize()const
-{
-	return pageSize_;
-}
-
-int DescribeAccountsResult::getCurrentPage()const
-{
-	return currentPage_;
-}
-
-std::vector<DescribeAccountsResult::Account> DescribeAccountsResult::getItems()const
-{
-	return items_;
-}
-

sddp/src/model/DescribeCategoryTemplateRuleListRequest.cc

@@ -0,0 +1,108 @@
+/*
+ * 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/sddp/model/DescribeCategoryTemplateRuleListRequest.h>
+
+using AlibabaCloud::Sddp::Model::DescribeCategoryTemplateRuleListRequest;
+
+DescribeCategoryTemplateRuleListRequest::DescribeCategoryTemplateRuleListRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "DescribeCategoryTemplateRuleList") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeCategoryTemplateRuleListRequest::~DescribeCategoryTemplateRuleListRequest() {}
+
+long DescribeCategoryTemplateRuleListRequest::getRiskLevelId() const {
+  return riskLevelId_;
+}
+
+void DescribeCategoryTemplateRuleListRequest::setRiskLevelId(long riskLevelId) {
+  riskLevelId_ = riskLevelId;
+  setParameter(std::string("RiskLevelId"), std::to_string(riskLevelId));
+}
+
+std::string DescribeCategoryTemplateRuleListRequest::getSourceIp() const {
+  return sourceIp_;
+}
+
+void DescribeCategoryTemplateRuleListRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
+}
+
+int DescribeCategoryTemplateRuleListRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void DescribeCategoryTemplateRuleListRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+std::string DescribeCategoryTemplateRuleListRequest::getLang() const {
+  return lang_;
+}
+
+void DescribeCategoryTemplateRuleListRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
+}
+
+std::string DescribeCategoryTemplateRuleListRequest::getParentCategoryIdList() const {
+  return parentCategoryIdList_;
+}
+
+void DescribeCategoryTemplateRuleListRequest::setParentCategoryIdList(const std::string &parentCategoryIdList) {
+  parentCategoryIdList_ = parentCategoryIdList;
+  setParameter(std::string("ParentCategoryIdList"), parentCategoryIdList);
+}
+
+int DescribeCategoryTemplateRuleListRequest::getCurrentPage() const {
+  return currentPage_;
+}
+
+void DescribeCategoryTemplateRuleListRequest::setCurrentPage(int currentPage) {
+  currentPage_ = currentPage;
+  setParameter(std::string("CurrentPage"), std::to_string(currentPage));
+}
+
+long DescribeCategoryTemplateRuleListRequest::getTemplateId() const {
+  return templateId_;
+}
+
+void DescribeCategoryTemplateRuleListRequest::setTemplateId(long templateId) {
+  templateId_ = templateId;
+  setParameter(std::string("TemplateId"), std::to_string(templateId));
+}
+
+int DescribeCategoryTemplateRuleListRequest::getCustomType() const {
+  return customType_;
+}
+
+void DescribeCategoryTemplateRuleListRequest::setCustomType(int customType) {
+  customType_ = customType;
+  setParameter(std::string("CustomType"), std::to_string(customType));
+}
+
+int DescribeCategoryTemplateRuleListRequest::getStatus() const {
+  return status_;
+}
+
+void DescribeCategoryTemplateRuleListRequest::setStatus(int status) {
+  status_ = status;
+  setParameter(std::string("Status"), std::to_string(status));
+}
+

sddp/src/model/DescribeCategoryTemplateRuleListResult.cc

@@ -0,0 +1,100 @@
+/*
+ * 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/sddp/model/DescribeCategoryTemplateRuleListResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Sddp;
+using namespace AlibabaCloud::Sddp::Model;
+
+DescribeCategoryTemplateRuleListResult::DescribeCategoryTemplateRuleListResult() :
+	ServiceResult()
+{}
+
+DescribeCategoryTemplateRuleListResult::DescribeCategoryTemplateRuleListResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeCategoryTemplateRuleListResult::~DescribeCategoryTemplateRuleListResult()
+{}
+
+void DescribeCategoryTemplateRuleListResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allItemsNode = value["Items"]["DataLimit"];
+	for (auto valueItemsDataLimit : allItemsNode)
+	{
+		DataLimit itemsObject;
+		if(!valueItemsDataLimit["Status"].isNull())
+			itemsObject.status = std::stoi(valueItemsDataLimit["Status"].asString());
+		if(!valueItemsDataLimit["IdentificationScope"].isNull())
+			itemsObject.identificationScope = valueItemsDataLimit["IdentificationScope"].asString();
+		if(!valueItemsDataLimit["RiskLevelId"].isNull())
+			itemsObject.riskLevelId = std::stol(valueItemsDataLimit["RiskLevelId"].asString());
+		if(!valueItemsDataLimit["ParentCategoryId"].isNull())
+			itemsObject.parentCategoryId = std::stol(valueItemsDataLimit["ParentCategoryId"].asString());
+		if(!valueItemsDataLimit["Description"].isNull())
+			itemsObject.description = valueItemsDataLimit["Description"].asString();
+		if(!valueItemsDataLimit["CustomType"].isNull())
+			itemsObject.customType = std::stoi(valueItemsDataLimit["CustomType"].asString());
+		if(!valueItemsDataLimit["IdentificationRuleIds"].isNull())
+			itemsObject.identificationRuleIds = valueItemsDataLimit["IdentificationRuleIds"].asString();
+		if(!valueItemsDataLimit["Name"].isNull())
+			itemsObject.name = valueItemsDataLimit["Name"].asString();
+		if(!valueItemsDataLimit["OrderNum"].isNull())
+			itemsObject.orderNum = std::stoi(valueItemsDataLimit["OrderNum"].asString());
+		if(!valueItemsDataLimit["TemplateId"].isNull())
+			itemsObject.templateId = std::stol(valueItemsDataLimit["TemplateId"].asString());
+		if(!valueItemsDataLimit["Id"].isNull())
+			itemsObject.id = std::stol(valueItemsDataLimit["Id"].asString());
+		if(!valueItemsDataLimit["CategoryLevel"].isNull())
+			itemsObject.categoryLevel = std::stoi(valueItemsDataLimit["CategoryLevel"].asString());
+		items_.push_back(itemsObject);
+	}
+	if(!value["CurrentPage"].isNull())
+		currentPage_ = std::stoi(value["CurrentPage"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+
+}
+
+int DescribeCategoryTemplateRuleListResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int DescribeCategoryTemplateRuleListResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeCategoryTemplateRuleListResult::getCurrentPage()const
+{
+	return currentPage_;
+}
+
+std::vector<DescribeCategoryTemplateRuleListResult::DataLimit> DescribeCategoryTemplateRuleListResult::getItems()const
+{
+	return items_;
+}
+

sddp/src/model/DescribeColumnsRequest.cc

@@ -1,227 +1,189 @@
 /*
  * 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/sddp/model/DescribeColumnsRequest.h>
-
-using AlibabaCloud::Sddp::Model::DescribeColumnsRequest;
-
-DescribeColumnsRequest::DescribeColumnsRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "DescribeColumns")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeColumnsRequest::~DescribeColumnsRequest()
-{}
-
-std::string DescribeColumnsRequest::getProductCode()const
-{
-	return productCode_;
+ */
+
+#include <alibabacloud/sddp/model/DescribeColumnsRequest.h>
+
+using AlibabaCloud::Sddp::Model::DescribeColumnsRequest;
+
+DescribeColumnsRequest::DescribeColumnsRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "DescribeColumns") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeColumnsRequest::setProductCode(const std::string& productCode)
-{
-	productCode_ = productCode;
-	setParameter("ProductCode", productCode);
+DescribeColumnsRequest::~DescribeColumnsRequest() {}
+
+std::string DescribeColumnsRequest::getProductCode() const {
+  return productCode_;
 }
 
-std::string DescribeColumnsRequest::getRiskLevels()const
-{
-	return riskLevels_;
+void DescribeColumnsRequest::setProductCode(const std::string &productCode) {
+  productCode_ = productCode;
+  setParameter(std::string("ProductCode"), productCode);
 }
 
-void DescribeColumnsRequest::setRiskLevels(const std::string& riskLevels)
-{
-	riskLevels_ = riskLevels;
-	setParameter("RiskLevels", riskLevels);
+std::string DescribeColumnsRequest::getRiskLevels() const {
+  return riskLevels_;
 }
 
-std::string DescribeColumnsRequest::getRuleName()const
-{
-	return ruleName_;
+void DescribeColumnsRequest::setRiskLevels(const std::string &riskLevels) {
+  riskLevels_ = riskLevels;
+  setParameter(std::string("RiskLevels"), riskLevels);
 }
 
-void DescribeColumnsRequest::setRuleName(const std::string& ruleName)
-{
-	ruleName_ = ruleName;
-	setParameter("RuleName", ruleName);
+std::string DescribeColumnsRequest::getRuleName() const {
+  return ruleName_;
 }
 
-std::string DescribeColumnsRequest::getQueryName()const
-{
-	return queryName_;
+void DescribeColumnsRequest::setRuleName(const std::string &ruleName) {
+  ruleName_ = ruleName;
+  setParameter(std::string("RuleName"), ruleName);
 }
 
-void DescribeColumnsRequest::setQueryName(const std::string& queryName)
-{
-	queryName_ = queryName;
-	setParameter("QueryName", queryName);
+std::string DescribeColumnsRequest::getQueryName() const {
+  return queryName_;
 }
 
-long DescribeColumnsRequest::getRiskLevelId()const
-{
-	return riskLevelId_;
+void DescribeColumnsRequest::setQueryName(const std::string &queryName) {
+  queryName_ = queryName;
+  setParameter(std::string("QueryName"), queryName);
 }
 
-void DescribeColumnsRequest::setRiskLevelId(long riskLevelId)
-{
-	riskLevelId_ = riskLevelId;
-	setParameter("RiskLevelId", std::to_string(riskLevelId));
+long DescribeColumnsRequest::getRiskLevelId() const {
+  return riskLevelId_;
 }
 
-std::string DescribeColumnsRequest::getSensLevelName()const
-{
-	return sensLevelName_;
+void DescribeColumnsRequest::setRiskLevelId(long riskLevelId) {
+  riskLevelId_ = riskLevelId;
+  setParameter(std::string("RiskLevelId"), std::to_string(riskLevelId));
 }
 
-void DescribeColumnsRequest::setSensLevelName(const std::string& sensLevelName)
-{
-	sensLevelName_ = sensLevelName;
-	setParameter("SensLevelName", sensLevelName);
+std::string DescribeColumnsRequest::getSensLevelName() const {
+  return sensLevelName_;
 }
 
-std::string DescribeColumnsRequest::getSourceIp()const
-{
-	return sourceIp_;
+void DescribeColumnsRequest::setSensLevelName(const std::string &sensLevelName) {
+  sensLevelName_ = sensLevelName;
+  setParameter(std::string("SensLevelName"), sensLevelName);
 }
 
-void DescribeColumnsRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+std::string DescribeColumnsRequest::getSourceIp() const {
+  return sourceIp_;
 }
 
-int DescribeColumnsRequest::getPageSize()const
-{
-	return pageSize_;
+void DescribeColumnsRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
 }
 
-void DescribeColumnsRequest::setPageSize(int pageSize)
-{
-	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
+int DescribeColumnsRequest::getPageSize() const {
+  return pageSize_;
 }
 
-long DescribeColumnsRequest::getTableId()const
-{
-	return tableId_;
+void DescribeColumnsRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
 }
 
-void DescribeColumnsRequest::setTableId(long tableId)
-{
-	tableId_ = tableId;
-	setParameter("TableId", std::to_string(tableId));
+long DescribeColumnsRequest::getTableId() const {
+  return tableId_;
 }
 
-std::string DescribeColumnsRequest::getLang()const
-{
-	return lang_;
+void DescribeColumnsRequest::setTableId(long tableId) {
+  tableId_ = tableId;
+  setParameter(std::string("TableId"), std::to_string(tableId));
 }
 
-void DescribeColumnsRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
+std::string DescribeColumnsRequest::getLang() const {
+  return lang_;
 }
 
-std::string DescribeColumnsRequest::getTableName()const
-{
-	return tableName_;
+void DescribeColumnsRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 
-void DescribeColumnsRequest::setTableName(const std::string& tableName)
-{
-	tableName_ = tableName;
-	setParameter("TableName", tableName);
+std::string DescribeColumnsRequest::getTableName() const {
+  return tableName_;
 }
 
-int DescribeColumnsRequest::getFeatureType()const
-{
-	return featureType_;
+void DescribeColumnsRequest::setTableName(const std::string &tableName) {
+  tableName_ = tableName;
+  setParameter(std::string("TableName"), tableName);
 }
 
-void DescribeColumnsRequest::setFeatureType(int featureType)
-{
-	featureType_ = featureType;
-	setParameter("FeatureType", std::to_string(featureType));
+int DescribeColumnsRequest::getFeatureType() const {
+  return featureType_;
 }
 
-std::string DescribeColumnsRequest::getOrderBy()const
-{
-	return orderBy_;
+void DescribeColumnsRequest::setFeatureType(int featureType) {
+  featureType_ = featureType;
+  setParameter(std::string("FeatureType"), std::to_string(featureType));
 }
 
-void DescribeColumnsRequest::setOrderBy(const std::string& orderBy)
-{
-	orderBy_ = orderBy;
-	setParameter("OrderBy", orderBy);
+std::string DescribeColumnsRequest::getOrderBy() const {
+  return orderBy_;
 }
 
-int DescribeColumnsRequest::getCurrentPage()const
-{
-	return currentPage_;
+void DescribeColumnsRequest::setOrderBy(const std::string &orderBy) {
+  orderBy_ = orderBy;
+  setParameter(std::string("OrderBy"), orderBy);
 }
 
-void DescribeColumnsRequest::setCurrentPage(int currentPage)
-{
-	currentPage_ = currentPage;
-	setParameter("CurrentPage", std::to_string(currentPage));
+int DescribeColumnsRequest::getCurrentPage() const {
+  return currentPage_;
 }
 
-long DescribeColumnsRequest::getInstanceId()const
-{
-	return instanceId_;
+void DescribeColumnsRequest::setCurrentPage(int currentPage) {
+  currentPage_ = currentPage;
+  setParameter(std::string("CurrentPage"), std::to_string(currentPage));
 }
 
-void DescribeColumnsRequest::setInstanceId(long instanceId)
-{
-	instanceId_ = instanceId;
-	setParameter("InstanceId", std::to_string(instanceId));
+long DescribeColumnsRequest::getInstanceId() const {
+  return instanceId_;
 }
 
-std::string DescribeColumnsRequest::getInstanceName()const
-{
-	return instanceName_;
+void DescribeColumnsRequest::setInstanceId(long instanceId) {
+  instanceId_ = instanceId;
+  setParameter(std::string("InstanceId"), std::to_string(instanceId));
 }
 
-void DescribeColumnsRequest::setInstanceName(const std::string& instanceName)
-{
-	instanceName_ = instanceName;
-	setParameter("InstanceName", instanceName);
+std::string DescribeColumnsRequest::getInstanceName() const {
+  return instanceName_;
 }
 
-std::string DescribeColumnsRequest::getName()const
-{
-	return name_;
+void DescribeColumnsRequest::setInstanceName(const std::string &instanceName) {
+  instanceName_ = instanceName;
+  setParameter(std::string("InstanceName"), instanceName);
 }
 
-void DescribeColumnsRequest::setName(const std::string& name)
-{
-	name_ = name;
-	setParameter("Name", name);
+std::string DescribeColumnsRequest::getName() const {
+  return name_;
 }
 
-long DescribeColumnsRequest::getRuleId()const
-{
-	return ruleId_;
+void DescribeColumnsRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
 }
 
-void DescribeColumnsRequest::setRuleId(long ruleId)
-{
-	ruleId_ = ruleId;
-	setParameter("RuleId", std::to_string(ruleId));
+long DescribeColumnsRequest::getRuleId() const {
+  return ruleId_;
+}
+
+void DescribeColumnsRequest::setRuleId(long ruleId) {
+  ruleId_ = ruleId;
+  setParameter(std::string("RuleId"), std::to_string(ruleId));
 }
 

sddp/src/model/DescribeConfigsRequest.cc

@@ -1,62 +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.
- */
-
-#include <alibabacloud/sddp/model/DescribeConfigsRequest.h>
-
-using AlibabaCloud::Sddp::Model::DescribeConfigsRequest;
-
-DescribeConfigsRequest::DescribeConfigsRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "DescribeConfigs")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeConfigsRequest::~DescribeConfigsRequest()
-{}
-
-int DescribeConfigsRequest::getFeatureType()const
-{
-	return featureType_;
+ */
+
+#include <alibabacloud/sddp/model/DescribeConfigsRequest.h>
+
+using AlibabaCloud::Sddp::Model::DescribeConfigsRequest;
+
+DescribeConfigsRequest::DescribeConfigsRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "DescribeConfigs") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeConfigsRequest::setFeatureType(int featureType)
-{
-	featureType_ = featureType;
-	setParameter("FeatureType", std::to_string(featureType));
+DescribeConfigsRequest::~DescribeConfigsRequest() {}
+
+int DescribeConfigsRequest::getFeatureType() const {
+  return featureType_;
 }
 
-std::string DescribeConfigsRequest::getSourceIp()const
-{
-	return sourceIp_;
+void DescribeConfigsRequest::setFeatureType(int featureType) {
+  featureType_ = featureType;
+  setParameter(std::string("FeatureType"), std::to_string(featureType));
 }
 
-void DescribeConfigsRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+std::string DescribeConfigsRequest::getSourceIp() const {
+  return sourceIp_;
 }
 
-std::string DescribeConfigsRequest::getLang()const
-{
-	return lang_;
+void DescribeConfigsRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
 }
 
-void DescribeConfigsRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
+std::string DescribeConfigsRequest::getLang() const {
+  return lang_;
+}
+
+void DescribeConfigsRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 

sddp/src/model/DescribeConfigsResult.cc

@@ -43,16 +43,16 @@ void DescribeConfigsResult::parse(const std::string &payload)
 	for (auto valueConfigListConfig : allConfigListNode)
 	{
 		Config configListObject;
-		if(!valueConfigListConfig["Id"].isNull())
-			configListObject.id = std::stol(valueConfigListConfig["Id"].asString());
 		if(!valueConfigListConfig["Code"].isNull())
-			configListObject.code = std::stoi(valueConfigListConfig["Code"].asString());
-		if(!valueConfigListConfig["Description"].isNull())
-			configListObject.description = valueConfigListConfig["Description"].asString();
+			configListObject.code = valueConfigListConfig["Code"].asString();
 		if(!valueConfigListConfig["Value"].isNull())
-			configListObject.value = std::stol(valueConfigListConfig["Value"].asString());
+			configListObject.value = valueConfigListConfig["Value"].asString();
 		if(!valueConfigListConfig["DefaultValue"].isNull())
 			configListObject.defaultValue = valueConfigListConfig["DefaultValue"].asString();
+		if(!valueConfigListConfig["Description"].isNull())
+			configListObject.description = valueConfigListConfig["Description"].asString();
+		if(!valueConfigListConfig["Id"].isNull())
+			configListObject.id = std::stol(valueConfigListConfig["Id"].asString());
 		configList_.push_back(configListObject);
 	}
 

sddp/src/model/DescribeDataAssetsRequest.cc

@@ -1,128 +1,108 @@
 /*
  * 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/sddp/model/DescribeDataAssetsRequest.h>
-
-using AlibabaCloud::Sddp::Model::DescribeDataAssetsRequest;
-
-DescribeDataAssetsRequest::DescribeDataAssetsRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "DescribeDataAssets")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeDataAssetsRequest::~DescribeDataAssetsRequest()
-{}
-
-std::string DescribeDataAssetsRequest::getRiskLevels()const
-{
-	return riskLevels_;
+ */
+
+#include <alibabacloud/sddp/model/DescribeDataAssetsRequest.h>
+
+using AlibabaCloud::Sddp::Model::DescribeDataAssetsRequest;
+
+DescribeDataAssetsRequest::DescribeDataAssetsRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "DescribeDataAssets") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeDataAssetsRequest::setRiskLevels(const std::string& riskLevels)
-{
-	riskLevels_ = riskLevels;
-	setParameter("RiskLevels", riskLevels);
+DescribeDataAssetsRequest::~DescribeDataAssetsRequest() {}
+
+std::string DescribeDataAssetsRequest::getRiskLevels() const {
+  return riskLevels_;
 }
 
-int DescribeDataAssetsRequest::getRangeId()const
-{
-	return rangeId_;
+void DescribeDataAssetsRequest::setRiskLevels(const std::string &riskLevels) {
+  riskLevels_ = riskLevels;
+  setParameter(std::string("RiskLevels"), riskLevels);
 }
 
-void DescribeDataAssetsRequest::setRangeId(int rangeId)
-{
-	rangeId_ = rangeId;
-	setParameter("RangeId", std::to_string(rangeId));
+int DescribeDataAssetsRequest::getRangeId() const {
+  return rangeId_;
 }
 
-std::string DescribeDataAssetsRequest::getSourceIp()const
-{
-	return sourceIp_;
+void DescribeDataAssetsRequest::setRangeId(int rangeId) {
+  rangeId_ = rangeId;
+  setParameter(std::string("RangeId"), std::to_string(rangeId));
 }
 
-void DescribeDataAssetsRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+std::string DescribeDataAssetsRequest::getSourceIp() const {
+  return sourceIp_;
 }
 
-int DescribeDataAssetsRequest::getPageSize()const
-{
-	return pageSize_;
+void DescribeDataAssetsRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
 }
 
-void DescribeDataAssetsRequest::setPageSize(int pageSize)
-{
-	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
+int DescribeDataAssetsRequest::getPageSize() const {
+  return pageSize_;
 }
 
-std::string DescribeDataAssetsRequest::getLang()const
-{
-	return lang_;
+void DescribeDataAssetsRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
 }
 
-void DescribeDataAssetsRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
+std::string DescribeDataAssetsRequest::getLang() const {
+  return lang_;
 }
 
-int DescribeDataAssetsRequest::getFeatureType()const
-{
-	return featureType_;
+void DescribeDataAssetsRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 
-void DescribeDataAssetsRequest::setFeatureType(int featureType)
-{
-	featureType_ = featureType;
-	setParameter("FeatureType", std::to_string(featureType));
+int DescribeDataAssetsRequest::getFeatureType() const {
+  return featureType_;
 }
 
-int DescribeDataAssetsRequest::getCurrentPage()const
-{
-	return currentPage_;
+void DescribeDataAssetsRequest::setFeatureType(int featureType) {
+  featureType_ = featureType;
+  setParameter(std::string("FeatureType"), std::to_string(featureType));
 }
 
-void DescribeDataAssetsRequest::setCurrentPage(int currentPage)
-{
-	currentPage_ = currentPage;
-	setParameter("CurrentPage", std::to_string(currentPage));
+int DescribeDataAssetsRequest::getCurrentPage() const {
+  return currentPage_;
 }
 
-std::string DescribeDataAssetsRequest::getName()const
-{
-	return name_;
+void DescribeDataAssetsRequest::setCurrentPage(int currentPage) {
+  currentPage_ = currentPage;
+  setParameter(std::string("CurrentPage"), std::to_string(currentPage));
 }
 
-void DescribeDataAssetsRequest::setName(const std::string& name)
-{
-	name_ = name;
-	setParameter("Name", name);
+std::string DescribeDataAssetsRequest::getName() const {
+  return name_;
 }
 
-long DescribeDataAssetsRequest::getRuleId()const
-{
-	return ruleId_;
+void DescribeDataAssetsRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
 }
 
-void DescribeDataAssetsRequest::setRuleId(long ruleId)
-{
-	ruleId_ = ruleId;
-	setParameter("RuleId", std::to_string(ruleId));
+long DescribeDataAssetsRequest::getRuleId() const {
+  return ruleId_;
+}
+
+void DescribeDataAssetsRequest::setRuleId(long ruleId) {
+  ruleId_ = ruleId;
+  setParameter(std::string("RuleId"), std::to_string(ruleId));
 }
 

sddp/src/model/DescribeDataAssetsResult.cc

@@ -43,52 +43,52 @@ void DescribeDataAssetsResult::parse(const std::string &payload)
 	for (auto valueItemsAsset : allItemsNode)
 	{
 		Asset itemsObject;
-		if(!valueItemsAsset["Id"].isNull())
-			itemsObject.id = valueItemsAsset["Id"].asString();
-		if(!valueItemsAsset["Name"].isNull())
-			itemsObject.name = valueItemsAsset["Name"].asString();
-		if(!valueItemsAsset["Owner"].isNull())
-			itemsObject.owner = valueItemsAsset["Owner"].asString();
-		if(!valueItemsAsset["CreationTime"].isNull())
-			itemsObject.creationTime = std::stol(valueItemsAsset["CreationTime"].asString());
-		if(!valueItemsAsset["ProductId"].isNull())
-			itemsObject.productId = valueItemsAsset["ProductId"].asString();
-		if(!valueItemsAsset["ProductCode"].isNull())
-			itemsObject.productCode = valueItemsAsset["ProductCode"].asString();
-		if(!valueItemsAsset["Protection"].isNull())
-			itemsObject.protection = valueItemsAsset["Protection"].asString() == "true";
-		if(!valueItemsAsset["Labelsec"].isNull())
-			itemsObject.labelsec = valueItemsAsset["Labelsec"].asString() == "true";
-		if(!valueItemsAsset["OdpsRiskLevelName"].isNull())
-			itemsObject.odpsRiskLevelName = valueItemsAsset["OdpsRiskLevelName"].asString();
-		if(!valueItemsAsset["Sensitive"].isNull())
-			itemsObject.sensitive = valueItemsAsset["Sensitive"].asString() == "true";
-		if(!valueItemsAsset["RiskLevelId"].isNull())
-			itemsObject.riskLevelId = std::stol(valueItemsAsset["RiskLevelId"].asString());
-		if(!valueItemsAsset["RiskLevelName"].isNull())
-			itemsObject.riskLevelName = valueItemsAsset["RiskLevelName"].asString();
-		if(!valueItemsAsset["RuleName"].isNull())
-			itemsObject.ruleName = valueItemsAsset["RuleName"].asString();
-		if(!valueItemsAsset["DepartName"].isNull())
-			itemsObject.departName = valueItemsAsset["DepartName"].asString();
-		if(!valueItemsAsset["TotalCount"].isNull())
-			itemsObject.totalCount = std::stoi(valueItemsAsset["TotalCount"].asString());
-		if(!valueItemsAsset["SensitiveCount"].isNull())
-			itemsObject.sensitiveCount = std::stoi(valueItemsAsset["SensitiveCount"].asString());
 		if(!valueItemsAsset["Acl"].isNull())
 			itemsObject.acl = valueItemsAsset["Acl"].asString();
-		if(!valueItemsAsset["SensitiveRatio"].isNull())
-			itemsObject.sensitiveRatio = valueItemsAsset["SensitiveRatio"].asString();
+		if(!valueItemsAsset["CreationTime"].isNull())
+			itemsObject.creationTime = std::stol(valueItemsAsset["CreationTime"].asString());
 		if(!valueItemsAsset["DataType"].isNull())
 			itemsObject.dataType = valueItemsAsset["DataType"].asString();
+		if(!valueItemsAsset["Owner"].isNull())
+			itemsObject.owner = valueItemsAsset["Owner"].asString();
+		if(!valueItemsAsset["SensitiveRatio"].isNull())
+			itemsObject.sensitiveRatio = valueItemsAsset["SensitiveRatio"].asString();
+		if(!valueItemsAsset["Protection"].isNull())
+			itemsObject.protection = valueItemsAsset["Protection"].asString() == "true";
+		if(!valueItemsAsset["DepartName"].isNull())
+			itemsObject.departName = valueItemsAsset["DepartName"].asString();
+		if(!valueItemsAsset["Labelsec"].isNull())
+			itemsObject.labelsec = valueItemsAsset["Labelsec"].asString() == "true";
+		if(!valueItemsAsset["TotalCount"].isNull())
+			itemsObject.totalCount = std::stoi(valueItemsAsset["TotalCount"].asString());
+		if(!valueItemsAsset["RiskLevelId"].isNull())
+			itemsObject.riskLevelId = std::stol(valueItemsAsset["RiskLevelId"].asString());
+		if(!valueItemsAsset["RuleName"].isNull())
+			itemsObject.ruleName = valueItemsAsset["RuleName"].asString();
+		if(!valueItemsAsset["Sensitive"].isNull())
+			itemsObject.sensitive = valueItemsAsset["Sensitive"].asString() == "true";
 		if(!valueItemsAsset["ObjectKey"].isNull())
 			itemsObject.objectKey = valueItemsAsset["ObjectKey"].asString();
+		if(!valueItemsAsset["RiskLevelName"].isNull())
+			itemsObject.riskLevelName = valueItemsAsset["RiskLevelName"].asString();
+		if(!valueItemsAsset["OdpsRiskLevelName"].isNull())
+			itemsObject.odpsRiskLevelName = valueItemsAsset["OdpsRiskLevelName"].asString();
+		if(!valueItemsAsset["ProductId"].isNull())
+			itemsObject.productId = valueItemsAsset["ProductId"].asString();
+		if(!valueItemsAsset["Name"].isNull())
+			itemsObject.name = valueItemsAsset["Name"].asString();
+		if(!valueItemsAsset["SensitiveCount"].isNull())
+			itemsObject.sensitiveCount = std::stoi(valueItemsAsset["SensitiveCount"].asString());
+		if(!valueItemsAsset["Id"].isNull())
+			itemsObject.id = valueItemsAsset["Id"].asString();
+		if(!valueItemsAsset["ProductCode"].isNull())
+			itemsObject.productCode = valueItemsAsset["ProductCode"].asString();
 		items_.push_back(itemsObject);
 	}
-	if(!value["PageSize"].isNull())
-		pageSize_ = std::stoi(value["PageSize"].asString());
 	if(!value["CurrentPage"].isNull())
 		currentPage_ = std::stoi(value["CurrentPage"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
 	if(!value["TotalCount"].isNull())
 		totalCount_ = std::stoi(value["TotalCount"].asString());
 

sddp/src/model/DescribeDataLimitDetailRequest.cc

@@ -1,73 +1,63 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
-
-#include <alibabacloud/sddp/model/DescribeDataLimitDetailRequest.h>
-
-using AlibabaCloud::Sddp::Model::DescribeDataLimitDetailRequest;
-
-DescribeDataLimitDetailRequest::DescribeDataLimitDetailRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "DescribeDataLimitDetail")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeDataLimitDetailRequest::~DescribeDataLimitDetailRequest()
-{}
-
-int DescribeDataLimitDetailRequest::getNetworkType()const
-{
-	return networkType_;
+ */
+
+#include <alibabacloud/sddp/model/DescribeDataLimitDetailRequest.h>
+
+using AlibabaCloud::Sddp::Model::DescribeDataLimitDetailRequest;
+
+DescribeDataLimitDetailRequest::DescribeDataLimitDetailRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "DescribeDataLimitDetail") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeDataLimitDetailRequest::setNetworkType(int networkType)
-{
-	networkType_ = networkType;
-	setParameter("NetworkType", std::to_string(networkType));
+DescribeDataLimitDetailRequest::~DescribeDataLimitDetailRequest() {}
+
+int DescribeDataLimitDetailRequest::getNetworkType() const {
+  return networkType_;
 }
 
-std::string DescribeDataLimitDetailRequest::getSourceIp()const
-{
-	return sourceIp_;
+void DescribeDataLimitDetailRequest::setNetworkType(int networkType) {
+  networkType_ = networkType;
+  setParameter(std::string("NetworkType"), std::to_string(networkType));
 }
 
-void DescribeDataLimitDetailRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+std::string DescribeDataLimitDetailRequest::getSourceIp() const {
+  return sourceIp_;
 }
 
-long DescribeDataLimitDetailRequest::getId()const
-{
-	return id_;
+void DescribeDataLimitDetailRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
 }
 
-void DescribeDataLimitDetailRequest::setId(long id)
-{
-	id_ = id;
-	setParameter("Id", std::to_string(id));
+long DescribeDataLimitDetailRequest::getId() const {
+  return id_;
 }
 
-std::string DescribeDataLimitDetailRequest::getLang()const
-{
-	return lang_;
+void DescribeDataLimitDetailRequest::setId(long id) {
+  id_ = id;
+  setParameter(std::string("Id"), std::to_string(id));
 }
 
-void DescribeDataLimitDetailRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
+std::string DescribeDataLimitDetailRequest::getLang() const {
+  return lang_;
+}
+
+void DescribeDataLimitDetailRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 

sddp/src/model/DescribeDataLimitDetailResult.cc

@@ -40,34 +40,34 @@ void DescribeDataLimitDetailResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto dataLimitNode = value["DataLimit"];
-	if(!dataLimitNode["RegionId"].isNull())
-		dataLimit_.regionId = dataLimitNode["RegionId"].asString();
 	if(!dataLimitNode["LocalName"].isNull())
 		dataLimit_.localName = dataLimitNode["LocalName"].asString();
-	if(!dataLimitNode["ParentId"].isNull())
-		dataLimit_.parentId = dataLimitNode["ParentId"].asString();
-	if(!dataLimitNode["Id"].isNull())
-		dataLimit_.id = std::stol(dataLimitNode["Id"].asString());
-	if(!dataLimitNode["UserName"].isNull())
-		dataLimit_.userName = dataLimitNode["UserName"].asString();
-	if(!dataLimitNode["GmtCreate"].isNull())
-		dataLimit_.gmtCreate = std::stol(dataLimitNode["GmtCreate"].asString());
-	if(!dataLimitNode["Connector"].isNull())
-		dataLimit_.connector = dataLimitNode["Connector"].asString();
 	if(!dataLimitNode["CheckStatus"].isNull())
 		dataLimit_.checkStatus = std::stoi(dataLimitNode["CheckStatus"].asString());
-	if(!dataLimitNode["CheckStatusName"].isNull())
-		dataLimit_.checkStatusName = dataLimitNode["CheckStatusName"].asString();
-	if(!dataLimitNode["ResourceType"].isNull())
-		dataLimit_.resourceType = std::stol(dataLimitNode["ResourceType"].asString());
-	if(!dataLimitNode["ResourceTypeCode"].isNull())
-		dataLimit_.resourceTypeCode = dataLimitNode["ResourceTypeCode"].asString();
-	if(!dataLimitNode["AuditStatus"].isNull())
-		dataLimit_.auditStatus = std::stoi(dataLimitNode["AuditStatus"].asString());
-	if(!dataLimitNode["LogStoreDay"].isNull())
-		dataLimit_.logStoreDay = std::stoi(dataLimitNode["LogStoreDay"].asString());
+	if(!dataLimitNode["Connector"].isNull())
+		dataLimit_.connector = dataLimitNode["Connector"].asString();
 	if(!dataLimitNode["Port"].isNull())
 		dataLimit_.port = std::stoi(dataLimitNode["Port"].asString());
+	if(!dataLimitNode["CheckStatusName"].isNull())
+		dataLimit_.checkStatusName = dataLimitNode["CheckStatusName"].asString();
+	if(!dataLimitNode["RegionId"].isNull())
+		dataLimit_.regionId = dataLimitNode["RegionId"].asString();
+	if(!dataLimitNode["ParentId"].isNull())
+		dataLimit_.parentId = dataLimitNode["ParentId"].asString();
+	if(!dataLimitNode["ResourceType"].isNull())
+		dataLimit_.resourceType = std::stol(dataLimitNode["ResourceType"].asString());
+	if(!dataLimitNode["LogStoreDay"].isNull())
+		dataLimit_.logStoreDay = std::stoi(dataLimitNode["LogStoreDay"].asString());
+	if(!dataLimitNode["GmtCreate"].isNull())
+		dataLimit_.gmtCreate = std::stol(dataLimitNode["GmtCreate"].asString());
+	if(!dataLimitNode["ResourceTypeCode"].isNull())
+		dataLimit_.resourceTypeCode = dataLimitNode["ResourceTypeCode"].asString();
+	if(!dataLimitNode["UserName"].isNull())
+		dataLimit_.userName = dataLimitNode["UserName"].asString();
+	if(!dataLimitNode["Id"].isNull())
+		dataLimit_.id = std::stol(dataLimitNode["Id"].asString());
+	if(!dataLimitNode["AuditStatus"].isNull())
+		dataLimit_.auditStatus = std::stoi(dataLimitNode["AuditStatus"].asString());
 
 }
 

sddp/src/model/DescribeDataLimitSetRequest.cc

@@ -1,73 +1,63 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
-
-#include <alibabacloud/sddp/model/DescribeDataLimitSetRequest.h>
-
-using AlibabaCloud::Sddp::Model::DescribeDataLimitSetRequest;
-
-DescribeDataLimitSetRequest::DescribeDataLimitSetRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "DescribeDataLimitSet")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeDataLimitSetRequest::~DescribeDataLimitSetRequest()
-{}
-
-std::string DescribeDataLimitSetRequest::getParentId()const
-{
-	return parentId_;
+ */
+
+#include <alibabacloud/sddp/model/DescribeDataLimitSetRequest.h>
+
+using AlibabaCloud::Sddp::Model::DescribeDataLimitSetRequest;
+
+DescribeDataLimitSetRequest::DescribeDataLimitSetRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "DescribeDataLimitSet") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeDataLimitSetRequest::setParentId(const std::string& parentId)
-{
-	parentId_ = parentId;
-	setParameter("ParentId", parentId);
+DescribeDataLimitSetRequest::~DescribeDataLimitSetRequest() {}
+
+std::string DescribeDataLimitSetRequest::getParentId() const {
+  return parentId_;
 }
 
-std::string DescribeDataLimitSetRequest::getSourceIp()const
-{
-	return sourceIp_;
+void DescribeDataLimitSetRequest::setParentId(const std::string &parentId) {
+  parentId_ = parentId;
+  setParameter(std::string("ParentId"), parentId);
 }
 
-void DescribeDataLimitSetRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+std::string DescribeDataLimitSetRequest::getSourceIp() const {
+  return sourceIp_;
 }
 
-std::string DescribeDataLimitSetRequest::getLang()const
-{
-	return lang_;
+void DescribeDataLimitSetRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
 }
 
-void DescribeDataLimitSetRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
+std::string DescribeDataLimitSetRequest::getLang() const {
+  return lang_;
 }
 
-int DescribeDataLimitSetRequest::getResourceType()const
-{
-	return resourceType_;
+void DescribeDataLimitSetRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 
-void DescribeDataLimitSetRequest::setResourceType(int resourceType)
-{
-	resourceType_ = resourceType;
-	setParameter("ResourceType", std::to_string(resourceType));
+int DescribeDataLimitSetRequest::getResourceType() const {
+  return resourceType_;
+}
+
+void DescribeDataLimitSetRequest::setResourceType(int resourceType) {
+  resourceType_ = resourceType;
+  setParameter(std::string("ResourceType"), std::to_string(resourceType));
 }
 

sddp/src/model/DescribeDataLimitSetResult.cc

@@ -40,68 +40,68 @@ void DescribeDataLimitSetResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto dataLimitSetNode = value["DataLimitSet"];
-	if(!dataLimitSetNode["ResourceType"].isNull())
-		dataLimitSet_.resourceType = std::stol(dataLimitSetNode["ResourceType"].asString());
 	if(!dataLimitSetNode["ResourceTypeCode"].isNull())
 		dataLimitSet_.resourceTypeCode = dataLimitSetNode["ResourceTypeCode"].asString();
+	if(!dataLimitSetNode["ResourceType"].isNull())
+		dataLimitSet_.resourceType = std::stol(dataLimitSetNode["ResourceType"].asString());
 	if(!dataLimitSetNode["TotalCount"].isNull())
 		dataLimitSet_.totalCount = std::stoi(dataLimitSetNode["TotalCount"].asString());
 	auto allDataLimitListNode = dataLimitSetNode["DataLimitList"]["DataLimit"];
 	for (auto dataLimitSetNodeDataLimitListDataLimit : allDataLimitListNode)
 	{
 		DataLimitSet::DataLimit dataLimitObject;
-		if(!dataLimitSetNodeDataLimitListDataLimit["RegionId"].isNull())
-			dataLimitObject.regionId = dataLimitSetNodeDataLimitListDataLimit["RegionId"].asString();
-		if(!dataLimitSetNodeDataLimitListDataLimit["LocalName"].isNull())
-			dataLimitObject.localName = dataLimitSetNodeDataLimitListDataLimit["LocalName"].asString();
-		if(!dataLimitSetNodeDataLimitListDataLimit["ParentId"].isNull())
-			dataLimitObject.parentId = dataLimitSetNodeDataLimitListDataLimit["ParentId"].asString();
-		if(!dataLimitSetNodeDataLimitListDataLimit["Id"].isNull())
-			dataLimitObject.id = std::stol(dataLimitSetNodeDataLimitListDataLimit["Id"].asString());
-		if(!dataLimitSetNodeDataLimitListDataLimit["UserName"].isNull())
-			dataLimitObject.userName = dataLimitSetNodeDataLimitListDataLimit["UserName"].asString();
-		if(!dataLimitSetNodeDataLimitListDataLimit["GmtCreate"].isNull())
-			dataLimitObject.gmtCreate = std::stol(dataLimitSetNodeDataLimitListDataLimit["GmtCreate"].asString());
-		if(!dataLimitSetNodeDataLimitListDataLimit["Connector"].isNull())
-			dataLimitObject.connector = dataLimitSetNodeDataLimitListDataLimit["Connector"].asString();
-		if(!dataLimitSetNodeDataLimitListDataLimit["CheckStatus"].isNull())
-			dataLimitObject.checkStatus = std::stoi(dataLimitSetNodeDataLimitListDataLimit["CheckStatus"].asString());
-		if(!dataLimitSetNodeDataLimitListDataLimit["CheckStatusName"].isNull())
-			dataLimitObject.checkStatusName = dataLimitSetNodeDataLimitListDataLimit["CheckStatusName"].asString();
-		if(!dataLimitSetNodeDataLimitListDataLimit["ResourceType"].isNull())
-			dataLimitObject.resourceType = std::stol(dataLimitSetNodeDataLimitListDataLimit["ResourceType"].asString());
-		if(!dataLimitSetNodeDataLimitListDataLimit["ResourceTypeCode"].isNull())
-			dataLimitObject.resourceTypeCode = dataLimitSetNodeDataLimitListDataLimit["ResourceTypeCode"].asString();
-		if(!dataLimitSetNodeDataLimitListDataLimit["AuditStatus"].isNull())
-			dataLimitObject.auditStatus = std::stoi(dataLimitSetNodeDataLimitListDataLimit["AuditStatus"].asString());
-		if(!dataLimitSetNodeDataLimitListDataLimit["LogStoreDay"].isNull())
-			dataLimitObject.logStoreDay = std::stoi(dataLimitSetNodeDataLimitListDataLimit["LogStoreDay"].asString());
-		if(!dataLimitSetNodeDataLimitListDataLimit["Port"].isNull())
-			dataLimitObject.port = std::stoi(dataLimitSetNodeDataLimitListDataLimit["Port"].asString());
-		if(!dataLimitSetNodeDataLimitListDataLimit["EventStatus"].isNull())
-			dataLimitObject.eventStatus = std::stoi(dataLimitSetNodeDataLimitListDataLimit["EventStatus"].asString());
 		if(!dataLimitSetNodeDataLimitListDataLimit["SupportEvent"].isNull())
 			dataLimitObject.supportEvent = dataLimitSetNodeDataLimitListDataLimit["SupportEvent"].asString() == "true";
+		if(!dataLimitSetNodeDataLimitListDataLimit["LocalName"].isNull())
+			dataLimitObject.localName = dataLimitSetNodeDataLimitListDataLimit["LocalName"].asString();
+		if(!dataLimitSetNodeDataLimitListDataLimit["CheckStatus"].isNull())
+			dataLimitObject.checkStatus = std::stoi(dataLimitSetNodeDataLimitListDataLimit["CheckStatus"].asString());
+		if(!dataLimitSetNodeDataLimitListDataLimit["Connector"].isNull())
+			dataLimitObject.connector = dataLimitSetNodeDataLimitListDataLimit["Connector"].asString();
+		if(!dataLimitSetNodeDataLimitListDataLimit["Port"].isNull())
+			dataLimitObject.port = std::stoi(dataLimitSetNodeDataLimitListDataLimit["Port"].asString());
+		if(!dataLimitSetNodeDataLimitListDataLimit["CheckStatusName"].isNull())
+			dataLimitObject.checkStatusName = dataLimitSetNodeDataLimitListDataLimit["CheckStatusName"].asString();
+		if(!dataLimitSetNodeDataLimitListDataLimit["RegionId"].isNull())
+			dataLimitObject.regionId = dataLimitSetNodeDataLimitListDataLimit["RegionId"].asString();
+		if(!dataLimitSetNodeDataLimitListDataLimit["ParentId"].isNull())
+			dataLimitObject.parentId = dataLimitSetNodeDataLimitListDataLimit["ParentId"].asString();
+		if(!dataLimitSetNodeDataLimitListDataLimit["ResourceType"].isNull())
+			dataLimitObject.resourceType = std::stol(dataLimitSetNodeDataLimitListDataLimit["ResourceType"].asString());
+		if(!dataLimitSetNodeDataLimitListDataLimit["LogStoreDay"].isNull())
+			dataLimitObject.logStoreDay = std::stoi(dataLimitSetNodeDataLimitListDataLimit["LogStoreDay"].asString());
+		if(!dataLimitSetNodeDataLimitListDataLimit["EventStatus"].isNull())
+			dataLimitObject.eventStatus = std::stoi(dataLimitSetNodeDataLimitListDataLimit["EventStatus"].asString());
+		if(!dataLimitSetNodeDataLimitListDataLimit["GmtCreate"].isNull())
+			dataLimitObject.gmtCreate = std::stol(dataLimitSetNodeDataLimitListDataLimit["GmtCreate"].asString());
+		if(!dataLimitSetNodeDataLimitListDataLimit["ResourceTypeCode"].isNull())
+			dataLimitObject.resourceTypeCode = dataLimitSetNodeDataLimitListDataLimit["ResourceTypeCode"].asString();
+		if(!dataLimitSetNodeDataLimitListDataLimit["UserName"].isNull())
+			dataLimitObject.userName = dataLimitSetNodeDataLimitListDataLimit["UserName"].asString();
+		if(!dataLimitSetNodeDataLimitListDataLimit["Id"].isNull())
+			dataLimitObject.id = std::stol(dataLimitSetNodeDataLimitListDataLimit["Id"].asString());
+		if(!dataLimitSetNodeDataLimitListDataLimit["AuditStatus"].isNull())
+			dataLimitObject.auditStatus = std::stoi(dataLimitSetNodeDataLimitListDataLimit["AuditStatus"].asString());
 		dataLimitSet_.dataLimitList.push_back(dataLimitObject);
 	}
 	auto allOssBucketListNode = dataLimitSetNode["OssBucketList"]["OssBucket"];
 	for (auto dataLimitSetNodeOssBucketListOssBucket : allOssBucketListNode)
 	{
 		DataLimitSet::OssBucket ossBucketObject;
-		if(!dataLimitSetNodeOssBucketListOssBucket["BucketName"].isNull())
-			ossBucketObject.bucketName = dataLimitSetNodeOssBucketListOssBucket["BucketName"].asString();
 		if(!dataLimitSetNodeOssBucketListOssBucket["RegionId"].isNull())
 			ossBucketObject.regionId = dataLimitSetNodeOssBucketListOssBucket["RegionId"].asString();
+		if(!dataLimitSetNodeOssBucketListOssBucket["BucketName"].isNull())
+			ossBucketObject.bucketName = dataLimitSetNodeOssBucketListOssBucket["BucketName"].asString();
 		dataLimitSet_.ossBucketList.push_back(ossBucketObject);
 	}
 	auto allRegionListNode = dataLimitSetNode["RegionList"]["Region"];
 	for (auto dataLimitSetNodeRegionListRegion : allRegionListNode)
 	{
 		DataLimitSet::Region regionObject;
-		if(!dataLimitSetNodeRegionListRegion["LocalName"].isNull())
-			regionObject.localName = dataLimitSetNodeRegionListRegion["LocalName"].asString();
 		if(!dataLimitSetNodeRegionListRegion["RegionId"].isNull())
 			regionObject.regionId = dataLimitSetNodeRegionListRegion["RegionId"].asString();
+		if(!dataLimitSetNodeRegionListRegion["LocalName"].isNull())
+			regionObject.localName = dataLimitSetNodeRegionListRegion["LocalName"].asString();
 		dataLimitSet_.regionList.push_back(regionObject);
 	}
 

sddp/src/model/DescribeDataLimitsInstanceDimRequest.cc

@@ -1,183 +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/sddp/model/DescribeDataLimitsInstanceDimRequest.h>
-
-using AlibabaCloud::Sddp::Model::DescribeDataLimitsInstanceDimRequest;
-
-DescribeDataLimitsInstanceDimRequest::DescribeDataLimitsInstanceDimRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "DescribeDataLimitsInstanceDim")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeDataLimitsInstanceDimRequest::~DescribeDataLimitsInstanceDimRequest()
-{}
-
-long DescribeDataLimitsInstanceDimRequest::getStartTime()const
-{
-	return startTime_;
-}
-
-void DescribeDataLimitsInstanceDimRequest::setStartTime(long startTime)
-{
-	startTime_ = startTime;
-	setParameter("StartTime", std::to_string(startTime));
-}
-
-std::string DescribeDataLimitsInstanceDimRequest::getParentId()const
-{
-	return parentId_;
-}
-
-void DescribeDataLimitsInstanceDimRequest::setParentId(const std::string& parentId)
-{
-	parentId_ = parentId;
-	setParameter("ParentId", parentId);
-}
-
-std::string DescribeDataLimitsInstanceDimRequest::getSourceIp()const
-{
-	return sourceIp_;
-}
-
-void DescribeDataLimitsInstanceDimRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
-}
-
-int DescribeDataLimitsInstanceDimRequest::getEnable()const
-{
-	return enable_;
-}
-
-void DescribeDataLimitsInstanceDimRequest::setEnable(int enable)
-{
-	enable_ = enable;
-	setParameter("Enable", std::to_string(enable));
-}
-
-int DescribeDataLimitsInstanceDimRequest::getPageSize()const
-{
-	return pageSize_;
-}
-
-void DescribeDataLimitsInstanceDimRequest::setPageSize(int pageSize)
-{
-	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
-}
-
-int DescribeDataLimitsInstanceDimRequest::getCheckStatus()const
-{
-	return checkStatus_;
-}
-
-void DescribeDataLimitsInstanceDimRequest::setCheckStatus(int checkStatus)
-{
-	checkStatus_ = checkStatus;
-	setParameter("CheckStatus", std::to_string(checkStatus));
-}
-
-int DescribeDataLimitsInstanceDimRequest::getDatamaskStatus()const
-{
-	return datamaskStatus_;
-}
-
-void DescribeDataLimitsInstanceDimRequest::setDatamaskStatus(int datamaskStatus)
-{
-	datamaskStatus_ = datamaskStatus;
-	setParameter("DatamaskStatus", std::to_string(datamaskStatus));
-}
-
-std::string DescribeDataLimitsInstanceDimRequest::getLang()const
-{
-	return lang_;
-}
-
-void DescribeDataLimitsInstanceDimRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
-}
-
-std::string DescribeDataLimitsInstanceDimRequest::getServiceRegionId()const
-{
-	return serviceRegionId_;
-}
-
-void DescribeDataLimitsInstanceDimRequest::setServiceRegionId(const std::string& serviceRegionId)
-{
-	serviceRegionId_ = serviceRegionId;
-	setParameter("ServiceRegionId", serviceRegionId);
-}
-
-std::string DescribeDataLimitsInstanceDimRequest::getEngineType()const
-{
-	return engineType_;
-}
-
-void DescribeDataLimitsInstanceDimRequest::setEngineType(const std::string& engineType)
-{
-	engineType_ = engineType;
-	setParameter("EngineType", engineType);
-}
-
-int DescribeDataLimitsInstanceDimRequest::getAuditStatus()const
-{
-	return auditStatus_;
-}
-
-void DescribeDataLimitsInstanceDimRequest::setAuditStatus(int auditStatus)
-{
-	auditStatus_ = auditStatus;
-	setParameter("AuditStatus", std::to_string(auditStatus));
-}
-
-long DescribeDataLimitsInstanceDimRequest::getEndTime()const
-{
-	return endTime_;
-}
-
-void DescribeDataLimitsInstanceDimRequest::setEndTime(long endTime)
-{
-	endTime_ = endTime;
-	setParameter("EndTime", std::to_string(endTime));
-}
-
-int DescribeDataLimitsInstanceDimRequest::getCurrentPage()const
-{
-	return currentPage_;
-}
-
-void DescribeDataLimitsInstanceDimRequest::setCurrentPage(int currentPage)
-{
-	currentPage_ = currentPage;
-	setParameter("CurrentPage", std::to_string(currentPage));
-}
-
-int DescribeDataLimitsInstanceDimRequest::getResourceType()const
-{
-	return resourceType_;
-}
-
-void DescribeDataLimitsInstanceDimRequest::setResourceType(int resourceType)
-{
-	resourceType_ = resourceType;
-	setParameter("ResourceType", std::to_string(resourceType));
-}
-

sddp/src/model/DescribeDataLimitsInstanceDimResult.cc

@@ -1,230 +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/sddp/model/DescribeDataLimitsInstanceDimResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Sddp;
-using namespace AlibabaCloud::Sddp::Model;
-
-DescribeDataLimitsInstanceDimResult::DescribeDataLimitsInstanceDimResult() :
-	ServiceResult()
-{}
-
-DescribeDataLimitsInstanceDimResult::DescribeDataLimitsInstanceDimResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-DescribeDataLimitsInstanceDimResult::~DescribeDataLimitsInstanceDimResult()
-{}
-
-void DescribeDataLimitsInstanceDimResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto allItemsNode = value["Items"]["DataLimit"];
-	for (auto valueItemsDataLimit : allItemsNode)
-	{
-		DataLimit itemsObject;
-		if(!valueItemsDataLimit["RegionId"].isNull())
-			itemsObject.regionId = valueItemsDataLimit["RegionId"].asString();
-		if(!valueItemsDataLimit["LocalName"].isNull())
-			itemsObject.localName = valueItemsDataLimit["LocalName"].asString();
-		if(!valueItemsDataLimit["ParentId"].isNull())
-			itemsObject.parentId = valueItemsDataLimit["ParentId"].asString();
-		if(!valueItemsDataLimit["Id"].isNull())
-			itemsObject.id = std::stol(valueItemsDataLimit["Id"].asString());
-		if(!valueItemsDataLimit["UserName"].isNull())
-			itemsObject.userName = valueItemsDataLimit["UserName"].asString();
-		if(!valueItemsDataLimit["GmtCreate"].isNull())
-			itemsObject.gmtCreate = std::stol(valueItemsDataLimit["GmtCreate"].asString());
-		if(!valueItemsDataLimit["Connector"].isNull())
-			itemsObject.connector = valueItemsDataLimit["Connector"].asString();
-		if(!valueItemsDataLimit["CheckStatus"].isNull())
-			itemsObject.checkStatus = std::stoi(valueItemsDataLimit["CheckStatus"].asString());
-		if(!valueItemsDataLimit["CheckStatusName"].isNull())
-			itemsObject.checkStatusName = valueItemsDataLimit["CheckStatusName"].asString();
-		if(!valueItemsDataLimit["ResourceType"].isNull())
-			itemsObject.resourceType = std::stol(valueItemsDataLimit["ResourceType"].asString());
-		if(!valueItemsDataLimit["ResourceTypeCode"].isNull())
-			itemsObject.resourceTypeCode = valueItemsDataLimit["ResourceTypeCode"].asString();
-		if(!valueItemsDataLimit["AuditStatus"].isNull())
-			itemsObject.auditStatus = std::stoi(valueItemsDataLimit["AuditStatus"].asString());
-		if(!valueItemsDataLimit["LogStoreDay"].isNull())
-			itemsObject.logStoreDay = std::stoi(valueItemsDataLimit["LogStoreDay"].asString());
-		if(!valueItemsDataLimit["Enable"].isNull())
-			itemsObject.enable = std::stoi(valueItemsDataLimit["Enable"].asString());
-		if(!valueItemsDataLimit["AutoScan"].isNull())
-			itemsObject.autoScan = std::stoi(valueItemsDataLimit["AutoScan"].asString());
-		if(!valueItemsDataLimit["EngineType"].isNull())
-			itemsObject.engineType = valueItemsDataLimit["EngineType"].asString();
-		if(!valueItemsDataLimit["ProcessStatus"].isNull())
-			itemsObject.processStatus = std::stoi(valueItemsDataLimit["ProcessStatus"].asString());
-		if(!valueItemsDataLimit["ProcessTotalCount"].isNull())
-			itemsObject.processTotalCount = std::stoi(valueItemsDataLimit["ProcessTotalCount"].asString());
-		if(!valueItemsDataLimit["TotalCount"].isNull())
-			itemsObject.totalCount = std::stoi(valueItemsDataLimit["TotalCount"].asString());
-		if(!valueItemsDataLimit["LastFinishedTime"].isNull())
-			itemsObject.lastFinishedTime = std::stol(valueItemsDataLimit["LastFinishedTime"].asString());
-		if(!valueItemsDataLimit["ErrorCode"].isNull())
-			itemsObject.errorCode = valueItemsDataLimit["ErrorCode"].asString();
-		if(!valueItemsDataLimit["ErrorMessage"].isNull())
-			itemsObject.errorMessage = valueItemsDataLimit["ErrorMessage"].asString();
-		if(!valueItemsDataLimit["Port"].isNull())
-			itemsObject.port = std::stoi(valueItemsDataLimit["Port"].asString());
-		if(!valueItemsDataLimit["DbVersion"].isNull())
-			itemsObject.dbVersion = valueItemsDataLimit["DbVersion"].asString();
-		if(!valueItemsDataLimit["SupportDatamask"].isNull())
-			itemsObject.supportDatamask = valueItemsDataLimit["SupportDatamask"].asString() == "true";
-		if(!valueItemsDataLimit["SupportScan"].isNull())
-			itemsObject.supportScan = valueItemsDataLimit["SupportScan"].asString() == "true";
-		if(!valueItemsDataLimit["SupportAudit"].isNull())
-			itemsObject.supportAudit = valueItemsDataLimit["SupportAudit"].asString() == "true";
-		if(!valueItemsDataLimit["DatamaskStatus"].isNull())
-			itemsObject.datamaskStatus = std::stoi(valueItemsDataLimit["DatamaskStatus"].asString());
-		if(!valueItemsDataLimit["SamplingSize"].isNull())
-			itemsObject.samplingSize = std::stoi(valueItemsDataLimit["SamplingSize"].asString());
-		if(!valueItemsDataLimit["NextStartTime"].isNull())
-			itemsObject.nextStartTime = std::stol(valueItemsDataLimit["NextStartTime"].asString());
-		if(!valueItemsDataLimit["SupportOcr"].isNull())
-			itemsObject.supportOcr = valueItemsDataLimit["SupportOcr"].asString() == "true";
-		if(!valueItemsDataLimit["OcrStatus"].isNull())
-			itemsObject.ocrStatus = std::stoi(valueItemsDataLimit["OcrStatus"].asString());
-		if(!valueItemsDataLimit["AgentId"].isNull())
-			itemsObject.agentId = valueItemsDataLimit["AgentId"].asString();
-		if(!valueItemsDataLimit["AgentState"].isNull())
-			itemsObject.agentState = std::stoi(valueItemsDataLimit["AgentState"].asString());
-		if(!valueItemsDataLimit["SupportAgentInstall"].isNull())
-			itemsObject.supportAgentInstall = valueItemsDataLimit["SupportAgentInstall"].asString() == "true";
-		if(!valueItemsDataLimit["InstanceDescription"].isNull())
-			itemsObject.instanceDescription = valueItemsDataLimit["InstanceDescription"].asString();
-		auto allDataLimitListNode = valueItemsDataLimit["DataLimitList"]["DataLimitListInner"];
-		for (auto valueItemsDataLimitDataLimitListDataLimitListInner : allDataLimitListNode)
-		{
-			DataLimit::DataLimitListInner dataLimitListObject;
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["RegionId"].isNull())
-				dataLimitListObject.regionId = valueItemsDataLimitDataLimitListDataLimitListInner["RegionId"].asString();
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["LocalName"].isNull())
-				dataLimitListObject.localName = valueItemsDataLimitDataLimitListDataLimitListInner["LocalName"].asString();
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["ParentId"].isNull())
-				dataLimitListObject.parentId = valueItemsDataLimitDataLimitListDataLimitListInner["ParentId"].asString();
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["Id"].isNull())
-				dataLimitListObject.id = std::stol(valueItemsDataLimitDataLimitListDataLimitListInner["Id"].asString());
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["UserName"].isNull())
-				dataLimitListObject.userName = valueItemsDataLimitDataLimitListDataLimitListInner["UserName"].asString();
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["GmtCreate"].isNull())
-				dataLimitListObject.gmtCreate = std::stol(valueItemsDataLimitDataLimitListDataLimitListInner["GmtCreate"].asString());
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["Connector"].isNull())
-				dataLimitListObject.connector = valueItemsDataLimitDataLimitListDataLimitListInner["Connector"].asString();
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["CheckStatus"].isNull())
-				dataLimitListObject.checkStatus = std::stoi(valueItemsDataLimitDataLimitListDataLimitListInner["CheckStatus"].asString());
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["CheckStatusName"].isNull())
-				dataLimitListObject.checkStatusName = valueItemsDataLimitDataLimitListDataLimitListInner["CheckStatusName"].asString();
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["ResourceType"].isNull())
-				dataLimitListObject.resourceType = std::stol(valueItemsDataLimitDataLimitListDataLimitListInner["ResourceType"].asString());
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["ResourceTypeCode"].isNull())
-				dataLimitListObject.resourceTypeCode = valueItemsDataLimitDataLimitListDataLimitListInner["ResourceTypeCode"].asString();
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["AuditStatus"].isNull())
-				dataLimitListObject.auditStatus = std::stoi(valueItemsDataLimitDataLimitListDataLimitListInner["AuditStatus"].asString());
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["LogStoreDay"].isNull())
-				dataLimitListObject.logStoreDay = std::stoi(valueItemsDataLimitDataLimitListDataLimitListInner["LogStoreDay"].asString());
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["Enable"].isNull())
-				dataLimitListObject.enable = std::stoi(valueItemsDataLimitDataLimitListDataLimitListInner["Enable"].asString());
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["AutoScan"].isNull())
-				dataLimitListObject.autoScan = std::stoi(valueItemsDataLimitDataLimitListDataLimitListInner["AutoScan"].asString());
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["EngineType"].isNull())
-				dataLimitListObject.engineType = valueItemsDataLimitDataLimitListDataLimitListInner["EngineType"].asString();
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["ProcessStatus"].isNull())
-				dataLimitListObject.processStatus = std::stoi(valueItemsDataLimitDataLimitListDataLimitListInner["ProcessStatus"].asString());
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["ProcessTotalCount"].isNull())
-				dataLimitListObject.processTotalCount = std::stoi(valueItemsDataLimitDataLimitListDataLimitListInner["ProcessTotalCount"].asString());
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["TotalCount"].isNull())
-				dataLimitListObject.totalCount = std::stoi(valueItemsDataLimitDataLimitListDataLimitListInner["TotalCount"].asString());
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["LastFinishedTime"].isNull())
-				dataLimitListObject.lastFinishedTime = std::stol(valueItemsDataLimitDataLimitListDataLimitListInner["LastFinishedTime"].asString());
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["ErrorCode"].isNull())
-				dataLimitListObject.errorCode = valueItemsDataLimitDataLimitListDataLimitListInner["ErrorCode"].asString();
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["ErrorMessage"].isNull())
-				dataLimitListObject.errorMessage = valueItemsDataLimitDataLimitListDataLimitListInner["ErrorMessage"].asString();
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["Port"].isNull())
-				dataLimitListObject.port = std::stoi(valueItemsDataLimitDataLimitListDataLimitListInner["Port"].asString());
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["DbVersion"].isNull())
-				dataLimitListObject.dbVersion = valueItemsDataLimitDataLimitListDataLimitListInner["DbVersion"].asString();
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["SupportDatamask"].isNull())
-				dataLimitListObject.supportDatamask = valueItemsDataLimitDataLimitListDataLimitListInner["SupportDatamask"].asString() == "true";
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["SupportScan"].isNull())
-				dataLimitListObject.supportScan = valueItemsDataLimitDataLimitListDataLimitListInner["SupportScan"].asString() == "true";
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["SupportAudit"].isNull())
-				dataLimitListObject.supportAudit = valueItemsDataLimitDataLimitListDataLimitListInner["SupportAudit"].asString() == "true";
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["DatamaskStatus"].isNull())
-				dataLimitListObject.datamaskStatus = std::stoi(valueItemsDataLimitDataLimitListDataLimitListInner["DatamaskStatus"].asString());
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["SamplingSize"].isNull())
-				dataLimitListObject.samplingSize = std::stoi(valueItemsDataLimitDataLimitListDataLimitListInner["SamplingSize"].asString());
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["NextStartTime"].isNull())
-				dataLimitListObject.nextStartTime = std::stol(valueItemsDataLimitDataLimitListDataLimitListInner["NextStartTime"].asString());
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["SupportOcr"].isNull())
-				dataLimitListObject.supportOcr = valueItemsDataLimitDataLimitListDataLimitListInner["SupportOcr"].asString() == "true";
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["OcrStatus"].isNull())
-				dataLimitListObject.ocrStatus = std::stoi(valueItemsDataLimitDataLimitListDataLimitListInner["OcrStatus"].asString());
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["AgentId"].isNull())
-				dataLimitListObject.agentId = valueItemsDataLimitDataLimitListDataLimitListInner["AgentId"].asString();
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["AgentState"].isNull())
-				dataLimitListObject.agentState = std::stoi(valueItemsDataLimitDataLimitListDataLimitListInner["AgentState"].asString());
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["SupportAgentInstall"].isNull())
-				dataLimitListObject.supportAgentInstall = valueItemsDataLimitDataLimitListDataLimitListInner["SupportAgentInstall"].asString() == "true";
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["AutoCreateAccount"].isNull())
-				dataLimitListObject.autoCreateAccount = valueItemsDataLimitDataLimitListDataLimitListInner["AutoCreateAccount"].asString() == "true";
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["EventStatus"].isNull())
-				dataLimitListObject.eventStatus = std::stoi(valueItemsDataLimitDataLimitListDataLimitListInner["EventStatus"].asString());
-			if(!valueItemsDataLimitDataLimitListDataLimitListInner["SupportEvent"].isNull())
-				dataLimitListObject.supportEvent = valueItemsDataLimitDataLimitListDataLimitListInner["SupportEvent"].asString() == "true";
-			itemsObject.dataLimitList.push_back(dataLimitListObject);
-		}
-		items_.push_back(itemsObject);
-	}
-	if(!value["PageSize"].isNull())
-		pageSize_ = std::stoi(value["PageSize"].asString());
-	if(!value["CurrentPage"].isNull())
-		currentPage_ = std::stoi(value["CurrentPage"].asString());
-	if(!value["TotalCount"].isNull())
-		totalCount_ = std::stoi(value["TotalCount"].asString());
-
-}
-
-int DescribeDataLimitsInstanceDimResult::getTotalCount()const
-{
-	return totalCount_;
-}
-
-int DescribeDataLimitsInstanceDimResult::getPageSize()const
-{
-	return pageSize_;
-}
-
-int DescribeDataLimitsInstanceDimResult::getCurrentPage()const
-{
-	return currentPage_;
-}
-
-std::vector<DescribeDataLimitsInstanceDimResult::DataLimit> DescribeDataLimitsInstanceDimResult::getItems()const
-{
-	return items_;
-}
-

sddp/src/model/DescribeDataLimitsRequest.cc

@@ -1,183 +1,153 @@
 /*
  * 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/sddp/model/DescribeDataLimitsRequest.h>
-
-using AlibabaCloud::Sddp::Model::DescribeDataLimitsRequest;
-
-DescribeDataLimitsRequest::DescribeDataLimitsRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "DescribeDataLimits")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeDataLimitsRequest::~DescribeDataLimitsRequest()
-{}
-
-long DescribeDataLimitsRequest::getStartTime()const
-{
-	return startTime_;
+ */
+
+#include <alibabacloud/sddp/model/DescribeDataLimitsRequest.h>
+
+using AlibabaCloud::Sddp::Model::DescribeDataLimitsRequest;
+
+DescribeDataLimitsRequest::DescribeDataLimitsRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "DescribeDataLimits") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeDataLimitsRequest::setStartTime(long startTime)
-{
-	startTime_ = startTime;
-	setParameter("StartTime", std::to_string(startTime));
+DescribeDataLimitsRequest::~DescribeDataLimitsRequest() {}
+
+long DescribeDataLimitsRequest::getStartTime() const {
+  return startTime_;
 }
 
-std::string DescribeDataLimitsRequest::getParentId()const
-{
-	return parentId_;
+void DescribeDataLimitsRequest::setStartTime(long startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), std::to_string(startTime));
 }
 
-void DescribeDataLimitsRequest::setParentId(const std::string& parentId)
-{
-	parentId_ = parentId;
-	setParameter("ParentId", parentId);
+std::string DescribeDataLimitsRequest::getParentId() const {
+  return parentId_;
 }
 
-std::string DescribeDataLimitsRequest::getSourceIp()const
-{
-	return sourceIp_;
+void DescribeDataLimitsRequest::setParentId(const std::string &parentId) {
+  parentId_ = parentId;
+  setParameter(std::string("ParentId"), parentId);
 }
 
-void DescribeDataLimitsRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+std::string DescribeDataLimitsRequest::getSourceIp() const {
+  return sourceIp_;
 }
 
-int DescribeDataLimitsRequest::getEnable()const
-{
-	return enable_;
+void DescribeDataLimitsRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
 }
 
-void DescribeDataLimitsRequest::setEnable(int enable)
-{
-	enable_ = enable;
-	setParameter("Enable", std::to_string(enable));
+int DescribeDataLimitsRequest::getEnable() const {
+  return enable_;
 }
 
-int DescribeDataLimitsRequest::getPageSize()const
-{
-	return pageSize_;
+void DescribeDataLimitsRequest::setEnable(int enable) {
+  enable_ = enable;
+  setParameter(std::string("Enable"), std::to_string(enable));
 }
 
-void DescribeDataLimitsRequest::setPageSize(int pageSize)
-{
-	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
+int DescribeDataLimitsRequest::getPageSize() const {
+  return pageSize_;
 }
 
-int DescribeDataLimitsRequest::getCheckStatus()const
-{
-	return checkStatus_;
+void DescribeDataLimitsRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
 }
 
-void DescribeDataLimitsRequest::setCheckStatus(int checkStatus)
-{
-	checkStatus_ = checkStatus;
-	setParameter("CheckStatus", std::to_string(checkStatus));
+int DescribeDataLimitsRequest::getCheckStatus() const {
+  return checkStatus_;
 }
 
-int DescribeDataLimitsRequest::getDatamaskStatus()const
-{
-	return datamaskStatus_;
+void DescribeDataLimitsRequest::setCheckStatus(int checkStatus) {
+  checkStatus_ = checkStatus;
+  setParameter(std::string("CheckStatus"), std::to_string(checkStatus));
 }
 
-void DescribeDataLimitsRequest::setDatamaskStatus(int datamaskStatus)
-{
-	datamaskStatus_ = datamaskStatus;
-	setParameter("DatamaskStatus", std::to_string(datamaskStatus));
+int DescribeDataLimitsRequest::getDatamaskStatus() const {
+  return datamaskStatus_;
 }
 
-std::string DescribeDataLimitsRequest::getLang()const
-{
-	return lang_;
+void DescribeDataLimitsRequest::setDatamaskStatus(int datamaskStatus) {
+  datamaskStatus_ = datamaskStatus;
+  setParameter(std::string("DatamaskStatus"), std::to_string(datamaskStatus));
 }
 
-void DescribeDataLimitsRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
+std::string DescribeDataLimitsRequest::getLang() const {
+  return lang_;
 }
 
-std::string DescribeDataLimitsRequest::getServiceRegionId()const
-{
-	return serviceRegionId_;
+void DescribeDataLimitsRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 
-void DescribeDataLimitsRequest::setServiceRegionId(const std::string& serviceRegionId)
-{
-	serviceRegionId_ = serviceRegionId;
-	setParameter("ServiceRegionId", serviceRegionId);
+std::string DescribeDataLimitsRequest::getServiceRegionId() const {
+  return serviceRegionId_;
 }
 
-std::string DescribeDataLimitsRequest::getEngineType()const
-{
-	return engineType_;
+void DescribeDataLimitsRequest::setServiceRegionId(const std::string &serviceRegionId) {
+  serviceRegionId_ = serviceRegionId;
+  setParameter(std::string("ServiceRegionId"), serviceRegionId);
 }
 
-void DescribeDataLimitsRequest::setEngineType(const std::string& engineType)
-{
-	engineType_ = engineType;
-	setParameter("EngineType", engineType);
+std::string DescribeDataLimitsRequest::getEngineType() const {
+  return engineType_;
 }
 
-int DescribeDataLimitsRequest::getAuditStatus()const
-{
-	return auditStatus_;
+void DescribeDataLimitsRequest::setEngineType(const std::string &engineType) {
+  engineType_ = engineType;
+  setParameter(std::string("EngineType"), engineType);
 }
 
-void DescribeDataLimitsRequest::setAuditStatus(int auditStatus)
-{
-	auditStatus_ = auditStatus;
-	setParameter("AuditStatus", std::to_string(auditStatus));
+int DescribeDataLimitsRequest::getAuditStatus() const {
+  return auditStatus_;
 }
 
-long DescribeDataLimitsRequest::getEndTime()const
-{
-	return endTime_;
+void DescribeDataLimitsRequest::setAuditStatus(int auditStatus) {
+  auditStatus_ = auditStatus;
+  setParameter(std::string("AuditStatus"), std::to_string(auditStatus));
 }
 
-void DescribeDataLimitsRequest::setEndTime(long endTime)
-{
-	endTime_ = endTime;
-	setParameter("EndTime", std::to_string(endTime));
+long DescribeDataLimitsRequest::getEndTime() const {
+  return endTime_;
 }
 
-int DescribeDataLimitsRequest::getCurrentPage()const
-{
-	return currentPage_;
+void DescribeDataLimitsRequest::setEndTime(long endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), std::to_string(endTime));
 }
 
-void DescribeDataLimitsRequest::setCurrentPage(int currentPage)
-{
-	currentPage_ = currentPage;
-	setParameter("CurrentPage", std::to_string(currentPage));
+int DescribeDataLimitsRequest::getCurrentPage() const {
+  return currentPage_;
 }
 
-int DescribeDataLimitsRequest::getResourceType()const
-{
-	return resourceType_;
+void DescribeDataLimitsRequest::setCurrentPage(int currentPage) {
+  currentPage_ = currentPage;
+  setParameter(std::string("CurrentPage"), std::to_string(currentPage));
 }
 
-void DescribeDataLimitsRequest::setResourceType(int resourceType)
-{
-	resourceType_ = resourceType;
-	setParameter("ResourceType", std::to_string(resourceType));
+int DescribeDataLimitsRequest::getResourceType() const {
+  return resourceType_;
+}
+
+void DescribeDataLimitsRequest::setResourceType(int resourceType) {
+  resourceType_ = resourceType;
+  setParameter(std::string("ResourceType"), std::to_string(resourceType));
 }
 

sddp/src/model/DescribeDataLimitsResult.cc

@@ -43,92 +43,92 @@ void DescribeDataLimitsResult::parse(const std::string &payload)
 	for (auto valueItemsDataLimit : allItemsNode)
 	{
 		DataLimit itemsObject;
-		if(!valueItemsDataLimit["RegionId"].isNull())
-			itemsObject.regionId = valueItemsDataLimit["RegionId"].asString();
-		if(!valueItemsDataLimit["LocalName"].isNull())
-			itemsObject.localName = valueItemsDataLimit["LocalName"].asString();
-		if(!valueItemsDataLimit["ParentId"].isNull())
-			itemsObject.parentId = valueItemsDataLimit["ParentId"].asString();
-		if(!valueItemsDataLimit["Id"].isNull())
-			itemsObject.id = std::stol(valueItemsDataLimit["Id"].asString());
-		if(!valueItemsDataLimit["UserName"].isNull())
-			itemsObject.userName = valueItemsDataLimit["UserName"].asString();
-		if(!valueItemsDataLimit["GmtCreate"].isNull())
-			itemsObject.gmtCreate = std::stol(valueItemsDataLimit["GmtCreate"].asString());
-		if(!valueItemsDataLimit["Connector"].isNull())
-			itemsObject.connector = valueItemsDataLimit["Connector"].asString();
-		if(!valueItemsDataLimit["CheckStatus"].isNull())
-			itemsObject.checkStatus = std::stoi(valueItemsDataLimit["CheckStatus"].asString());
-		if(!valueItemsDataLimit["CheckStatusName"].isNull())
-			itemsObject.checkStatusName = valueItemsDataLimit["CheckStatusName"].asString();
-		if(!valueItemsDataLimit["ResourceType"].isNull())
-			itemsObject.resourceType = std::stol(valueItemsDataLimit["ResourceType"].asString());
-		if(!valueItemsDataLimit["ResourceTypeCode"].isNull())
-			itemsObject.resourceTypeCode = valueItemsDataLimit["ResourceTypeCode"].asString();
-		if(!valueItemsDataLimit["AuditStatus"].isNull())
-			itemsObject.auditStatus = std::stoi(valueItemsDataLimit["AuditStatus"].asString());
-		if(!valueItemsDataLimit["LogStoreDay"].isNull())
-			itemsObject.logStoreDay = std::stoi(valueItemsDataLimit["LogStoreDay"].asString());
-		if(!valueItemsDataLimit["Enable"].isNull())
-			itemsObject.enable = std::stoi(valueItemsDataLimit["Enable"].asString());
-		if(!valueItemsDataLimit["AutoScan"].isNull())
-			itemsObject.autoScan = std::stoi(valueItemsDataLimit["AutoScan"].asString());
-		if(!valueItemsDataLimit["EngineType"].isNull())
-			itemsObject.engineType = valueItemsDataLimit["EngineType"].asString();
-		if(!valueItemsDataLimit["ProcessStatus"].isNull())
-			itemsObject.processStatus = std::stoi(valueItemsDataLimit["ProcessStatus"].asString());
-		if(!valueItemsDataLimit["ProcessTotalCount"].isNull())
-			itemsObject.processTotalCount = std::stoi(valueItemsDataLimit["ProcessTotalCount"].asString());
-		if(!valueItemsDataLimit["TotalCount"].isNull())
-			itemsObject.totalCount = std::stoi(valueItemsDataLimit["TotalCount"].asString());
-		if(!valueItemsDataLimit["LastFinishedTime"].isNull())
-			itemsObject.lastFinishedTime = std::stol(valueItemsDataLimit["LastFinishedTime"].asString());
-		if(!valueItemsDataLimit["ErrorCode"].isNull())
-			itemsObject.errorCode = valueItemsDataLimit["ErrorCode"].asString();
-		if(!valueItemsDataLimit["ErrorMessage"].isNull())
-			itemsObject.errorMessage = valueItemsDataLimit["ErrorMessage"].asString();
-		if(!valueItemsDataLimit["Port"].isNull())
-			itemsObject.port = std::stoi(valueItemsDataLimit["Port"].asString());
-		if(!valueItemsDataLimit["DbVersion"].isNull())
-			itemsObject.dbVersion = valueItemsDataLimit["DbVersion"].asString();
-		if(!valueItemsDataLimit["SupportDatamask"].isNull())
-			itemsObject.supportDatamask = valueItemsDataLimit["SupportDatamask"].asString() == "true";
-		if(!valueItemsDataLimit["SupportScan"].isNull())
-			itemsObject.supportScan = valueItemsDataLimit["SupportScan"].asString() == "true";
-		if(!valueItemsDataLimit["SupportAudit"].isNull())
-			itemsObject.supportAudit = valueItemsDataLimit["SupportAudit"].asString() == "true";
-		if(!valueItemsDataLimit["DatamaskStatus"].isNull())
-			itemsObject.datamaskStatus = std::stoi(valueItemsDataLimit["DatamaskStatus"].asString());
-		if(!valueItemsDataLimit["SamplingSize"].isNull())
-			itemsObject.samplingSize = std::stoi(valueItemsDataLimit["SamplingSize"].asString());
-		if(!valueItemsDataLimit["NextStartTime"].isNull())
-			itemsObject.nextStartTime = std::stol(valueItemsDataLimit["NextStartTime"].asString());
-		if(!valueItemsDataLimit["SupportOcr"].isNull())
-			itemsObject.supportOcr = valueItemsDataLimit["SupportOcr"].asString() == "true";
-		if(!valueItemsDataLimit["OcrStatus"].isNull())
-			itemsObject.ocrStatus = std::stoi(valueItemsDataLimit["OcrStatus"].asString());
-		if(!valueItemsDataLimit["AgentId"].isNull())
-			itemsObject.agentId = valueItemsDataLimit["AgentId"].asString();
-		if(!valueItemsDataLimit["AgentState"].isNull())
-			itemsObject.agentState = std::stoi(valueItemsDataLimit["AgentState"].asString());
-		if(!valueItemsDataLimit["SupportAgentInstall"].isNull())
-			itemsObject.supportAgentInstall = valueItemsDataLimit["SupportAgentInstall"].asString() == "true";
-		if(!valueItemsDataLimit["EventStatus"].isNull())
-			itemsObject.eventStatus = std::stoi(valueItemsDataLimit["EventStatus"].asString());
 		if(!valueItemsDataLimit["SupportEvent"].isNull())
 			itemsObject.supportEvent = valueItemsDataLimit["SupportEvent"].asString() == "true";
-		if(!valueItemsDataLimit["InstanceId"].isNull())
-			itemsObject.instanceId = valueItemsDataLimit["InstanceId"].asString();
-		if(!valueItemsDataLimit["InstanceDescription"].isNull())
-			itemsObject.instanceDescription = valueItemsDataLimit["InstanceDescription"].asString();
+		if(!valueItemsDataLimit["ErrorMessage"].isNull())
+			itemsObject.errorMessage = valueItemsDataLimit["ErrorMessage"].asString();
+		if(!valueItemsDataLimit["CheckStatus"].isNull())
+			itemsObject.checkStatus = std::stoi(valueItemsDataLimit["CheckStatus"].asString());
+		if(!valueItemsDataLimit["LocalName"].isNull())
+			itemsObject.localName = valueItemsDataLimit["LocalName"].asString();
 		if(!valueItemsDataLimit["TenantName"].isNull())
 			itemsObject.tenantName = valueItemsDataLimit["TenantName"].asString();
+		if(!valueItemsDataLimit["AgentId"].isNull())
+			itemsObject.agentId = valueItemsDataLimit["AgentId"].asString();
+		if(!valueItemsDataLimit["NextStartTime"].isNull())
+			itemsObject.nextStartTime = std::stol(valueItemsDataLimit["NextStartTime"].asString());
+		if(!valueItemsDataLimit["Connector"].isNull())
+			itemsObject.connector = valueItemsDataLimit["Connector"].asString();
+		if(!valueItemsDataLimit["Port"].isNull())
+			itemsObject.port = std::stoi(valueItemsDataLimit["Port"].asString());
+		if(!valueItemsDataLimit["CheckStatusName"].isNull())
+			itemsObject.checkStatusName = valueItemsDataLimit["CheckStatusName"].asString();
+		if(!valueItemsDataLimit["AgentState"].isNull())
+			itemsObject.agentState = std::stoi(valueItemsDataLimit["AgentState"].asString());
+		if(!valueItemsDataLimit["SamplingSize"].isNull())
+			itemsObject.samplingSize = std::stoi(valueItemsDataLimit["SamplingSize"].asString());
+		if(!valueItemsDataLimit["ParentId"].isNull())
+			itemsObject.parentId = valueItemsDataLimit["ParentId"].asString();
+		if(!valueItemsDataLimit["DatamaskStatus"].isNull())
+			itemsObject.datamaskStatus = std::stoi(valueItemsDataLimit["DatamaskStatus"].asString());
+		if(!valueItemsDataLimit["ProcessTotalCount"].isNull())
+			itemsObject.processTotalCount = std::stoi(valueItemsDataLimit["ProcessTotalCount"].asString());
+		if(!valueItemsDataLimit["ResourceType"].isNull())
+			itemsObject.resourceType = std::stol(valueItemsDataLimit["ResourceType"].asString());
+		if(!valueItemsDataLimit["ErrorCode"].isNull())
+			itemsObject.errorCode = valueItemsDataLimit["ErrorCode"].asString();
+		if(!valueItemsDataLimit["OcrStatus"].isNull())
+			itemsObject.ocrStatus = std::stoi(valueItemsDataLimit["OcrStatus"].asString());
+		if(!valueItemsDataLimit["LogStoreDay"].isNull())
+			itemsObject.logStoreDay = std::stoi(valueItemsDataLimit["LogStoreDay"].asString());
+		if(!valueItemsDataLimit["EventStatus"].isNull())
+			itemsObject.eventStatus = std::stoi(valueItemsDataLimit["EventStatus"].asString());
+		if(!valueItemsDataLimit["SupportScan"].isNull())
+			itemsObject.supportScan = valueItemsDataLimit["SupportScan"].asString() == "true";
+		if(!valueItemsDataLimit["LastFinishedTime"].isNull())
+			itemsObject.lastFinishedTime = std::stol(valueItemsDataLimit["LastFinishedTime"].asString());
+		if(!valueItemsDataLimit["UserName"].isNull())
+			itemsObject.userName = valueItemsDataLimit["UserName"].asString();
+		if(!valueItemsDataLimit["AuditStatus"].isNull())
+			itemsObject.auditStatus = std::stoi(valueItemsDataLimit["AuditStatus"].asString());
+		if(!valueItemsDataLimit["SupportOcr"].isNull())
+			itemsObject.supportOcr = valueItemsDataLimit["SupportOcr"].asString() == "true";
+		if(!valueItemsDataLimit["SupportAgentInstall"].isNull())
+			itemsObject.supportAgentInstall = valueItemsDataLimit["SupportAgentInstall"].asString() == "true";
+		if(!valueItemsDataLimit["EngineType"].isNull())
+			itemsObject.engineType = valueItemsDataLimit["EngineType"].asString();
+		if(!valueItemsDataLimit["InstanceId"].isNull())
+			itemsObject.instanceId = valueItemsDataLimit["InstanceId"].asString();
+		if(!valueItemsDataLimit["TotalCount"].isNull())
+			itemsObject.totalCount = std::stoi(valueItemsDataLimit["TotalCount"].asString());
+		if(!valueItemsDataLimit["InstanceDescription"].isNull())
+			itemsObject.instanceDescription = valueItemsDataLimit["InstanceDescription"].asString();
+		if(!valueItemsDataLimit["DbVersion"].isNull())
+			itemsObject.dbVersion = valueItemsDataLimit["DbVersion"].asString();
+		if(!valueItemsDataLimit["RegionId"].isNull())
+			itemsObject.regionId = valueItemsDataLimit["RegionId"].asString();
+		if(!valueItemsDataLimit["GmtCreate"].isNull())
+			itemsObject.gmtCreate = std::stol(valueItemsDataLimit["GmtCreate"].asString());
+		if(!valueItemsDataLimit["SupportAudit"].isNull())
+			itemsObject.supportAudit = valueItemsDataLimit["SupportAudit"].asString() == "true";
+		if(!valueItemsDataLimit["AutoScan"].isNull())
+			itemsObject.autoScan = std::stoi(valueItemsDataLimit["AutoScan"].asString());
+		if(!valueItemsDataLimit["ResourceTypeCode"].isNull())
+			itemsObject.resourceTypeCode = valueItemsDataLimit["ResourceTypeCode"].asString();
+		if(!valueItemsDataLimit["SupportDatamask"].isNull())
+			itemsObject.supportDatamask = valueItemsDataLimit["SupportDatamask"].asString() == "true";
+		if(!valueItemsDataLimit["ProcessStatus"].isNull())
+			itemsObject.processStatus = std::stoi(valueItemsDataLimit["ProcessStatus"].asString());
+		if(!valueItemsDataLimit["Id"].isNull())
+			itemsObject.id = std::stol(valueItemsDataLimit["Id"].asString());
+		if(!valueItemsDataLimit["Enable"].isNull())
+			itemsObject.enable = std::stoi(valueItemsDataLimit["Enable"].asString());
 		items_.push_back(itemsObject);
 	}
-	if(!value["PageSize"].isNull())
-		pageSize_ = std::stoi(value["PageSize"].asString());
 	if(!value["CurrentPage"].isNull())
 		currentPage_ = std::stoi(value["CurrentPage"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
 	if(!value["TotalCount"].isNull())
 		totalCount_ = std::stoi(value["TotalCount"].asString());
 

sddp/src/model/DescribeDataMaskingRunHistoryRequest.cc

@@ -1,172 +1,144 @@
 /*
  * 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/sddp/model/DescribeDataMaskingRunHistoryRequest.h>
-
-using AlibabaCloud::Sddp::Model::DescribeDataMaskingRunHistoryRequest;
-
-DescribeDataMaskingRunHistoryRequest::DescribeDataMaskingRunHistoryRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "DescribeDataMaskingRunHistory")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeDataMaskingRunHistoryRequest::~DescribeDataMaskingRunHistoryRequest()
-{}
-
-int DescribeDataMaskingRunHistoryRequest::getSrcType()const
-{
-	return srcType_;
+ */
+
+#include <alibabacloud/sddp/model/DescribeDataMaskingRunHistoryRequest.h>
+
+using AlibabaCloud::Sddp::Model::DescribeDataMaskingRunHistoryRequest;
+
+DescribeDataMaskingRunHistoryRequest::DescribeDataMaskingRunHistoryRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "DescribeDataMaskingRunHistory") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeDataMaskingRunHistoryRequest::setSrcType(int srcType)
-{
-	srcType_ = srcType;
-	setParameter("SrcType", std::to_string(srcType));
+DescribeDataMaskingRunHistoryRequest::~DescribeDataMaskingRunHistoryRequest() {}
+
+int DescribeDataMaskingRunHistoryRequest::getSrcType() const {
+  return srcType_;
 }
 
-long DescribeDataMaskingRunHistoryRequest::getMainProcessId()const
-{
-	return mainProcessId_;
+void DescribeDataMaskingRunHistoryRequest::setSrcType(int srcType) {
+  srcType_ = srcType;
+  setParameter(std::string("SrcType"), std::to_string(srcType));
 }
 
-void DescribeDataMaskingRunHistoryRequest::setMainProcessId(long mainProcessId)
-{
-	mainProcessId_ = mainProcessId;
-	setParameter("MainProcessId", std::to_string(mainProcessId));
+long DescribeDataMaskingRunHistoryRequest::getMainProcessId() const {
+  return mainProcessId_;
 }
 
-long DescribeDataMaskingRunHistoryRequest::getStartTime()const
-{
-	return startTime_;
+void DescribeDataMaskingRunHistoryRequest::setMainProcessId(long mainProcessId) {
+  mainProcessId_ = mainProcessId;
+  setParameter(std::string("MainProcessId"), std::to_string(mainProcessId));
 }
 
-void DescribeDataMaskingRunHistoryRequest::setStartTime(long startTime)
-{
-	startTime_ = startTime;
-	setParameter("StartTime", std::to_string(startTime));
+long DescribeDataMaskingRunHistoryRequest::getStartTime() const {
+  return startTime_;
 }
 
-std::string DescribeDataMaskingRunHistoryRequest::getSourceIp()const
-{
-	return sourceIp_;
+void DescribeDataMaskingRunHistoryRequest::setStartTime(long startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), std::to_string(startTime));
 }
 
-void DescribeDataMaskingRunHistoryRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+std::string DescribeDataMaskingRunHistoryRequest::getSourceIp() const {
+  return sourceIp_;
 }
 
-int DescribeDataMaskingRunHistoryRequest::getPageSize()const
-{
-	return pageSize_;
+void DescribeDataMaskingRunHistoryRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
 }
 
-void DescribeDataMaskingRunHistoryRequest::setPageSize(int pageSize)
-{
-	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
+int DescribeDataMaskingRunHistoryRequest::getPageSize() const {
+  return pageSize_;
 }
 
-std::string DescribeDataMaskingRunHistoryRequest::getLang()const
-{
-	return lang_;
+void DescribeDataMaskingRunHistoryRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
 }
 
-void DescribeDataMaskingRunHistoryRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
+std::string DescribeDataMaskingRunHistoryRequest::getLang() const {
+  return lang_;
 }
 
-std::string DescribeDataMaskingRunHistoryRequest::getTaskId()const
-{
-	return taskId_;
+void DescribeDataMaskingRunHistoryRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 
-void DescribeDataMaskingRunHistoryRequest::setTaskId(const std::string& taskId)
-{
-	taskId_ = taskId;
-	setParameter("TaskId", taskId);
+std::string DescribeDataMaskingRunHistoryRequest::getTaskId() const {
+  return taskId_;
 }
 
-std::string DescribeDataMaskingRunHistoryRequest::getSrcTableName()const
-{
-	return srcTableName_;
+void DescribeDataMaskingRunHistoryRequest::setTaskId(const std::string &taskId) {
+  taskId_ = taskId;
+  setParameter(std::string("TaskId"), taskId);
 }
 
-void DescribeDataMaskingRunHistoryRequest::setSrcTableName(const std::string& srcTableName)
-{
-	srcTableName_ = srcTableName;
-	setParameter("SrcTableName", srcTableName);
+std::string DescribeDataMaskingRunHistoryRequest::getSrcTableName() const {
+  return srcTableName_;
 }
 
-int DescribeDataMaskingRunHistoryRequest::getFeatureType()const
-{
-	return featureType_;
+void DescribeDataMaskingRunHistoryRequest::setSrcTableName(const std::string &srcTableName) {
+  srcTableName_ = srcTableName;
+  setParameter(std::string("SrcTableName"), srcTableName);
 }
 
-void DescribeDataMaskingRunHistoryRequest::setFeatureType(int featureType)
-{
-	featureType_ = featureType;
-	setParameter("FeatureType", std::to_string(featureType));
+int DescribeDataMaskingRunHistoryRequest::getFeatureType() const {
+  return featureType_;
 }
 
-long DescribeDataMaskingRunHistoryRequest::getEndTime()const
-{
-	return endTime_;
+void DescribeDataMaskingRunHistoryRequest::setFeatureType(int featureType) {
+  featureType_ = featureType;
+  setParameter(std::string("FeatureType"), std::to_string(featureType));
 }
 
-void DescribeDataMaskingRunHistoryRequest::setEndTime(long endTime)
-{
-	endTime_ = endTime;
-	setParameter("EndTime", std::to_string(endTime));
+long DescribeDataMaskingRunHistoryRequest::getEndTime() const {
+  return endTime_;
 }
 
-int DescribeDataMaskingRunHistoryRequest::getCurrentPage()const
-{
-	return currentPage_;
+void DescribeDataMaskingRunHistoryRequest::setEndTime(long endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), std::to_string(endTime));
 }
 
-void DescribeDataMaskingRunHistoryRequest::setCurrentPage(int currentPage)
-{
-	currentPage_ = currentPage;
-	setParameter("CurrentPage", std::to_string(currentPage));
+int DescribeDataMaskingRunHistoryRequest::getCurrentPage() const {
+  return currentPage_;
 }
 
-int DescribeDataMaskingRunHistoryRequest::getDstType()const
-{
-	return dstType_;
+void DescribeDataMaskingRunHistoryRequest::setCurrentPage(int currentPage) {
+  currentPage_ = currentPage;
+  setParameter(std::string("CurrentPage"), std::to_string(currentPage));
 }
 
-void DescribeDataMaskingRunHistoryRequest::setDstType(int dstType)
-{
-	dstType_ = dstType;
-	setParameter("DstType", std::to_string(dstType));
+int DescribeDataMaskingRunHistoryRequest::getDstType() const {
+  return dstType_;
 }
 
-int DescribeDataMaskingRunHistoryRequest::getStatus()const
-{
-	return status_;
+void DescribeDataMaskingRunHistoryRequest::setDstType(int dstType) {
+  dstType_ = dstType;
+  setParameter(std::string("DstType"), std::to_string(dstType));
 }
 
-void DescribeDataMaskingRunHistoryRequest::setStatus(int status)
-{
-	status_ = status;
-	setParameter("Status", std::to_string(status));
+int DescribeDataMaskingRunHistoryRequest::getStatus() const {
+  return status_;
+}
+
+void DescribeDataMaskingRunHistoryRequest::setStatus(int status) {
+  status_ = status;
+  setParameter(std::string("Status"), std::to_string(status));
 }
 

sddp/src/model/DescribeDataMaskingRunHistoryResult.cc

@@ -43,50 +43,50 @@ void DescribeDataMaskingRunHistoryResult::parse(const std::string &payload)
 	for (auto valueItemsTask : allItemsNode)
 	{
 		Task itemsObject;
-		if(!valueItemsTask["Id"].isNull())
-			itemsObject.id = std::stol(valueItemsTask["Id"].asString());
-		if(!valueItemsTask["TaskId"].isNull())
-			itemsObject.taskId = valueItemsTask["TaskId"].asString();
-		if(!valueItemsTask["StartTime"].isNull())
-			itemsObject.startTime = std::stol(valueItemsTask["StartTime"].asString());
+		if(!valueItemsTask["Status"].isNull())
+			itemsObject.status = std::stoi(valueItemsTask["Status"].asString());
+		if(!valueItemsTask["Type"].isNull())
+			itemsObject.type = std::stoi(valueItemsTask["Type"].asString());
+		if(!valueItemsTask["SrcType"].isNull())
+			itemsObject.srcType = std::stoi(valueItemsTask["SrcType"].asString());
+		if(!valueItemsTask["SrcTableName"].isNull())
+			itemsObject.srcTableName = valueItemsTask["SrcTableName"].asString();
+		if(!valueItemsTask["MaskingCount"].isNull())
+			itemsObject.maskingCount = std::stol(valueItemsTask["MaskingCount"].asString());
+		if(!valueItemsTask["Percentage"].isNull())
+			itemsObject.percentage = std::stoi(valueItemsTask["Percentage"].asString());
+		if(!valueItemsTask["DstType"].isNull())
+			itemsObject.dstType = std::stoi(valueItemsTask["DstType"].asString());
+		if(!valueItemsTask["FailMsg"].isNull())
+			itemsObject.failMsg = valueItemsTask["FailMsg"].asString();
+		if(!valueItemsTask["FailCode"].isNull())
+			itemsObject.failCode = valueItemsTask["FailCode"].asString();
+		if(!valueItemsTask["ConflictCount"].isNull())
+			itemsObject.conflictCount = std::stol(valueItemsTask["ConflictCount"].asString());
+		if(!valueItemsTask["DstTypeCode"].isNull())
+			itemsObject.dstTypeCode = valueItemsTask["DstTypeCode"].asString();
 		if(!valueItemsTask["EndTime"].isNull())
 			itemsObject.endTime = std::stol(valueItemsTask["EndTime"].asString());
 		if(!valueItemsTask["RunIndex"].isNull())
 			itemsObject.runIndex = std::stoi(valueItemsTask["RunIndex"].asString());
-		if(!valueItemsTask["Type"].isNull())
-			itemsObject.type = std::stoi(valueItemsTask["Type"].asString());
-		if(!valueItemsTask["DstType"].isNull())
-			itemsObject.dstType = std::stoi(valueItemsTask["DstType"].asString());
-		if(!valueItemsTask["Percentage"].isNull())
-			itemsObject.percentage = std::stoi(valueItemsTask["Percentage"].asString());
-		if(!valueItemsTask["SrcType"].isNull())
-			itemsObject.srcType = std::stoi(valueItemsTask["SrcType"].asString());
-		if(!valueItemsTask["MaskingCount"].isNull())
-			itemsObject.maskingCount = std::stol(valueItemsTask["MaskingCount"].asString());
-		if(!valueItemsTask["ConflictCount"].isNull())
-			itemsObject.conflictCount = std::stol(valueItemsTask["ConflictCount"].asString());
-		if(!valueItemsTask["Status"].isNull())
-			itemsObject.status = std::stoi(valueItemsTask["Status"].asString());
-		if(!valueItemsTask["FailCode"].isNull())
-			itemsObject.failCode = valueItemsTask["FailCode"].asString();
-		if(!valueItemsTask["DstTypeCode"].isNull())
-			itemsObject.dstTypeCode = valueItemsTask["DstTypeCode"].asString();
-		if(!valueItemsTask["SrcTypeCode"].isNull())
-			itemsObject.srcTypeCode = valueItemsTask["SrcTypeCode"].asString();
+		if(!valueItemsTask["StartTime"].isNull())
+			itemsObject.startTime = std::stol(valueItemsTask["StartTime"].asString());
 		if(!valueItemsTask["HasSubProcess"].isNull())
 			itemsObject.hasSubProcess = std::stoi(valueItemsTask["HasSubProcess"].asString());
 		if(!valueItemsTask["HasDownloadFile"].isNull())
 			itemsObject.hasDownloadFile = std::stoi(valueItemsTask["HasDownloadFile"].asString());
-		if(!valueItemsTask["SrcTableName"].isNull())
-			itemsObject.srcTableName = valueItemsTask["SrcTableName"].asString();
-		if(!valueItemsTask["FailMsg"].isNull())
-			itemsObject.failMsg = valueItemsTask["FailMsg"].asString();
+		if(!valueItemsTask["TaskId"].isNull())
+			itemsObject.taskId = valueItemsTask["TaskId"].asString();
+		if(!valueItemsTask["SrcTypeCode"].isNull())
+			itemsObject.srcTypeCode = valueItemsTask["SrcTypeCode"].asString();
+		if(!valueItemsTask["Id"].isNull())
+			itemsObject.id = std::stol(valueItemsTask["Id"].asString());
 		items_.push_back(itemsObject);
 	}
-	if(!value["PageSize"].isNull())
-		pageSize_ = std::stoi(value["PageSize"].asString());
 	if(!value["CurrentPage"].isNull())
 		currentPage_ = std::stoi(value["CurrentPage"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
 	if(!value["TotalCount"].isNull())
 		totalCount_ = std::stoi(value["TotalCount"].asString());
 

sddp/src/model/DescribeDataMaskingTasksRequest.cc

@@ -1,128 +1,108 @@
 /*
  * 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/sddp/model/DescribeDataMaskingTasksRequest.h>
-
-using AlibabaCloud::Sddp::Model::DescribeDataMaskingTasksRequest;
-
-DescribeDataMaskingTasksRequest::DescribeDataMaskingTasksRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "DescribeDataMaskingTasks")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeDataMaskingTasksRequest::~DescribeDataMaskingTasksRequest()
-{}
-
-std::string DescribeDataMaskingTasksRequest::getSearchKey()const
-{
-	return searchKey_;
+ */
+
+#include <alibabacloud/sddp/model/DescribeDataMaskingTasksRequest.h>
+
+using AlibabaCloud::Sddp::Model::DescribeDataMaskingTasksRequest;
+
+DescribeDataMaskingTasksRequest::DescribeDataMaskingTasksRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "DescribeDataMaskingTasks") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeDataMaskingTasksRequest::setSearchKey(const std::string& searchKey)
-{
-	searchKey_ = searchKey;
-	setParameter("SearchKey", searchKey);
+DescribeDataMaskingTasksRequest::~DescribeDataMaskingTasksRequest() {}
+
+std::string DescribeDataMaskingTasksRequest::getSearchKey() const {
+  return searchKey_;
 }
 
-long DescribeDataMaskingTasksRequest::getStartTime()const
-{
-	return startTime_;
+void DescribeDataMaskingTasksRequest::setSearchKey(const std::string &searchKey) {
+  searchKey_ = searchKey;
+  setParameter(std::string("SearchKey"), searchKey);
 }
 
-void DescribeDataMaskingTasksRequest::setStartTime(long startTime)
-{
-	startTime_ = startTime;
-	setParameter("StartTime", std::to_string(startTime));
+long DescribeDataMaskingTasksRequest::getStartTime() const {
+  return startTime_;
 }
 
-std::string DescribeDataMaskingTasksRequest::getSourceIp()const
-{
-	return sourceIp_;
+void DescribeDataMaskingTasksRequest::setStartTime(long startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), std::to_string(startTime));
 }
 
-void DescribeDataMaskingTasksRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+std::string DescribeDataMaskingTasksRequest::getSourceIp() const {
+  return sourceIp_;
 }
 
-int DescribeDataMaskingTasksRequest::getPageSize()const
-{
-	return pageSize_;
+void DescribeDataMaskingTasksRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
 }
 
-void DescribeDataMaskingTasksRequest::setPageSize(int pageSize)
-{
-	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
+int DescribeDataMaskingTasksRequest::getPageSize() const {
+  return pageSize_;
 }
 
-std::string DescribeDataMaskingTasksRequest::getLang()const
-{
-	return lang_;
+void DescribeDataMaskingTasksRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
 }
 
-void DescribeDataMaskingTasksRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
+std::string DescribeDataMaskingTasksRequest::getLang() const {
+  return lang_;
 }
 
-int DescribeDataMaskingTasksRequest::getFeatureType()const
-{
-	return featureType_;
+void DescribeDataMaskingTasksRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 
-void DescribeDataMaskingTasksRequest::setFeatureType(int featureType)
-{
-	featureType_ = featureType;
-	setParameter("FeatureType", std::to_string(featureType));
+int DescribeDataMaskingTasksRequest::getFeatureType() const {
+  return featureType_;
 }
 
-long DescribeDataMaskingTasksRequest::getEndTime()const
-{
-	return endTime_;
+void DescribeDataMaskingTasksRequest::setFeatureType(int featureType) {
+  featureType_ = featureType;
+  setParameter(std::string("FeatureType"), std::to_string(featureType));
 }
 
-void DescribeDataMaskingTasksRequest::setEndTime(long endTime)
-{
-	endTime_ = endTime;
-	setParameter("EndTime", std::to_string(endTime));
+long DescribeDataMaskingTasksRequest::getEndTime() const {
+  return endTime_;
 }
 
-int DescribeDataMaskingTasksRequest::getCurrentPage()const
-{
-	return currentPage_;
+void DescribeDataMaskingTasksRequest::setEndTime(long endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), std::to_string(endTime));
 }
 
-void DescribeDataMaskingTasksRequest::setCurrentPage(int currentPage)
-{
-	currentPage_ = currentPage;
-	setParameter("CurrentPage", std::to_string(currentPage));
+int DescribeDataMaskingTasksRequest::getCurrentPage() const {
+  return currentPage_;
 }
 
-int DescribeDataMaskingTasksRequest::getDstType()const
-{
-	return dstType_;
+void DescribeDataMaskingTasksRequest::setCurrentPage(int currentPage) {
+  currentPage_ = currentPage;
+  setParameter(std::string("CurrentPage"), std::to_string(currentPage));
 }
 
-void DescribeDataMaskingTasksRequest::setDstType(int dstType)
-{
-	dstType_ = dstType;
-	setParameter("DstType", std::to_string(dstType));
+int DescribeDataMaskingTasksRequest::getDstType() const {
+  return dstType_;
+}
+
+void DescribeDataMaskingTasksRequest::setDstType(int dstType) {
+  dstType_ = dstType;
+  setParameter(std::string("DstType"), std::to_string(dstType));
 }
 

sddp/src/model/DescribeDataMaskingTasksResult.cc

@@ -43,44 +43,44 @@ void DescribeDataMaskingTasksResult::parse(const std::string &payload)
 	for (auto valueItemsTask : allItemsNode)
 	{
 		Task itemsObject;
-		if(!valueItemsTask["Id"].isNull())
-			itemsObject.id = std::stol(valueItemsTask["Id"].asString());
-		if(!valueItemsTask["TaskId"].isNull())
-			itemsObject.taskId = valueItemsTask["TaskId"].asString();
-		if(!valueItemsTask["TaskName"].isNull())
-			itemsObject.taskName = valueItemsTask["TaskName"].asString();
-		if(!valueItemsTask["Owner"].isNull())
-			itemsObject.owner = valueItemsTask["Owner"].asString();
-		if(!valueItemsTask["GmtCreate"].isNull())
-			itemsObject.gmtCreate = std::stol(valueItemsTask["GmtCreate"].asString());
-		if(!valueItemsTask["DstType"].isNull())
-			itemsObject.dstType = std::stoi(valueItemsTask["DstType"].asString());
-		if(!valueItemsTask["DstPath"].isNull())
-			itemsObject.dstPath = valueItemsTask["DstPath"].asString();
-		if(!valueItemsTask["SrcType"].isNull())
-			itemsObject.srcType = std::stoi(valueItemsTask["SrcType"].asString());
-		if(!valueItemsTask["SrcPath"].isNull())
-			itemsObject.srcPath = valueItemsTask["SrcPath"].asString();
-		if(!valueItemsTask["RunCount"].isNull())
-			itemsObject.runCount = std::stoi(valueItemsTask["RunCount"].asString());
 		if(!valueItemsTask["Status"].isNull())
 			itemsObject.status = std::stoi(valueItemsTask["Status"].asString());
+		if(!valueItemsTask["Owner"].isNull())
+			itemsObject.owner = valueItemsTask["Owner"].asString();
+		if(!valueItemsTask["TaskName"].isNull())
+			itemsObject.taskName = valueItemsTask["TaskName"].asString();
+		if(!valueItemsTask["SrcType"].isNull())
+			itemsObject.srcType = std::stoi(valueItemsTask["SrcType"].asString());
+		if(!valueItemsTask["DstType"].isNull())
+			itemsObject.dstType = std::stoi(valueItemsTask["DstType"].asString());
 		if(!valueItemsTask["HasUnfinishProcess"].isNull())
 			itemsObject.hasUnfinishProcess = valueItemsTask["HasUnfinishProcess"].asString() == "true";
-		if(!valueItemsTask["DstTypeCode"].isNull())
-			itemsObject.dstTypeCode = valueItemsTask["DstTypeCode"].asString();
-		if(!valueItemsTask["SrcTypeCode"].isNull())
-			itemsObject.srcTypeCode = valueItemsTask["SrcTypeCode"].asString();
-		if(!valueItemsTask["TriggerType"].isNull())
-			itemsObject.triggerType = std::stoi(valueItemsTask["TriggerType"].asString());
 		if(!valueItemsTask["OriginalTable"].isNull())
 			itemsObject.originalTable = valueItemsTask["OriginalTable"].asString() == "true";
+		if(!valueItemsTask["TriggerType"].isNull())
+			itemsObject.triggerType = std::stoi(valueItemsTask["TriggerType"].asString());
+		if(!valueItemsTask["DstTypeCode"].isNull())
+			itemsObject.dstTypeCode = valueItemsTask["DstTypeCode"].asString();
+		if(!valueItemsTask["RunCount"].isNull())
+			itemsObject.runCount = std::stoi(valueItemsTask["RunCount"].asString());
+		if(!valueItemsTask["GmtCreate"].isNull())
+			itemsObject.gmtCreate = std::stol(valueItemsTask["GmtCreate"].asString());
+		if(!valueItemsTask["TaskId"].isNull())
+			itemsObject.taskId = valueItemsTask["TaskId"].asString();
+		if(!valueItemsTask["DstPath"].isNull())
+			itemsObject.dstPath = valueItemsTask["DstPath"].asString();
+		if(!valueItemsTask["SrcTypeCode"].isNull())
+			itemsObject.srcTypeCode = valueItemsTask["SrcTypeCode"].asString();
+		if(!valueItemsTask["Id"].isNull())
+			itemsObject.id = std::stol(valueItemsTask["Id"].asString());
+		if(!valueItemsTask["SrcPath"].isNull())
+			itemsObject.srcPath = valueItemsTask["SrcPath"].asString();
 		items_.push_back(itemsObject);
 	}
-	if(!value["PageSize"].isNull())
-		pageSize_ = std::stoi(value["PageSize"].asString());
 	if(!value["CurrentPage"].isNull())
 		currentPage_ = std::stoi(value["CurrentPage"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
 	if(!value["TotalCount"].isNull())
 		totalCount_ = std::stoi(value["TotalCount"].asString());
 

sddp/src/model/DescribeDataTotalCountRequest.cc

@@ -1,95 +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/sddp/model/DescribeDataTotalCountRequest.h>
-
-using AlibabaCloud::Sddp::Model::DescribeDataTotalCountRequest;
-
-DescribeDataTotalCountRequest::DescribeDataTotalCountRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "DescribeDataTotalCount")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeDataTotalCountRequest::~DescribeDataTotalCountRequest()
-{}
-
-std::string DescribeDataTotalCountRequest::getProductCode()const
-{
-	return productCode_;
-}
-
-void DescribeDataTotalCountRequest::setProductCode(const std::string& productCode)
-{
-	productCode_ = productCode;
-	setParameter("ProductCode", productCode);
-}
-
-int DescribeDataTotalCountRequest::getFeatureType()const
-{
-	return featureType_;
-}
-
-void DescribeDataTotalCountRequest::setFeatureType(int featureType)
-{
-	featureType_ = featureType;
-	setParameter("FeatureType", std::to_string(featureType));
-}
-
-int DescribeDataTotalCountRequest::getCountType()const
-{
-	return countType_;
-}
-
-void DescribeDataTotalCountRequest::setCountType(int countType)
-{
-	countType_ = countType;
-	setParameter("CountType", std::to_string(countType));
-}
-
-long DescribeDataTotalCountRequest::getInstanceId()const
-{
-	return instanceId_;
-}
-
-void DescribeDataTotalCountRequest::setInstanceId(long instanceId)
-{
-	instanceId_ = instanceId;
-	setParameter("InstanceId", std::to_string(instanceId));
-}
-
-std::string DescribeDataTotalCountRequest::getSourceIp()const
-{
-	return sourceIp_;
-}
-
-void DescribeDataTotalCountRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
-}
-
-std::string DescribeDataTotalCountRequest::getLang()const
-{
-	return lang_;
-}
-
-void DescribeDataTotalCountRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
-}
-

sddp/src/model/DescribeDataTotalCountResult.cc

@@ -1,189 +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/sddp/model/DescribeDataTotalCountResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Sddp;
-using namespace AlibabaCloud::Sddp::Model;
-
-DescribeDataTotalCountResult::DescribeDataTotalCountResult() :
-	ServiceResult()
-{}
-
-DescribeDataTotalCountResult::DescribeDataTotalCountResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-DescribeDataTotalCountResult::~DescribeDataTotalCountResult()
-{}
-
-void DescribeDataTotalCountResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto dataCountNode = value["DataCount"];
-	auto instanceNode = dataCountNode["Instance"];
-	if(!instanceNode["TotalCount"].isNull())
-		dataCount_.instance.totalCount = std::stol(instanceNode["TotalCount"].asString());
-	if(!instanceNode["Count"].isNull())
-		dataCount_.instance.count = std::stol(instanceNode["Count"].asString());
-	if(!instanceNode["SensitiveCount"].isNull())
-		dataCount_.instance.sensitiveCount = std::stol(instanceNode["SensitiveCount"].asString());
-	if(!instanceNode["LastCount"].isNull())
-		dataCount_.instance.lastCount = std::stol(instanceNode["LastCount"].asString());
-	if(!instanceNode["LastSensitiveCount"].isNull())
-		dataCount_.instance.lastSensitiveCount = std::stol(instanceNode["LastSensitiveCount"].asString());
-	auto allRiskCountListNode = instanceNode["RiskCountList"]["RiskCount"];
-	for (auto instanceNodeRiskCountListRiskCount : allRiskCountListNode)
-	{
-		DataCount::Instance::RiskCount riskCountObject;
-		if(!instanceNodeRiskCountListRiskCount["Id"].isNull())
-			riskCountObject.id = std::stol(instanceNodeRiskCountListRiskCount["Id"].asString());
-		if(!instanceNodeRiskCountListRiskCount["Name"].isNull())
-			riskCountObject.name = instanceNodeRiskCountListRiskCount["Name"].asString();
-		if(!instanceNodeRiskCountListRiskCount["Count"].isNull())
-			riskCountObject.count = std::stol(instanceNodeRiskCountListRiskCount["Count"].asString());
-		dataCount_.instance.riskCountList.push_back(riskCountObject);
-	}
-	auto tableNode = dataCountNode["Table"];
-	if(!tableNode["TotalCount"].isNull())
-		dataCount_.table.totalCount = std::stol(tableNode["TotalCount"].asString());
-	if(!tableNode["Count"].isNull())
-		dataCount_.table.count = std::stol(tableNode["Count"].asString());
-	if(!tableNode["SensitiveCount"].isNull())
-		dataCount_.table.sensitiveCount = std::stol(tableNode["SensitiveCount"].asString());
-	if(!tableNode["LastCount"].isNull())
-		dataCount_.table.lastCount = std::stol(tableNode["LastCount"].asString());
-	if(!tableNode["LastSensitiveCount"].isNull())
-		dataCount_.table.lastSensitiveCount = std::stol(tableNode["LastSensitiveCount"].asString());
-	auto allRiskCountList1Node = tableNode["RiskCountList"]["RiskCount"];
-	for (auto tableNodeRiskCountListRiskCount : allRiskCountList1Node)
-	{
-		DataCount::Table::RiskCount2 riskCount2Object;
-		if(!tableNodeRiskCountListRiskCount["Id"].isNull())
-			riskCount2Object.id = std::stol(tableNodeRiskCountListRiskCount["Id"].asString());
-		if(!tableNodeRiskCountListRiskCount["Name"].isNull())
-			riskCount2Object.name = tableNodeRiskCountListRiskCount["Name"].asString();
-		if(!tableNodeRiskCountListRiskCount["Count"].isNull())
-			riskCount2Object.count = std::stol(tableNodeRiskCountListRiskCount["Count"].asString());
-		dataCount_.table.riskCountList1.push_back(riskCount2Object);
-	}
-	auto packageNode = dataCountNode["Package"];
-	if(!packageNode["TotalCount"].isNull())
-		dataCount_.package.totalCount = std::stol(packageNode["TotalCount"].asString());
-	if(!packageNode["Count"].isNull())
-		dataCount_.package.count = std::stol(packageNode["Count"].asString());
-	if(!packageNode["SensitiveCount"].isNull())
-		dataCount_.package.sensitiveCount = std::stol(packageNode["SensitiveCount"].asString());
-	if(!packageNode["LastCount"].isNull())
-		dataCount_.package.lastCount = std::stol(packageNode["LastCount"].asString());
-	if(!packageNode["LastSensitiveCount"].isNull())
-		dataCount_.package.lastSensitiveCount = std::stol(packageNode["LastSensitiveCount"].asString());
-	auto allRiskCountList3Node = packageNode["RiskCountList"]["RiskCount"];
-	for (auto packageNodeRiskCountListRiskCount : allRiskCountList3Node)
-	{
-		DataCount::Package::RiskCount4 riskCount4Object;
-		if(!packageNodeRiskCountListRiskCount["Id"].isNull())
-			riskCount4Object.id = std::stol(packageNodeRiskCountListRiskCount["Id"].asString());
-		if(!packageNodeRiskCountListRiskCount["Name"].isNull())
-			riskCount4Object.name = packageNodeRiskCountListRiskCount["Name"].asString();
-		if(!packageNodeRiskCountListRiskCount["Count"].isNull())
-			riskCount4Object.count = std::stol(packageNodeRiskCountListRiskCount["Count"].asString());
-		dataCount_.package.riskCountList3.push_back(riskCount4Object);
-	}
-	auto columnNode = dataCountNode["Column"];
-	if(!columnNode["TotalCount"].isNull())
-		dataCount_.column.totalCount = std::stol(columnNode["TotalCount"].asString());
-	if(!columnNode["Count"].isNull())
-		dataCount_.column.count = std::stol(columnNode["Count"].asString());
-	if(!columnNode["SensitiveCount"].isNull())
-		dataCount_.column.sensitiveCount = std::stol(columnNode["SensitiveCount"].asString());
-	if(!columnNode["LastCount"].isNull())
-		dataCount_.column.lastCount = std::stol(columnNode["LastCount"].asString());
-	if(!columnNode["LastSensitiveCount"].isNull())
-		dataCount_.column.lastSensitiveCount = std::stol(columnNode["LastSensitiveCount"].asString());
-	auto allRiskCountList5Node = columnNode["RiskCountList"]["RiskCount"];
-	for (auto columnNodeRiskCountListRiskCount : allRiskCountList5Node)
-	{
-		DataCount::Column::RiskCount6 riskCount6Object;
-		if(!columnNodeRiskCountListRiskCount["Id"].isNull())
-			riskCount6Object.id = std::stol(columnNodeRiskCountListRiskCount["Id"].asString());
-		if(!columnNodeRiskCountListRiskCount["Name"].isNull())
-			riskCount6Object.name = columnNodeRiskCountListRiskCount["Name"].asString();
-		if(!columnNodeRiskCountListRiskCount["Count"].isNull())
-			riskCount6Object.count = std::stol(columnNodeRiskCountListRiskCount["Count"].asString());
-		dataCount_.column.riskCountList5.push_back(riskCount6Object);
-	}
-	auto allColumnRuleTopNode = columnNode["ColumnRuleTop"]["ColumnCount"];
-	for (auto columnNodeColumnRuleTopColumnCount : allColumnRuleTopNode)
-	{
-		DataCount::Column::ColumnCount columnCountObject;
-		if(!columnNodeColumnRuleTopColumnCount["Id"].isNull())
-			columnCountObject.id = std::stol(columnNodeColumnRuleTopColumnCount["Id"].asString());
-		if(!columnNodeColumnRuleTopColumnCount["Name"].isNull())
-			columnCountObject.name = columnNodeColumnRuleTopColumnCount["Name"].asString();
-		if(!columnNodeColumnRuleTopColumnCount["Count"].isNull())
-			columnCountObject.count = std::stol(columnNodeColumnRuleTopColumnCount["Count"].asString());
-		dataCount_.column.columnRuleTop.push_back(columnCountObject);
-	}
-	auto ossNode = dataCountNode["Oss"];
-	if(!ossNode["TotalCount"].isNull())
-		dataCount_.oss.totalCount = std::stol(ossNode["TotalCount"].asString());
-	if(!ossNode["Count"].isNull())
-		dataCount_.oss.count = std::stol(ossNode["Count"].asString());
-	if(!ossNode["SensitiveCount"].isNull())
-		dataCount_.oss.sensitiveCount = std::stol(ossNode["SensitiveCount"].asString());
-	if(!ossNode["LastCount"].isNull())
-		dataCount_.oss.lastCount = std::stol(ossNode["LastCount"].asString());
-	if(!ossNode["LastSensitiveCount"].isNull())
-		dataCount_.oss.lastSensitiveCount = std::stol(ossNode["LastSensitiveCount"].asString());
-	auto allRiskCountList7Node = ossNode["RiskCountList"]["RiskCount"];
-	for (auto ossNodeRiskCountListRiskCount : allRiskCountList7Node)
-	{
-		DataCount::Oss::RiskCount8 riskCount8Object;
-		if(!ossNodeRiskCountListRiskCount["Id"].isNull())
-			riskCount8Object.id = std::stol(ossNodeRiskCountListRiskCount["Id"].asString());
-		if(!ossNodeRiskCountListRiskCount["Name"].isNull())
-			riskCount8Object.name = ossNodeRiskCountListRiskCount["Name"].asString();
-		if(!ossNodeRiskCountListRiskCount["Count"].isNull())
-			riskCount8Object.count = std::stol(ossNodeRiskCountListRiskCount["Count"].asString());
-		dataCount_.oss.riskCountList7.push_back(riskCount8Object);
-	}
-	auto allOssRuleTopNode = ossNode["OssRuleTop"]["OssCount"];
-	for (auto ossNodeOssRuleTopOssCount : allOssRuleTopNode)
-	{
-		DataCount::Oss::OssCount ossCountObject;
-		if(!ossNodeOssRuleTopOssCount["Id"].isNull())
-			ossCountObject.id = std::stol(ossNodeOssRuleTopOssCount["Id"].asString());
-		if(!ossNodeOssRuleTopOssCount["Name"].isNull())
-			ossCountObject.name = ossNodeOssRuleTopOssCount["Name"].asString();
-		if(!ossNodeOssRuleTopOssCount["Count"].isNull())
-			ossCountObject.count = std::stol(ossNodeOssRuleTopOssCount["Count"].asString());
-		dataCount_.oss.ossRuleTop.push_back(ossCountObject);
-	}
-
-}
-
-DescribeDataTotalCountResult::DataCount DescribeDataTotalCountResult::getDataCount()const
-{
-	return dataCount_;
-}
-

sddp/src/model/DescribeEventDetailRequest.cc

@@ -1,73 +1,63 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
-
-#include <alibabacloud/sddp/model/DescribeEventDetailRequest.h>
-
-using AlibabaCloud::Sddp::Model::DescribeEventDetailRequest;
-
-DescribeEventDetailRequest::DescribeEventDetailRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "DescribeEventDetail")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeEventDetailRequest::~DescribeEventDetailRequest()
-{}
-
-long DescribeEventDetailRequest::getFeatureType()const
-{
-	return featureType_;
+ */
+
+#include <alibabacloud/sddp/model/DescribeEventDetailRequest.h>
+
+using AlibabaCloud::Sddp::Model::DescribeEventDetailRequest;
+
+DescribeEventDetailRequest::DescribeEventDetailRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "DescribeEventDetail") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeEventDetailRequest::setFeatureType(long featureType)
-{
-	featureType_ = featureType;
-	setParameter("FeatureType", std::to_string(featureType));
+DescribeEventDetailRequest::~DescribeEventDetailRequest() {}
+
+long DescribeEventDetailRequest::getFeatureType() const {
+  return featureType_;
 }
 
-std::string DescribeEventDetailRequest::getSourceIp()const
-{
-	return sourceIp_;
+void DescribeEventDetailRequest::setFeatureType(long featureType) {
+  featureType_ = featureType;
+  setParameter(std::string("FeatureType"), std::to_string(featureType));
 }
 
-void DescribeEventDetailRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+std::string DescribeEventDetailRequest::getSourceIp() const {
+  return sourceIp_;
 }
 
-long DescribeEventDetailRequest::getId()const
-{
-	return id_;
+void DescribeEventDetailRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
 }
 
-void DescribeEventDetailRequest::setId(long id)
-{
-	id_ = id;
-	setParameter("Id", std::to_string(id));
+long DescribeEventDetailRequest::getId() const {
+  return id_;
 }
 
-std::string DescribeEventDetailRequest::getLang()const
-{
-	return lang_;
+void DescribeEventDetailRequest::setId(long id) {
+  id_ = id;
+  setParameter(std::string("Id"), std::to_string(id));
 }
 
-void DescribeEventDetailRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
+std::string DescribeEventDetailRequest::getLang() const {
+  return lang_;
+}
+
+void DescribeEventDetailRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 

sddp/src/model/DescribeEventDetailResult.cc

@@ -40,72 +40,72 @@ void DescribeEventDetailResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto eventNode = value["Event"];
-	if(!eventNode["Id"].isNull())
-		event_.id = std::stol(eventNode["Id"].asString());
-	if(!eventNode["UserId"].isNull())
-		event_.userId = std::stol(eventNode["UserId"].asString());
-	if(!eventNode["LoginName"].isNull())
-		event_.loginName = eventNode["LoginName"].asString();
 	if(!eventNode["DisplayName"].isNull())
 		event_.displayName = eventNode["DisplayName"].asString();
-	if(!eventNode["ProductCode"].isNull())
-		event_.productCode = eventNode["ProductCode"].asString();
-	if(!eventNode["TypeCode"].isNull())
-		event_.typeCode = eventNode["TypeCode"].asString();
-	if(!eventNode["TypeName"].isNull())
-		event_.typeName = eventNode["TypeName"].asString();
-	if(!eventNode["SubTypeCode"].isNull())
-		event_.subTypeCode = eventNode["SubTypeCode"].asString();
+	if(!eventNode["Status"].isNull())
+		event_.status = std::stoi(eventNode["Status"].asString());
+	if(!eventNode["DealReason"].isNull())
+		event_.dealReason = eventNode["DealReason"].asString();
+	if(!eventNode["UserId"].isNull())
+		event_.userId = std::stol(eventNode["UserId"].asString());
+	if(!eventNode["StatusName"].isNull())
+		event_.statusName = eventNode["StatusName"].asString();
+	if(!eventNode["DepartName"].isNull())
+		event_.departName = eventNode["DepartName"].asString();
+	if(!eventNode["DealTime"].isNull())
+		event_.dealTime = std::stol(eventNode["DealTime"].asString());
+	if(!eventNode["DealLoginName"].isNull())
+		event_.dealLoginName = eventNode["DealLoginName"].asString();
 	if(!eventNode["SubTypeName"].isNull())
 		event_.subTypeName = eventNode["SubTypeName"].asString();
-	if(!eventNode["AlertTime"].isNull())
-		event_.alertTime = std::stol(eventNode["AlertTime"].asString());
+	if(!eventNode["Backed"].isNull())
+		event_.backed = eventNode["Backed"].asString() == "true";
 	if(!eventNode["DataInstance"].isNull())
 		event_.dataInstance = eventNode["DataInstance"].asString();
 	if(!eventNode["EventTime"].isNull())
 		event_.eventTime = std::stol(eventNode["EventTime"].asString());
-	if(!eventNode["Status"].isNull())
-		event_.status = std::stoi(eventNode["Status"].asString());
-	if(!eventNode["StatusName"].isNull())
-		event_.statusName = eventNode["StatusName"].asString();
-	if(!eventNode["DealUserId"].isNull())
-		event_.dealUserId = std::stol(eventNode["DealUserId"].asString());
-	if(!eventNode["DealLoginName"].isNull())
-		event_.dealLoginName = eventNode["DealLoginName"].asString();
-	if(!eventNode["DealDisplayName"].isNull())
-		event_.dealDisplayName = eventNode["DealDisplayName"].asString();
-	if(!eventNode["DealTime"].isNull())
-		event_.dealTime = std::stol(eventNode["DealTime"].asString());
-	if(!eventNode["DepartName"].isNull())
-		event_.departName = eventNode["DepartName"].asString();
-	if(!eventNode["Backed"].isNull())
-		event_.backed = eventNode["Backed"].asString() == "true";
-	if(!eventNode["DealReason"].isNull())
-		event_.dealReason = eventNode["DealReason"].asString();
+	if(!eventNode["LoginName"].isNull())
+		event_.loginName = eventNode["LoginName"].asString();
 	if(!eventNode["UserIdValue"].isNull())
 		event_.userIdValue = eventNode["UserIdValue"].asString();
-	if(!eventNode["dealUserIdValue"].isNull())
-		event_.dealUserIdValue = eventNode["dealUserIdValue"].asString();
+	if(!eventNode["SubTypeCode"].isNull())
+		event_.subTypeCode = eventNode["SubTypeCode"].asString();
 	if(!eventNode["LogDetail"].isNull())
 		event_.logDetail = eventNode["LogDetail"].asString();
+	if(!eventNode["TypeCode"].isNull())
+		event_.typeCode = eventNode["TypeCode"].asString();
+	if(!eventNode["dealUserIdValue"].isNull())
+		event_.dealUserIdValue = eventNode["dealUserIdValue"].asString();
+	if(!eventNode["AlertTime"].isNull())
+		event_.alertTime = std::stol(eventNode["AlertTime"].asString());
+	if(!eventNode["DealUserId"].isNull())
+		event_.dealUserId = std::stol(eventNode["DealUserId"].asString());
+	if(!eventNode["TypeName"].isNull())
+		event_.typeName = eventNode["TypeName"].asString();
+	if(!eventNode["DealDisplayName"].isNull())
+		event_.dealDisplayName = eventNode["DealDisplayName"].asString();
+	if(!eventNode["Id"].isNull())
+		event_.id = std::stol(eventNode["Id"].asString());
+	if(!eventNode["ProductCode"].isNull())
+		event_.productCode = eventNode["ProductCode"].asString();
 	auto allHandleInfoListNode = eventNode["HandleInfoList"]["HandleInfo"];
 	for (auto eventNodeHandleInfoListHandleInfo : allHandleInfoListNode)
 	{
 		Event::HandleInfo handleInfoObject;
-		if(!eventNodeHandleInfoListHandleInfo["HandlerType"].isNull())
-			handleInfoObject.handlerType = eventNodeHandleInfoListHandleInfo["HandlerType"].asString();
-		if(!eventNodeHandleInfoListHandleInfo["HandlerName"].isNull())
-			handleInfoObject.handlerName = eventNodeHandleInfoListHandleInfo["HandlerName"].asString();
-		if(!eventNodeHandleInfoListHandleInfo["HandlerValue"].isNull())
-			handleInfoObject.handlerValue = std::stoi(eventNodeHandleInfoListHandleInfo["HandlerValue"].asString());
-		if(!eventNodeHandleInfoListHandleInfo["CurrentValue"].isNull())
-			handleInfoObject.currentValue = eventNodeHandleInfoListHandleInfo["CurrentValue"].asString();
-		if(!eventNodeHandleInfoListHandleInfo["DisableTime"].isNull())
-			handleInfoObject.disableTime = std::stol(eventNodeHandleInfoListHandleInfo["DisableTime"].asString());
-		if(!eventNodeHandleInfoListHandleInfo["EnableTime"].isNull())
-			handleInfoObject.enableTime = std::stol(eventNodeHandleInfoListHandleInfo["EnableTime"].asString());
 		if(!eventNodeHandleInfoListHandleInfo["Status"].isNull())
 			handleInfoObject.status = std::stoi(eventNodeHandleInfoListHandleInfo["Status"].asString());
+		if(!eventNodeHandleInfoListHandleInfo["EnableTime"].isNull())
+			handleInfoObject.enableTime = std::stol(eventNodeHandleInfoListHandleInfo["EnableTime"].asString());
+		if(!eventNodeHandleInfoListHandleInfo["HandlerValue"].isNull())
+			handleInfoObject.handlerValue = std::stoi(eventNodeHandleInfoListHandleInfo["HandlerValue"].asString());
+		if(!eventNodeHandleInfoListHandleInfo["DisableTime"].isNull())
+			handleInfoObject.disableTime = std::stol(eventNodeHandleInfoListHandleInfo["DisableTime"].asString());
+		if(!eventNodeHandleInfoListHandleInfo["HandlerName"].isNull())
+			handleInfoObject.handlerName = eventNodeHandleInfoListHandleInfo["HandlerName"].asString();
+		if(!eventNodeHandleInfoListHandleInfo["HandlerType"].isNull())
+			handleInfoObject.handlerType = eventNodeHandleInfoListHandleInfo["HandlerType"].asString();
+		if(!eventNodeHandleInfoListHandleInfo["CurrentValue"].isNull())
+			handleInfoObject.currentValue = eventNodeHandleInfoListHandleInfo["CurrentValue"].asString();
 		if(!eventNodeHandleInfoListHandleInfo["Id"].isNull())
 			handleInfoObject.id = std::stol(eventNodeHandleInfoListHandleInfo["Id"].asString());
 		event_.handleInfoList.push_back(handleInfoObject);
@@ -125,19 +125,21 @@ void DescribeEventDetailResult::parse(const std::string &payload)
 	for (auto detailNodeChartChartItem : allChartNode)
 	{
 		Event::Detail::ChartItem chartItemObject;
+		if(!detailNodeChartChartItem["Type"].isNull())
+			chartItemObject.type = detailNodeChartChartItem["Type"].asString();
 		if(!detailNodeChartChartItem["Label"].isNull())
 			chartItemObject.label = detailNodeChartChartItem["Label"].asString();
 		if(!detailNodeChartChartItem["XLabel"].isNull())
 			chartItemObject.xLabel = detailNodeChartChartItem["XLabel"].asString();
 		if(!detailNodeChartChartItem["YLabel"].isNull())
 			chartItemObject.yLabel = detailNodeChartChartItem["YLabel"].asString();
-		if(!detailNodeChartChartItem["Type"].isNull())
-			chartItemObject.type = detailNodeChartChartItem["Type"].asString();
 		auto dataNode = value["Data"];
-		if(!dataNode["X"].isNull())
-			chartItemObject.data.x = dataNode["X"].asString();
-		if(!dataNode["Y"].isNull())
-			chartItemObject.data.y = dataNode["Y"].asString();
+			auto allY = dataNode["Y"]["Y"];
+			for (auto value : allY)
+				chartItemObject.data.y.push_back(value.asString());
+			auto allX = dataNode["X"]["X"];
+			for (auto value : allX)
+				chartItemObject.data.x.push_back(value.asString());
 		event_.detail.chart.push_back(chartItemObject);
 	}
 	auto allResourceInfoNode = detailNode["ResourceInfo"]["ResourceInfoItem"];

sddp/src/model/DescribeEventTopRequest.cc

@@ -1,216 +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/sddp/model/DescribeEventTopRequest.h>
-
-using AlibabaCloud::Sddp::Model::DescribeEventTopRequest;
-
-DescribeEventTopRequest::DescribeEventTopRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "DescribeEventTop")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeEventTopRequest::~DescribeEventTopRequest()
-{}
-
-std::string DescribeEventTopRequest::getProductCode()const
-{
-	return productCode_;
-}
-
-void DescribeEventTopRequest::setProductCode(const std::string& productCode)
-{
-	productCode_ = productCode;
-	setParameter("ProductCode", productCode);
-}
-
-std::string DescribeEventTopRequest::getStartTime()const
-{
-	return startTime_;
-}
-
-void DescribeEventTopRequest::setStartTime(const std::string& startTime)
-{
-	startTime_ = startTime;
-	setParameter("StartTime", startTime);
-}
-
-long DescribeEventTopRequest::getUserId()const
-{
-	return userId_;
-}
-
-void DescribeEventTopRequest::setUserId(long userId)
-{
-	userId_ = userId;
-	setParameter("UserId", std::to_string(userId));
-}
-
-std::string DescribeEventTopRequest::getTypeCode()const
-{
-	return typeCode_;
-}
-
-void DescribeEventTopRequest::setTypeCode(const std::string& typeCode)
-{
-	typeCode_ = typeCode;
-	setParameter("TypeCode", typeCode);
-}
-
-std::string DescribeEventTopRequest::getSubTypeCode()const
-{
-	return subTypeCode_;
-}
-
-void DescribeEventTopRequest::setSubTypeCode(const std::string& subTypeCode)
-{
-	subTypeCode_ = subTypeCode;
-	setParameter("SubTypeCode", subTypeCode);
-}
-
-std::string DescribeEventTopRequest::getSourceIp()const
-{
-	return sourceIp_;
-}
-
-void DescribeEventTopRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
-}
-
-std::string DescribeEventTopRequest::getTargetProductCode()const
-{
-	return targetProductCode_;
-}
-
-void DescribeEventTopRequest::setTargetProductCode(const std::string& targetProductCode)
-{
-	targetProductCode_ = targetProductCode;
-	setParameter("TargetProductCode", targetProductCode);
-}
-
-int DescribeEventTopRequest::getPageSize()const
-{
-	return pageSize_;
-}
-
-void DescribeEventTopRequest::setPageSize(int pageSize)
-{
-	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
-}
-
-std::string DescribeEventTopRequest::getLang()const
-{
-	return lang_;
-}
-
-void DescribeEventTopRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
-}
-
-std::string DescribeEventTopRequest::getDealUserId()const
-{
-	return dealUserId_;
-}
-
-void DescribeEventTopRequest::setDealUserId(const std::string& dealUserId)
-{
-	dealUserId_ = dealUserId;
-	setParameter("DealUserId", dealUserId);
-}
-
-int DescribeEventTopRequest::getFeatureType()const
-{
-	return featureType_;
-}
-
-void DescribeEventTopRequest::setFeatureType(int featureType)
-{
-	featureType_ = featureType;
-	setParameter("FeatureType", std::to_string(featureType));
-}
-
-std::string DescribeEventTopRequest::getEndTime()const
-{
-	return endTime_;
-}
-
-void DescribeEventTopRequest::setEndTime(const std::string& endTime)
-{
-	endTime_ = endTime;
-	setParameter("EndTime", endTime);
-}
-
-int DescribeEventTopRequest::getCurrentPage()const
-{
-	return currentPage_;
-}
-
-void DescribeEventTopRequest::setCurrentPage(int currentPage)
-{
-	currentPage_ = currentPage;
-	setParameter("CurrentPage", std::to_string(currentPage));
-}
-
-std::string DescribeEventTopRequest::getInstanceName()const
-{
-	return instanceName_;
-}
-
-void DescribeEventTopRequest::setInstanceName(const std::string& instanceName)
-{
-	instanceName_ = instanceName;
-	setParameter("InstanceName", instanceName);
-}
-
-long DescribeEventTopRequest::getDepartId()const
-{
-	return departId_;
-}
-
-void DescribeEventTopRequest::setDepartId(long departId)
-{
-	departId_ = departId;
-	setParameter("DepartId", std::to_string(departId));
-}
-
-std::string DescribeEventTopRequest::getStatus()const
-{
-	return status_;
-}
-
-void DescribeEventTopRequest::setStatus(const std::string& status)
-{
-	status_ = status;
-	setParameter("Status", status);
-}
-
-std::string DescribeEventTopRequest::getUserName()const
-{
-	return userName_;
-}
-
-void DescribeEventTopRequest::setUserName(const std::string& userName)
-{
-	userName_ = userName;
-	setParameter("UserName", userName);
-}
-

sddp/src/model/DescribeEventTopResult.cc

@@ -1,67 +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/sddp/model/DescribeEventTopResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Sddp;
-using namespace AlibabaCloud::Sddp::Model;
-
-DescribeEventTopResult::DescribeEventTopResult() :
-	ServiceResult()
-{}
-
-DescribeEventTopResult::DescribeEventTopResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-DescribeEventTopResult::~DescribeEventTopResult()
-{}
-
-void DescribeEventTopResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto allDataCountListNode = value["DataCountList"]["DataCount"];
-	for (auto valueDataCountListDataCount : allDataCountListNode)
-	{
-		DataCount dataCountListObject;
-		if(!valueDataCountListDataCount["EventName"].isNull())
-			dataCountListObject.eventName = valueDataCountListDataCount["EventName"].asString();
-		if(!valueDataCountListDataCount["InstanceName"].isNull())
-			dataCountListObject.instanceName = valueDataCountListDataCount["InstanceName"].asString();
-		if(!valueDataCountListDataCount["ProductCode"].isNull())
-			dataCountListObject.productCode = valueDataCountListDataCount["ProductCode"].asString();
-		if(!valueDataCountListDataCount["UserName"].isNull())
-			dataCountListObject.userName = valueDataCountListDataCount["UserName"].asString();
-		if(!valueDataCountListDataCount["RemoteIp"].isNull())
-			dataCountListObject.remoteIp = valueDataCountListDataCount["RemoteIp"].asString();
-		if(!valueDataCountListDataCount["Id"].isNull())
-			dataCountListObject.id = std::stol(valueDataCountListDataCount["Id"].asString());
-		dataCountList_.push_back(dataCountListObject);
-	}
-
-}
-
-std::vector<DescribeEventTopResult::DataCount> DescribeEventTopResult::getDataCountList()const
-{
-	return dataCountList_;
-}
-

sddp/src/model/DescribeEventTypesDetailRequest.cc

@@ -1,62 +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/sddp/model/DescribeEventTypesDetailRequest.h>
-
-using AlibabaCloud::Sddp::Model::DescribeEventTypesDetailRequest;
-
-DescribeEventTypesDetailRequest::DescribeEventTypesDetailRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "DescribeEventTypesDetail")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeEventTypesDetailRequest::~DescribeEventTypesDetailRequest()
-{}
-
-std::string DescribeEventTypesDetailRequest::getCode()const
-{
-	return code_;
-}
-
-void DescribeEventTypesDetailRequest::setCode(const std::string& code)
-{
-	code_ = code;
-	setParameter("Code", code);
-}
-
-std::string DescribeEventTypesDetailRequest::getSourceIp()const
-{
-	return sourceIp_;
-}
-
-void DescribeEventTypesDetailRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
-}
-
-std::string DescribeEventTypesDetailRequest::getLang()const
-{
-	return lang_;
-}
-
-void DescribeEventTypesDetailRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
-}
-

sddp/src/model/DescribeEventTypesDetailResult.cc

@@ -1,88 +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/sddp/model/DescribeEventTypesDetailResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Sddp;
-using namespace AlibabaCloud::Sddp::Model;
-
-DescribeEventTypesDetailResult::DescribeEventTypesDetailResult() :
-	ServiceResult()
-{}
-
-DescribeEventTypesDetailResult::DescribeEventTypesDetailResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-DescribeEventTypesDetailResult::~DescribeEventTypesDetailResult()
-{}
-
-void DescribeEventTypesDetailResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto userStatusNode = value["UserStatus"];
-	if(!userStatusNode["Name"].isNull())
-		userStatus_.name = userStatusNode["Name"].asString();
-	if(!userStatusNode["Code"].isNull())
-		userStatus_.code = userStatusNode["Code"].asString();
-	if(!userStatusNode["Description"].isNull())
-		userStatus_.description = userStatusNode["Description"].asString();
-	if(!userStatusNode["ParentTypeId"].isNull())
-		userStatus_.parentTypeId = std::stol(userStatusNode["ParentTypeId"].asString());
-	if(!userStatusNode["ParentTypeName"].isNull())
-		userStatus_.parentTypeName = userStatusNode["ParentTypeName"].asString();
-	if(!userStatusNode["RiskLevel"].isNull())
-		userStatus_.riskLevel = std::stoi(userStatusNode["RiskLevel"].asString());
-	if(!userStatusNode["RiskName"].isNull())
-		userStatus_.riskName = userStatusNode["RiskName"].asString();
-	if(!userStatusNode["Status"].isNull())
-		userStatus_.status = std::stoi(userStatusNode["Status"].asString());
-	if(!userStatusNode["EventHitCount"].isNull())
-		userStatus_.eventHitCount = std::stoi(userStatusNode["EventHitCount"].asString());
-	if(!userStatusNode["AccessCount"].isNull())
-		userStatus_.accessCount = std::stoi(userStatusNode["AccessCount"].asString());
-	if(!userStatusNode["DescEvent"].isNull())
-		userStatus_.descEvent = userStatusNode["DescEvent"].asString();
-	if(!userStatusNode["DescModel"].isNull())
-		userStatus_.descModel = userStatusNode["DescModel"].asString();
-	if(!userStatusNode["DealSuggestion"].isNull())
-		userStatus_.dealSuggestion = userStatusNode["DealSuggestion"].asString();
-	if(!userStatusNode["RiskEvent"].isNull())
-		userStatus_.riskEvent = userStatusNode["RiskEvent"].asString();
-	if(!userStatusNode["AdaptedProduct"].isNull())
-		userStatus_.adaptedProduct = userStatusNode["AdaptedProduct"].asString();
-	if(!userStatusNode["ConfigCode"].isNull())
-		userStatus_.configCode = userStatusNode["ConfigCode"].asString();
-	if(!userStatusNode["ConfigContentType"].isNull())
-		userStatus_.configContentType = std::stoi(userStatusNode["ConfigContentType"].asString());
-	if(!userStatusNode["ConfigDescription"].isNull())
-		userStatus_.configDescription = userStatusNode["ConfigDescription"].asString();
-	if(!userStatusNode["ConfigValue"].isNull())
-		userStatus_.configValue = userStatusNode["ConfigValue"].asString();
-
-}
-
-DescribeEventTypesDetailResult::UserStatus DescribeEventTypesDetailResult::getUserStatus()const
-{
-	return userStatus_;
-}
-

sddp/src/model/DescribeEventTypesRequest.cc

@@ -1,84 +1,72 @@
 /*
  * 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/sddp/model/DescribeEventTypesRequest.h>
-
-using AlibabaCloud::Sddp::Model::DescribeEventTypesRequest;
-
-DescribeEventTypesRequest::DescribeEventTypesRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "DescribeEventTypes")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeEventTypesRequest::~DescribeEventTypesRequest()
-{}
-
-int DescribeEventTypesRequest::getResourceId()const
-{
-	return resourceId_;
+ */
+
+#include <alibabacloud/sddp/model/DescribeEventTypesRequest.h>
+
+using AlibabaCloud::Sddp::Model::DescribeEventTypesRequest;
+
+DescribeEventTypesRequest::DescribeEventTypesRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "DescribeEventTypes") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeEventTypesRequest::setResourceId(int resourceId)
-{
-	resourceId_ = resourceId;
-	setParameter("ResourceId", std::to_string(resourceId));
+DescribeEventTypesRequest::~DescribeEventTypesRequest() {}
+
+int DescribeEventTypesRequest::getResourceId() const {
+  return resourceId_;
 }
 
-long DescribeEventTypesRequest::getParentTypeId()const
-{
-	return parentTypeId_;
+void DescribeEventTypesRequest::setResourceId(int resourceId) {
+  resourceId_ = resourceId;
+  setParameter(std::string("ResourceId"), std::to_string(resourceId));
 }
 
-void DescribeEventTypesRequest::setParentTypeId(long parentTypeId)
-{
-	parentTypeId_ = parentTypeId;
-	setParameter("ParentTypeId", std::to_string(parentTypeId));
+long DescribeEventTypesRequest::getParentTypeId() const {
+  return parentTypeId_;
 }
 
-std::string DescribeEventTypesRequest::getSourceIp()const
-{
-	return sourceIp_;
+void DescribeEventTypesRequest::setParentTypeId(long parentTypeId) {
+  parentTypeId_ = parentTypeId;
+  setParameter(std::string("ParentTypeId"), std::to_string(parentTypeId));
 }
 
-void DescribeEventTypesRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+std::string DescribeEventTypesRequest::getSourceIp() const {
+  return sourceIp_;
 }
 
-std::string DescribeEventTypesRequest::getLang()const
-{
-	return lang_;
+void DescribeEventTypesRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
 }
 
-void DescribeEventTypesRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
+std::string DescribeEventTypesRequest::getLang() const {
+  return lang_;
 }
 
-int DescribeEventTypesRequest::getStatus()const
-{
-	return status_;
+void DescribeEventTypesRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 
-void DescribeEventTypesRequest::setStatus(int status)
-{
-	status_ = status;
-	setParameter("Status", std::to_string(status));
+int DescribeEventTypesRequest::getStatus() const {
+  return status_;
+}
+
+void DescribeEventTypesRequest::setStatus(int status) {
+  status_ = status;
+  setParameter(std::string("Status"), std::to_string(status));
 }
 

sddp/src/model/DescribeEventTypesResult.cc

@@ -43,40 +43,40 @@ void DescribeEventTypesResult::parse(const std::string &payload)
 	for (auto valueEventTypeListEventType : allEventTypeListNode)
 	{
 		EventType eventTypeListObject;
-		if(!valueEventTypeListEventType["Id"].isNull())
-			eventTypeListObject.id = std::stol(valueEventTypeListEventType["Id"].asString());
-		if(!valueEventTypeListEventType["Name"].isNull())
-			eventTypeListObject.name = valueEventTypeListEventType["Name"].asString();
 		if(!valueEventTypeListEventType["Code"].isNull())
 			eventTypeListObject.code = valueEventTypeListEventType["Code"].asString();
 		if(!valueEventTypeListEventType["Description"].isNull())
 			eventTypeListObject.description = valueEventTypeListEventType["Description"].asString();
+		if(!valueEventTypeListEventType["Name"].isNull())
+			eventTypeListObject.name = valueEventTypeListEventType["Name"].asString();
+		if(!valueEventTypeListEventType["Id"].isNull())
+			eventTypeListObject.id = std::stol(valueEventTypeListEventType["Id"].asString());
 		auto allSubTypeListNode = valueEventTypeListEventType["SubTypeList"]["SubType"];
 		for (auto valueEventTypeListEventTypeSubTypeListSubType : allSubTypeListNode)
 		{
 			EventType::SubType subTypeListObject;
-			if(!valueEventTypeListEventTypeSubTypeListSubType["Id"].isNull())
-				subTypeListObject.id = std::stol(valueEventTypeListEventTypeSubTypeListSubType["Id"].asString());
-			if(!valueEventTypeListEventTypeSubTypeListSubType["Name"].isNull())
-				subTypeListObject.name = valueEventTypeListEventTypeSubTypeListSubType["Name"].asString();
-			if(!valueEventTypeListEventTypeSubTypeListSubType["Code"].isNull())
-				subTypeListObject.code = valueEventTypeListEventTypeSubTypeListSubType["Code"].asString();
-			if(!valueEventTypeListEventTypeSubTypeListSubType["Description"].isNull())
-				subTypeListObject.description = valueEventTypeListEventTypeSubTypeListSubType["Description"].asString();
 			if(!valueEventTypeListEventTypeSubTypeListSubType["Status"].isNull())
 				subTypeListObject.status = std::stoi(valueEventTypeListEventTypeSubTypeListSubType["Status"].asString());
-			if(!valueEventTypeListEventTypeSubTypeListSubType["EventHitCount"].isNull())
-				subTypeListObject.eventHitCount = std::stoi(valueEventTypeListEventTypeSubTypeListSubType["EventHitCount"].asString());
-			if(!valueEventTypeListEventTypeSubTypeListSubType["AdaptedProduct"].isNull())
-				subTypeListObject.adaptedProduct = valueEventTypeListEventTypeSubTypeListSubType["AdaptedProduct"].asString();
-			if(!valueEventTypeListEventTypeSubTypeListSubType["ConfigCode"].isNull())
-				subTypeListObject.configCode = valueEventTypeListEventTypeSubTypeListSubType["ConfigCode"].asString();
+			if(!valueEventTypeListEventTypeSubTypeListSubType["Description"].isNull())
+				subTypeListObject.description = valueEventTypeListEventTypeSubTypeListSubType["Description"].asString();
 			if(!valueEventTypeListEventTypeSubTypeListSubType["ConfigContentType"].isNull())
 				subTypeListObject.configContentType = std::stoi(valueEventTypeListEventTypeSubTypeListSubType["ConfigContentType"].asString());
-			if(!valueEventTypeListEventTypeSubTypeListSubType["ConfigDescription"].isNull())
-				subTypeListObject.configDescription = valueEventTypeListEventTypeSubTypeListSubType["ConfigDescription"].asString();
+			if(!valueEventTypeListEventTypeSubTypeListSubType["EventHitCount"].isNull())
+				subTypeListObject.eventHitCount = std::stoi(valueEventTypeListEventTypeSubTypeListSubType["EventHitCount"].asString());
 			if(!valueEventTypeListEventTypeSubTypeListSubType["ConfigValue"].isNull())
 				subTypeListObject.configValue = valueEventTypeListEventTypeSubTypeListSubType["ConfigValue"].asString();
+			if(!valueEventTypeListEventTypeSubTypeListSubType["ConfigCode"].isNull())
+				subTypeListObject.configCode = valueEventTypeListEventTypeSubTypeListSubType["ConfigCode"].asString();
+			if(!valueEventTypeListEventTypeSubTypeListSubType["Code"].isNull())
+				subTypeListObject.code = valueEventTypeListEventTypeSubTypeListSubType["Code"].asString();
+			if(!valueEventTypeListEventTypeSubTypeListSubType["ConfigDescription"].isNull())
+				subTypeListObject.configDescription = valueEventTypeListEventTypeSubTypeListSubType["ConfigDescription"].asString();
+			if(!valueEventTypeListEventTypeSubTypeListSubType["Name"].isNull())
+				subTypeListObject.name = valueEventTypeListEventTypeSubTypeListSubType["Name"].asString();
+			if(!valueEventTypeListEventTypeSubTypeListSubType["AdaptedProduct"].isNull())
+				subTypeListObject.adaptedProduct = valueEventTypeListEventTypeSubTypeListSubType["AdaptedProduct"].asString();
+			if(!valueEventTypeListEventTypeSubTypeListSubType["Id"].isNull())
+				subTypeListObject.id = std::stol(valueEventTypeListEventTypeSubTypeListSubType["Id"].asString());
 			eventTypeListObject.subTypeList.push_back(subTypeListObject);
 		}
 		eventTypeList_.push_back(eventTypeListObject);

sddp/src/model/DescribeEventsRequest.cc

@@ -1,227 +1,189 @@
 /*
  * 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/sddp/model/DescribeEventsRequest.h>
-
-using AlibabaCloud::Sddp::Model::DescribeEventsRequest;
-
-DescribeEventsRequest::DescribeEventsRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "DescribeEvents")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeEventsRequest::~DescribeEventsRequest()
-{}
-
-std::string DescribeEventsRequest::getProductCode()const
-{
-	return productCode_;
+ */
+
+#include <alibabacloud/sddp/model/DescribeEventsRequest.h>
+
+using AlibabaCloud::Sddp::Model::DescribeEventsRequest;
+
+DescribeEventsRequest::DescribeEventsRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "DescribeEvents") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeEventsRequest::setProductCode(const std::string& productCode)
-{
-	productCode_ = productCode;
-	setParameter("ProductCode", productCode);
+DescribeEventsRequest::~DescribeEventsRequest() {}
+
+std::string DescribeEventsRequest::getProductCode() const {
+  return productCode_;
 }
 
-std::string DescribeEventsRequest::getStartTime()const
-{
-	return startTime_;
+void DescribeEventsRequest::setProductCode(const std::string &productCode) {
+  productCode_ = productCode;
+  setParameter(std::string("ProductCode"), productCode);
 }
 
-void DescribeEventsRequest::setStartTime(const std::string& startTime)
-{
-	startTime_ = startTime;
-	setParameter("StartTime", startTime);
+std::string DescribeEventsRequest::getStartTime() const {
+  return startTime_;
 }
 
-long DescribeEventsRequest::getUserId()const
-{
-	return userId_;
+void DescribeEventsRequest::setStartTime(const std::string &startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), startTime);
 }
 
-void DescribeEventsRequest::setUserId(long userId)
-{
-	userId_ = userId;
-	setParameter("UserId", std::to_string(userId));
+long DescribeEventsRequest::getUserId() const {
+  return userId_;
 }
 
-std::string DescribeEventsRequest::getTypeCode()const
-{
-	return typeCode_;
+void DescribeEventsRequest::setUserId(long userId) {
+  userId_ = userId;
+  setParameter(std::string("UserId"), std::to_string(userId));
 }
 
-void DescribeEventsRequest::setTypeCode(const std::string& typeCode)
-{
-	typeCode_ = typeCode;
-	setParameter("TypeCode", typeCode);
+std::string DescribeEventsRequest::getTypeCode() const {
+  return typeCode_;
 }
 
-std::string DescribeEventsRequest::getSubTypeCode()const
-{
-	return subTypeCode_;
+void DescribeEventsRequest::setTypeCode(const std::string &typeCode) {
+  typeCode_ = typeCode;
+  setParameter(std::string("TypeCode"), typeCode);
 }
 
-void DescribeEventsRequest::setSubTypeCode(const std::string& subTypeCode)
-{
-	subTypeCode_ = subTypeCode;
-	setParameter("SubTypeCode", subTypeCode);
+std::string DescribeEventsRequest::getSubTypeCode() const {
+  return subTypeCode_;
 }
 
-std::string DescribeEventsRequest::getSourceIp()const
-{
-	return sourceIp_;
+void DescribeEventsRequest::setSubTypeCode(const std::string &subTypeCode) {
+  subTypeCode_ = subTypeCode;
+  setParameter(std::string("SubTypeCode"), subTypeCode);
 }
 
-void DescribeEventsRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+std::string DescribeEventsRequest::getSourceIp() const {
+  return sourceIp_;
 }
 
-std::string DescribeEventsRequest::getTargetProductCode()const
-{
-	return targetProductCode_;
+void DescribeEventsRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
 }
 
-void DescribeEventsRequest::setTargetProductCode(const std::string& targetProductCode)
-{
-	targetProductCode_ = targetProductCode;
-	setParameter("TargetProductCode", targetProductCode);
+std::string DescribeEventsRequest::getTargetProductCode() const {
+  return targetProductCode_;
 }
 
-int DescribeEventsRequest::getPageSize()const
-{
-	return pageSize_;
+void DescribeEventsRequest::setTargetProductCode(const std::string &targetProductCode) {
+  targetProductCode_ = targetProductCode;
+  setParameter(std::string("TargetProductCode"), targetProductCode);
 }
 
-void DescribeEventsRequest::setPageSize(int pageSize)
-{
-	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
+int DescribeEventsRequest::getPageSize() const {
+  return pageSize_;
 }
 
-long DescribeEventsRequest::getId()const
-{
-	return id_;
+void DescribeEventsRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
 }
 
-void DescribeEventsRequest::setId(long id)
-{
-	id_ = id;
-	setParameter("Id", std::to_string(id));
+long DescribeEventsRequest::getId() const {
+  return id_;
 }
 
-std::string DescribeEventsRequest::getLang()const
-{
-	return lang_;
+void DescribeEventsRequest::setId(long id) {
+  id_ = id;
+  setParameter(std::string("Id"), std::to_string(id));
 }
 
-void DescribeEventsRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
+std::string DescribeEventsRequest::getLang() const {
+  return lang_;
 }
 
-std::string DescribeEventsRequest::getDealUserId()const
-{
-	return dealUserId_;
+void DescribeEventsRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 
-void DescribeEventsRequest::setDealUserId(const std::string& dealUserId)
-{
-	dealUserId_ = dealUserId;
-	setParameter("DealUserId", dealUserId);
+std::string DescribeEventsRequest::getDealUserId() const {
+  return dealUserId_;
 }
 
-int DescribeEventsRequest::getFeatureType()const
-{
-	return featureType_;
+void DescribeEventsRequest::setDealUserId(const std::string &dealUserId) {
+  dealUserId_ = dealUserId;
+  setParameter(std::string("DealUserId"), dealUserId);
 }
 
-void DescribeEventsRequest::setFeatureType(int featureType)
-{
-	featureType_ = featureType;
-	setParameter("FeatureType", std::to_string(featureType));
+int DescribeEventsRequest::getFeatureType() const {
+  return featureType_;
 }
 
-std::string DescribeEventsRequest::getEndTime()const
-{
-	return endTime_;
+void DescribeEventsRequest::setFeatureType(int featureType) {
+  featureType_ = featureType;
+  setParameter(std::string("FeatureType"), std::to_string(featureType));
 }
 
-void DescribeEventsRequest::setEndTime(const std::string& endTime)
-{
-	endTime_ = endTime;
-	setParameter("EndTime", endTime);
+std::string DescribeEventsRequest::getEndTime() const {
+  return endTime_;
 }
 
-int DescribeEventsRequest::getCurrentPage()const
-{
-	return currentPage_;
+void DescribeEventsRequest::setEndTime(const std::string &endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), endTime);
 }
 
-void DescribeEventsRequest::setCurrentPage(int currentPage)
-{
-	currentPage_ = currentPage;
-	setParameter("CurrentPage", std::to_string(currentPage));
+int DescribeEventsRequest::getCurrentPage() const {
+  return currentPage_;
 }
 
-std::string DescribeEventsRequest::getInstanceName()const
-{
-	return instanceName_;
+void DescribeEventsRequest::setCurrentPage(int currentPage) {
+  currentPage_ = currentPage;
+  setParameter(std::string("CurrentPage"), std::to_string(currentPage));
 }
 
-void DescribeEventsRequest::setInstanceName(const std::string& instanceName)
-{
-	instanceName_ = instanceName;
-	setParameter("InstanceName", instanceName);
+std::string DescribeEventsRequest::getInstanceName() const {
+  return instanceName_;
 }
 
-long DescribeEventsRequest::getDepartId()const
-{
-	return departId_;
+void DescribeEventsRequest::setInstanceName(const std::string &instanceName) {
+  instanceName_ = instanceName;
+  setParameter(std::string("InstanceName"), instanceName);
 }
 
-void DescribeEventsRequest::setDepartId(long departId)
-{
-	departId_ = departId;
-	setParameter("DepartId", std::to_string(departId));
+long DescribeEventsRequest::getDepartId() const {
+  return departId_;
 }
 
-std::string DescribeEventsRequest::getStatus()const
-{
-	return status_;
+void DescribeEventsRequest::setDepartId(long departId) {
+  departId_ = departId;
+  setParameter(std::string("DepartId"), std::to_string(departId));
 }
 
-void DescribeEventsRequest::setStatus(const std::string& status)
-{
-	status_ = status;
-	setParameter("Status", status);
+std::string DescribeEventsRequest::getStatus() const {
+  return status_;
 }
 
-std::string DescribeEventsRequest::getUserName()const
-{
-	return userName_;
+void DescribeEventsRequest::setStatus(const std::string &status) {
+  status_ = status;
+  setParameter(std::string("Status"), status);
 }
 
-void DescribeEventsRequest::setUserName(const std::string& userName)
-{
-	userName_ = userName;
-	setParameter("UserName", userName);
+std::string DescribeEventsRequest::getUserName() const {
+  return userName_;
+}
+
+void DescribeEventsRequest::setUserName(const std::string &userName) {
+  userName_ = userName;
+  setParameter(std::string("UserName"), userName);
 }
 

sddp/src/model/DescribeEventsResult.cc

@@ -43,60 +43,60 @@ void DescribeEventsResult::parse(const std::string &payload)
 	for (auto valueItemsEvent : allItemsNode)
 	{
 		Event itemsObject;
-		if(!valueItemsEvent["Id"].isNull())
-			itemsObject.id = std::stol(valueItemsEvent["Id"].asString());
-		if(!valueItemsEvent["UserId"].isNull())
-			itemsObject.userId = std::stol(valueItemsEvent["UserId"].asString());
-		if(!valueItemsEvent["LoginName"].isNull())
-			itemsObject.loginName = valueItemsEvent["LoginName"].asString();
 		if(!valueItemsEvent["DisplayName"].isNull())
 			itemsObject.displayName = valueItemsEvent["DisplayName"].asString();
-		if(!valueItemsEvent["ProductCode"].isNull())
-			itemsObject.productCode = valueItemsEvent["ProductCode"].asString();
-		if(!valueItemsEvent["TargetProductCode"].isNull())
-			itemsObject.targetProductCode = valueItemsEvent["TargetProductCode"].asString();
-		if(!valueItemsEvent["TypeCode"].isNull())
-			itemsObject.typeCode = valueItemsEvent["TypeCode"].asString();
-		if(!valueItemsEvent["TypeName"].isNull())
-			itemsObject.typeName = valueItemsEvent["TypeName"].asString();
-		if(!valueItemsEvent["SubTypeCode"].isNull())
-			itemsObject.subTypeCode = valueItemsEvent["SubTypeCode"].asString();
-		if(!valueItemsEvent["SubTypeName"].isNull())
-			itemsObject.subTypeName = valueItemsEvent["SubTypeName"].asString();
-		if(!valueItemsEvent["AlertTime"].isNull())
-			itemsObject.alertTime = std::stol(valueItemsEvent["AlertTime"].asString());
-		if(!valueItemsEvent["EventTime"].isNull())
-			itemsObject.eventTime = std::stol(valueItemsEvent["EventTime"].asString());
 		if(!valueItemsEvent["Status"].isNull())
 			itemsObject.status = std::stoi(valueItemsEvent["Status"].asString());
+		if(!valueItemsEvent["WarnLevel"].isNull())
+			itemsObject.warnLevel = std::stoi(valueItemsEvent["WarnLevel"].asString());
+		if(!valueItemsEvent["UserId"].isNull())
+			itemsObject.userId = std::stol(valueItemsEvent["UserId"].asString());
 		if(!valueItemsEvent["StatusName"].isNull())
 			itemsObject.statusName = valueItemsEvent["StatusName"].asString();
-		if(!valueItemsEvent["DealUserId"].isNull())
-			itemsObject.dealUserId = std::stol(valueItemsEvent["DealUserId"].asString());
-		if(!valueItemsEvent["DealLoginName"].isNull())
-			itemsObject.dealLoginName = valueItemsEvent["DealLoginName"].asString();
-		if(!valueItemsEvent["DealDisplayName"].isNull())
-			itemsObject.dealDisplayName = valueItemsEvent["DealDisplayName"].asString();
-		if(!valueItemsEvent["DealTime"].isNull())
-			itemsObject.dealTime = std::stol(valueItemsEvent["DealTime"].asString());
 		if(!valueItemsEvent["DepartName"].isNull())
 			itemsObject.departName = valueItemsEvent["DepartName"].asString();
+		if(!valueItemsEvent["DealUserIdValue"].isNull())
+			itemsObject.dealUserIdValue = valueItemsEvent["DealUserIdValue"].asString();
+		if(!valueItemsEvent["DealTime"].isNull())
+			itemsObject.dealTime = std::stol(valueItemsEvent["DealTime"].asString());
+		if(!valueItemsEvent["DealLoginName"].isNull())
+			itemsObject.dealLoginName = valueItemsEvent["DealLoginName"].asString();
+		if(!valueItemsEvent["SubTypeName"].isNull())
+			itemsObject.subTypeName = valueItemsEvent["SubTypeName"].asString();
 		if(!valueItemsEvent["Backed"].isNull())
 			itemsObject.backed = valueItemsEvent["Backed"].asString() == "true";
 		if(!valueItemsEvent["InstanceName"].isNull())
 			itemsObject.instanceName = valueItemsEvent["InstanceName"].asString();
+		if(!valueItemsEvent["EventTime"].isNull())
+			itemsObject.eventTime = std::stol(valueItemsEvent["EventTime"].asString());
+		if(!valueItemsEvent["LoginName"].isNull())
+			itemsObject.loginName = valueItemsEvent["LoginName"].asString();
 		if(!valueItemsEvent["UserIdValue"].isNull())
 			itemsObject.userIdValue = valueItemsEvent["UserIdValue"].asString();
-		if(!valueItemsEvent["DealUserIdValue"].isNull())
-			itemsObject.dealUserIdValue = valueItemsEvent["DealUserIdValue"].asString();
-		if(!valueItemsEvent["WarnLevel"].isNull())
-			itemsObject.warnLevel = std::stoi(valueItemsEvent["WarnLevel"].asString());
+		if(!valueItemsEvent["SubTypeCode"].isNull())
+			itemsObject.subTypeCode = valueItemsEvent["SubTypeCode"].asString();
+		if(!valueItemsEvent["TargetProductCode"].isNull())
+			itemsObject.targetProductCode = valueItemsEvent["TargetProductCode"].asString();
+		if(!valueItemsEvent["TypeCode"].isNull())
+			itemsObject.typeCode = valueItemsEvent["TypeCode"].asString();
+		if(!valueItemsEvent["AlertTime"].isNull())
+			itemsObject.alertTime = std::stol(valueItemsEvent["AlertTime"].asString());
+		if(!valueItemsEvent["DealUserId"].isNull())
+			itemsObject.dealUserId = std::stol(valueItemsEvent["DealUserId"].asString());
+		if(!valueItemsEvent["TypeName"].isNull())
+			itemsObject.typeName = valueItemsEvent["TypeName"].asString();
+		if(!valueItemsEvent["DealDisplayName"].isNull())
+			itemsObject.dealDisplayName = valueItemsEvent["DealDisplayName"].asString();
+		if(!valueItemsEvent["Id"].isNull())
+			itemsObject.id = std::stol(valueItemsEvent["Id"].asString());
+		if(!valueItemsEvent["ProductCode"].isNull())
+			itemsObject.productCode = valueItemsEvent["ProductCode"].asString();
 		items_.push_back(itemsObject);
 	}
-	if(!value["PageSize"].isNull())
-		pageSize_ = std::stoi(value["PageSize"].asString());
 	if(!value["CurrentPage"].isNull())
 		currentPage_ = std::stoi(value["CurrentPage"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
 	if(!value["TotalCount"].isNull())
 		totalCount_ = std::stoi(value["TotalCount"].asString());
 

sddp/src/model/DescribeInstancePortraitRequest.cc

@@ -1,73 +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/sddp/model/DescribeInstancePortraitRequest.h>
-
-using AlibabaCloud::Sddp::Model::DescribeInstancePortraitRequest;
-
-DescribeInstancePortraitRequest::DescribeInstancePortraitRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "DescribeInstancePortrait")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeInstancePortraitRequest::~DescribeInstancePortraitRequest()
-{}
-
-long DescribeInstancePortraitRequest::getProductId()const
-{
-	return productId_;
-}
-
-void DescribeInstancePortraitRequest::setProductId(long productId)
-{
-	productId_ = productId;
-	setParameter("ProductId", std::to_string(productId));
-}
-
-std::string DescribeInstancePortraitRequest::getSourceIp()const
-{
-	return sourceIp_;
-}
-
-void DescribeInstancePortraitRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
-}
-
-long DescribeInstancePortraitRequest::getInstanceId()const
-{
-	return instanceId_;
-}
-
-void DescribeInstancePortraitRequest::setInstanceId(long instanceId)
-{
-	instanceId_ = instanceId;
-	setParameter("InstanceId", std::to_string(instanceId));
-}
-
-std::string DescribeInstancePortraitRequest::getItemKeys()const
-{
-	return itemKeys_;
-}
-
-void DescribeInstancePortraitRequest::setItemKeys(const std::string& itemKeys)
-{
-	itemKeys_ = itemKeys;
-	setParameter("ItemKeys", itemKeys);
-}
-

sddp/src/model/DescribeInstancePortraitResult.cc

@@ -1,59 +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/sddp/model/DescribeInstancePortraitResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Sddp;
-using namespace AlibabaCloud::Sddp::Model;
-
-DescribeInstancePortraitResult::DescribeInstancePortraitResult() :
-	ServiceResult()
-{}
-
-DescribeInstancePortraitResult::DescribeInstancePortraitResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-DescribeInstancePortraitResult::~DescribeInstancePortraitResult()
-{}
-
-void DescribeInstancePortraitResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto allContentNode = value["Content"]["InstancePortrait"];
-	for (auto valueContentInstancePortrait : allContentNode)
-	{
-		InstancePortrait contentObject;
-		if(!valueContentInstancePortrait["ItemKey"].isNull())
-			contentObject.itemKey = valueContentInstancePortrait["ItemKey"].asString();
-		if(!valueContentInstancePortrait["Content"].isNull())
-			contentObject.content = valueContentInstancePortrait["Content"].asString();
-		content_.push_back(contentObject);
-	}
-
-}
-
-std::vector<DescribeInstancePortraitResult::InstancePortrait> DescribeInstancePortraitResult::getContent()const
-{
-	return content_;
-}
-

sddp/src/model/DescribeInstanceSourcesRequest.cc

@@ -1,139 +1,162 @@
 /*
  * 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/sddp/model/DescribeInstanceSourcesRequest.h>
-
-using AlibabaCloud::Sddp::Model::DescribeInstanceSourcesRequest;
-
-DescribeInstanceSourcesRequest::DescribeInstanceSourcesRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "DescribeInstanceSources")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeInstanceSourcesRequest::~DescribeInstanceSourcesRequest()
-{}
-
-long DescribeInstanceSourcesRequest::getProductId()const
-{
-	return productId_;
+ */
+
+#include <alibabacloud/sddp/model/DescribeInstanceSourcesRequest.h>
+
+using AlibabaCloud::Sddp::Model::DescribeInstanceSourcesRequest;
+
+DescribeInstanceSourcesRequest::DescribeInstanceSourcesRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "DescribeInstanceSources") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeInstanceSourcesRequest::setProductId(long productId)
-{
-	productId_ = productId;
-	setParameter("ProductId", std::to_string(productId));
+DescribeInstanceSourcesRequest::~DescribeInstanceSourcesRequest() {}
+
+std::string DescribeInstanceSourcesRequest::getProductCode() const {
+  return productCode_;
 }
 
-std::string DescribeInstanceSourcesRequest::getSourceIp()const
-{
-	return sourceIp_;
+void DescribeInstanceSourcesRequest::setProductCode(const std::string &productCode) {
+  productCode_ = productCode;
+  setParameter(std::string("ProductCode"), productCode);
 }
 
-void DescribeInstanceSourcesRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+long DescribeInstanceSourcesRequest::getProductId() const {
+  return productId_;
 }
 
-int DescribeInstanceSourcesRequest::getPageSize()const
-{
-	return pageSize_;
+void DescribeInstanceSourcesRequest::setProductId(long productId) {
+  productId_ = productId;
+  setParameter(std::string("ProductId"), std::to_string(productId));
 }
 
-void DescribeInstanceSourcesRequest::setPageSize(int pageSize)
-{
-	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
+std::string DescribeInstanceSourcesRequest::getSearchKey() const {
+  return searchKey_;
 }
 
-std::string DescribeInstanceSourcesRequest::getLang()const
-{
-	return lang_;
+void DescribeInstanceSourcesRequest::setSearchKey(const std::string &searchKey) {
+  searchKey_ = searchKey;
+  setParameter(std::string("SearchKey"), searchKey);
 }
 
-void DescribeInstanceSourcesRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
+std::string DescribeInstanceSourcesRequest::getSourceIp() const {
+  return sourceIp_;
 }
 
-std::string DescribeInstanceSourcesRequest::getServiceRegionId()const
-{
-	return serviceRegionId_;
+void DescribeInstanceSourcesRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
 }
 
-void DescribeInstanceSourcesRequest::setServiceRegionId(const std::string& serviceRegionId)
-{
-	serviceRegionId_ = serviceRegionId;
-	setParameter("ServiceRegionId", serviceRegionId);
+std::string DescribeInstanceSourcesRequest::getSearchType() const {
+  return searchType_;
 }
 
-std::string DescribeInstanceSourcesRequest::getEngineType()const
-{
-	return engineType_;
+void DescribeInstanceSourcesRequest::setSearchType(const std::string &searchType) {
+  searchType_ = searchType;
+  setParameter(std::string("SearchType"), searchType);
 }
 
-void DescribeInstanceSourcesRequest::setEngineType(const std::string& engineType)
-{
-	engineType_ = engineType;
-	setParameter("EngineType", engineType);
+int DescribeInstanceSourcesRequest::getPageSize() const {
+  return pageSize_;
 }
 
-int DescribeInstanceSourcesRequest::getCurrentPage()const
-{
-	return currentPage_;
+void DescribeInstanceSourcesRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
 }
 
-void DescribeInstanceSourcesRequest::setCurrentPage(int currentPage)
-{
-	currentPage_ = currentPage;
-	setParameter("CurrentPage", std::to_string(currentPage));
+std::string DescribeInstanceSourcesRequest::getLang() const {
+  return lang_;
 }
 
-bool DescribeInstanceSourcesRequest::getAuthed()const
-{
-	return authed_;
+void DescribeInstanceSourcesRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 
-void DescribeInstanceSourcesRequest::setAuthed(bool authed)
-{
-	authed_ = authed;
-	setParameter("Authed", authed ? "true" : "false");
+std::string DescribeInstanceSourcesRequest::getServiceRegionId() const {
+  return serviceRegionId_;
 }
 
-std::string DescribeInstanceSourcesRequest::getInstanceId()const
-{
-	return instanceId_;
+void DescribeInstanceSourcesRequest::setServiceRegionId(const std::string &serviceRegionId) {
+  serviceRegionId_ = serviceRegionId;
+  setParameter(std::string("ServiceRegionId"), serviceRegionId);
 }
 
-void DescribeInstanceSourcesRequest::setInstanceId(const std::string& instanceId)
-{
-	instanceId_ = instanceId;
-	setParameter("InstanceId", instanceId);
+std::string DescribeInstanceSourcesRequest::getEngineType() const {
+  return engineType_;
 }
 
-std::string DescribeInstanceSourcesRequest::getDbName()const
-{
-	return dbName_;
+void DescribeInstanceSourcesRequest::setEngineType(const std::string &engineType) {
+  engineType_ = engineType;
+  setParameter(std::string("EngineType"), engineType);
 }
 
-void DescribeInstanceSourcesRequest::setDbName(const std::string& dbName)
-{
-	dbName_ = dbName;
-	setParameter("DbName", dbName);
+int DescribeInstanceSourcesRequest::getAuditStatus() const {
+  return auditStatus_;
+}
+
+void DescribeInstanceSourcesRequest::setAuditStatus(int auditStatus) {
+  auditStatus_ = auditStatus;
+  setParameter(std::string("AuditStatus"), std::to_string(auditStatus));
+}
+
+int DescribeInstanceSourcesRequest::getAuthStatus() const {
+  return authStatus_;
+}
+
+void DescribeInstanceSourcesRequest::setAuthStatus(int authStatus) {
+  authStatus_ = authStatus;
+  setParameter(std::string("AuthStatus"), std::to_string(authStatus));
+}
+
+int DescribeInstanceSourcesRequest::getCurrentPage() const {
+  return currentPage_;
+}
+
+void DescribeInstanceSourcesRequest::setCurrentPage(int currentPage) {
+  currentPage_ = currentPage;
+  setParameter(std::string("CurrentPage"), std::to_string(currentPage));
+}
+
+bool DescribeInstanceSourcesRequest::getAuthed() const {
+  return authed_;
+}
+
+void DescribeInstanceSourcesRequest::setAuthed(bool authed) {
+  authed_ = authed;
+  setParameter(std::string("Authed"), authed ? "true" : "false");
+}
+
+std::string DescribeInstanceSourcesRequest::getInstanceId() const {
+  return instanceId_;
+}
+
+void DescribeInstanceSourcesRequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setParameter(std::string("InstanceId"), instanceId);
+}
+
+std::string DescribeInstanceSourcesRequest::getDbName() const {
+  return dbName_;
+}
+
+void DescribeInstanceSourcesRequest::setDbName(const std::string &dbName) {
+  dbName_ = dbName;
+  setParameter(std::string("DbName"), dbName);
 }
 

sddp/src/model/DescribeInstanceSourcesResult.cc

@@ -43,58 +43,64 @@ void DescribeInstanceSourcesResult::parse(const std::string &payload)
 	for (auto valueItemsInstanceSource : allItemsNode)
 	{
 		InstanceSource itemsObject;
-		if(!valueItemsInstanceSource["RegionId"].isNull())
-			itemsObject.regionId = valueItemsInstanceSource["RegionId"].asString();
-		if(!valueItemsInstanceSource["RegionName"].isNull())
-			itemsObject.regionName = valueItemsInstanceSource["RegionName"].asString();
-		if(!valueItemsInstanceSource["InstanceId"].isNull())
-			itemsObject.instanceId = valueItemsInstanceSource["InstanceId"].asString();
-		if(!valueItemsInstanceSource["Id"].isNull())
-			itemsObject.id = std::stol(valueItemsInstanceSource["Id"].asString());
-		if(!valueItemsInstanceSource["UserName"].isNull())
-			itemsObject.userName = valueItemsInstanceSource["UserName"].asString();
-		if(!valueItemsInstanceSource["DbName"].isNull())
-			itemsObject.dbName = valueItemsInstanceSource["DbName"].asString();
-		if(!valueItemsInstanceSource["DataLimitId"].isNull())
-			itemsObject.dataLimitId = std::stol(valueItemsInstanceSource["DataLimitId"].asString());
-		if(!valueItemsInstanceSource["GmtCreate"].isNull())
-			itemsObject.gmtCreate = std::stol(valueItemsInstanceSource["GmtCreate"].asString());
-		if(!valueItemsInstanceSource["ProductId"].isNull())
-			itemsObject.productId = std::stol(valueItemsInstanceSource["ProductId"].asString());
-		if(!valueItemsInstanceSource["AuditStatus"].isNull())
-			itemsObject.auditStatus = std::stoi(valueItemsInstanceSource["AuditStatus"].asString());
-		if(!valueItemsInstanceSource["LogStoreDay"].isNull())
-			itemsObject.logStoreDay = std::stoi(valueItemsInstanceSource["LogStoreDay"].asString());
-		if(!valueItemsInstanceSource["Enable"].isNull())
-			itemsObject.enable = std::stoi(valueItemsInstanceSource["Enable"].asString());
-		if(!valueItemsInstanceSource["AutoScan"].isNull())
-			itemsObject.autoScan = std::stoi(valueItemsInstanceSource["AutoScan"].asString());
-		if(!valueItemsInstanceSource["EngineType"].isNull())
-			itemsObject.engineType = valueItemsInstanceSource["EngineType"].asString();
-		if(!valueItemsInstanceSource["InstanceSize"].isNull())
-			itemsObject.instanceSize = std::stol(valueItemsInstanceSource["InstanceSize"].asString());
-		if(!valueItemsInstanceSource["PasswordStatus"].isNull())
-			itemsObject.passwordStatus = std::stoi(valueItemsInstanceSource["PasswordStatus"].asString());
 		if(!valueItemsInstanceSource["LastModifyUserId"].isNull())
 			itemsObject.lastModifyUserId = valueItemsInstanceSource["LastModifyUserId"].asString();
-		if(!valueItemsInstanceSource["LastModifyTime"].isNull())
-			itemsObject.lastModifyTime = std::stol(valueItemsInstanceSource["LastModifyTime"].asString());
-		if(!valueItemsInstanceSource["TenantId"].isNull())
-			itemsObject.tenantId = valueItemsInstanceSource["TenantId"].asString();
+		if(!valueItemsInstanceSource["PasswordStatus"].isNull())
+			itemsObject.passwordStatus = std::stoi(valueItemsInstanceSource["PasswordStatus"].asString());
+		if(!valueItemsInstanceSource["EngineType"].isNull())
+			itemsObject.engineType = valueItemsInstanceSource["EngineType"].asString();
 		if(!valueItemsInstanceSource["TenantName"].isNull())
 			itemsObject.tenantName = valueItemsInstanceSource["TenantName"].asString();
+		if(!valueItemsInstanceSource["InstanceId"].isNull())
+			itemsObject.instanceId = valueItemsInstanceSource["InstanceId"].asString();
 		if(!valueItemsInstanceSource["InstanceDescription"].isNull())
 			itemsObject.instanceDescription = valueItemsInstanceSource["InstanceDescription"].asString();
+		if(!valueItemsInstanceSource["DataLimitId"].isNull())
+			itemsObject.dataLimitId = std::stol(valueItemsInstanceSource["DataLimitId"].asString());
+		if(!valueItemsInstanceSource["RegionId"].isNull())
+			itemsObject.regionId = valueItemsInstanceSource["RegionId"].asString();
+		if(!valueItemsInstanceSource["DbName"].isNull())
+			itemsObject.dbName = valueItemsInstanceSource["DbName"].asString();
+		if(!valueItemsInstanceSource["LastModifyTime"].isNull())
+			itemsObject.lastModifyTime = std::stol(valueItemsInstanceSource["LastModifyTime"].asString());
+		if(!valueItemsInstanceSource["RegionName"].isNull())
+			itemsObject.regionName = valueItemsInstanceSource["RegionName"].asString();
 		if(!valueItemsInstanceSource["CanModifyUserName"].isNull())
 			itemsObject.canModifyUserName = valueItemsInstanceSource["CanModifyUserName"].asString() == "true";
-		if(!valueItemsInstanceSource["InstanceDescription"].isNull())
-			itemsObject.instanceDescription1 = valueItemsInstanceSource["InstanceDescription"].asString();
+		if(!valueItemsInstanceSource["LogStoreDay"].isNull())
+			itemsObject.logStoreDay = std::stoi(valueItemsInstanceSource["LogStoreDay"].asString());
+		if(!valueItemsInstanceSource["GmtCreate"].isNull())
+			itemsObject.gmtCreate = std::stol(valueItemsInstanceSource["GmtCreate"].asString());
+		if(!valueItemsInstanceSource["AutoScan"].isNull())
+			itemsObject.autoScan = std::stoi(valueItemsInstanceSource["AutoScan"].asString());
+		if(!valueItemsInstanceSource["ProductId"].isNull())
+			itemsObject.productId = std::stol(valueItemsInstanceSource["ProductId"].asString());
+		if(!valueItemsInstanceSource["InstanceSize"].isNull())
+			itemsObject.instanceSize = std::stol(valueItemsInstanceSource["InstanceSize"].asString());
+		if(!valueItemsInstanceSource["UserName"].isNull())
+			itemsObject.userName = valueItemsInstanceSource["UserName"].asString();
+		if(!valueItemsInstanceSource["AuditStatus"].isNull())
+			itemsObject.auditStatus = std::stoi(valueItemsInstanceSource["AuditStatus"].asString());
+		if(!valueItemsInstanceSource["Id"].isNull())
+			itemsObject.id = std::stol(valueItemsInstanceSource["Id"].asString());
+		if(!valueItemsInstanceSource["TenantId"].isNull())
+			itemsObject.tenantId = valueItemsInstanceSource["TenantId"].asString();
+		if(!valueItemsInstanceSource["Enable"].isNull())
+			itemsObject.enable = std::stoi(valueItemsInstanceSource["Enable"].asString());
+		if(!valueItemsInstanceSource["CheckStatus"].isNull())
+			itemsObject.checkStatus = std::stoi(valueItemsInstanceSource["CheckStatus"].asString());
+		if(!valueItemsInstanceSource["DatamaskStatus"].isNull())
+			itemsObject.datamaskStatus = std::stoi(valueItemsInstanceSource["DatamaskStatus"].asString());
+		if(!valueItemsInstanceSource["ErrorMessage"].isNull())
+			itemsObject.errorMessage = valueItemsInstanceSource["ErrorMessage"].asString();
+		if(!valueItemsInstanceSource["SamplingSize"].isNull())
+			itemsObject.samplingSize = std::stoi(valueItemsInstanceSource["SamplingSize"].asString());
 		items_.push_back(itemsObject);
 	}
-	if(!value["PageSize"].isNull())
-		pageSize_ = std::stoi(value["PageSize"].asString());
 	if(!value["CurrentPage"].isNull())
 		currentPage_ = std::stoi(value["CurrentPage"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
 	if(!value["TotalCount"].isNull())
 		totalCount_ = std::stoi(value["TotalCount"].asString());
 

sddp/src/model/DescribeInstancesRequest.cc

@@ -1,315 +1,270 @@
 /*
  * 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/sddp/model/DescribeInstancesRequest.h>
-
-using AlibabaCloud::Sddp::Model::DescribeInstancesRequest;
-
-DescribeInstancesRequest::DescribeInstancesRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "DescribeInstances")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeInstancesRequest::~DescribeInstancesRequest()
-{}
-
-std::string DescribeInstancesRequest::getProductCode()const
-{
-	return productCode_;
+ */
+
+#include <alibabacloud/sddp/model/DescribeInstancesRequest.h>
+
+using AlibabaCloud::Sddp::Model::DescribeInstancesRequest;
+
+DescribeInstancesRequest::DescribeInstancesRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "DescribeInstances") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeInstancesRequest::setProductCode(const std::string& productCode)
-{
-	productCode_ = productCode;
-	setParameter("ProductCode", productCode);
+DescribeInstancesRequest::~DescribeInstancesRequest() {}
+
+std::string DescribeInstancesRequest::getProductCode() const {
+  return productCode_;
 }
 
-long DescribeInstancesRequest::getProductId()const
-{
-	return productId_;
+void DescribeInstancesRequest::setProductCode(const std::string &productCode) {
+  productCode_ = productCode;
+  setParameter(std::string("ProductCode"), productCode);
 }
 
-void DescribeInstancesRequest::setProductId(long productId)
-{
-	productId_ = productId;
-	setParameter("ProductId", std::to_string(productId));
+long DescribeInstancesRequest::getProductId() const {
+  return productId_;
 }
 
-std::string DescribeInstancesRequest::getRiskLevels()const
-{
-	return riskLevels_;
+void DescribeInstancesRequest::setProductId(long productId) {
+  productId_ = productId;
+  setParameter(std::string("ProductId"), std::to_string(productId));
 }
 
-void DescribeInstancesRequest::setRiskLevels(const std::string& riskLevels)
-{
-	riskLevels_ = riskLevels;
-	setParameter("RiskLevels", riskLevels);
+std::string DescribeInstancesRequest::getRiskLevels() const {
+  return riskLevels_;
 }
 
-std::string DescribeInstancesRequest::getQueryName()const
-{
-	return queryName_;
+void DescribeInstancesRequest::setRiskLevels(const std::string &riskLevels) {
+  riskLevels_ = riskLevels;
+  setParameter(std::string("RiskLevels"), riskLevels);
 }
 
-void DescribeInstancesRequest::setQueryName(const std::string& queryName)
-{
-	queryName_ = queryName;
-	setParameter("QueryName", queryName);
+std::string DescribeInstancesRequest::getQueryName() const {
+  return queryName_;
 }
 
-long DescribeInstancesRequest::getRiskLevelId()const
-{
-	return riskLevelId_;
+void DescribeInstancesRequest::setQueryName(const std::string &queryName) {
+  queryName_ = queryName;
+  setParameter(std::string("QueryName"), queryName);
 }
 
-void DescribeInstancesRequest::setRiskLevelId(long riskLevelId)
-{
-	riskLevelId_ = riskLevelId;
-	setParameter("RiskLevelId", std::to_string(riskLevelId));
+long DescribeInstancesRequest::getRiskLevelId() const {
+  return riskLevelId_;
 }
 
-std::string DescribeInstancesRequest::getSource()const
-{
-	return source_;
+void DescribeInstancesRequest::setRiskLevelId(long riskLevelId) {
+  riskLevelId_ = riskLevelId;
+  setParameter(std::string("RiskLevelId"), std::to_string(riskLevelId));
 }
 
-void DescribeInstancesRequest::setSource(const std::string& source)
-{
-	source_ = source;
-	setParameter("Source", source);
+std::string DescribeInstancesRequest::getSource() const {
+  return source_;
 }
 
-long DescribeInstancesRequest::getStartTime()const
-{
-	return startTime_;
+void DescribeInstancesRequest::setSource(const std::string &source) {
+  source_ = source;
+  setParameter(std::string("Source"), source);
 }
 
-void DescribeInstancesRequest::setStartTime(long startTime)
-{
-	startTime_ = startTime;
-	setParameter("StartTime", std::to_string(startTime));
+long DescribeInstancesRequest::getStartTime() const {
+  return startTime_;
 }
 
-long DescribeInstancesRequest::getUserId()const
-{
-	return userId_;
+void DescribeInstancesRequest::setStartTime(long startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), std::to_string(startTime));
 }
 
-void DescribeInstancesRequest::setUserId(long userId)
-{
-	userId_ = userId;
-	setParameter("UserId", std::to_string(userId));
+long DescribeInstancesRequest::getUserId() const {
+  return userId_;
 }
 
-std::string DescribeInstancesRequest::getNameAccurate()const
-{
-	return nameAccurate_;
+void DescribeInstancesRequest::setUserId(long userId) {
+  userId_ = userId;
+  setParameter(std::string("UserId"), std::to_string(userId));
 }
 
-void DescribeInstancesRequest::setNameAccurate(const std::string& nameAccurate)
-{
-	nameAccurate_ = nameAccurate;
-	setParameter("NameAccurate", nameAccurate);
+std::string DescribeInstancesRequest::getNameAccurate() const {
+  return nameAccurate_;
 }
 
-std::string DescribeInstancesRequest::getSensLevelName()const
-{
-	return sensLevelName_;
+void DescribeInstancesRequest::setNameAccurate(const std::string &nameAccurate) {
+  nameAccurate_ = nameAccurate;
+  setParameter(std::string("NameAccurate"), nameAccurate);
 }
 
-void DescribeInstancesRequest::setSensLevelName(const std::string& sensLevelName)
-{
-	sensLevelName_ = sensLevelName;
-	setParameter("SensLevelName", sensLevelName);
+std::string DescribeInstancesRequest::getSensLevelName() const {
+  return sensLevelName_;
 }
 
-std::string DescribeInstancesRequest::getSourceIp()const
-{
-	return sourceIp_;
+void DescribeInstancesRequest::setSensLevelName(const std::string &sensLevelName) {
+  sensLevelName_ = sensLevelName;
+  setParameter(std::string("SensLevelName"), sensLevelName);
 }
 
-void DescribeInstancesRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+std::string DescribeInstancesRequest::getSourceIp() const {
+  return sourceIp_;
 }
 
-long DescribeInstancesRequest::getLastFinishTimeStart()const
-{
-	return lastFinishTimeStart_;
+void DescribeInstancesRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
 }
 
-void DescribeInstancesRequest::setLastFinishTimeStart(long lastFinishTimeStart)
-{
-	lastFinishTimeStart_ = lastFinishTimeStart;
-	setParameter("LastFinishTimeStart", std::to_string(lastFinishTimeStart));
+long DescribeInstancesRequest::getLastFinishTimeStart() const {
+  return lastFinishTimeStart_;
 }
 
-int DescribeInstancesRequest::getPageSize()const
-{
-	return pageSize_;
+void DescribeInstancesRequest::setLastFinishTimeStart(long lastFinishTimeStart) {
+  lastFinishTimeStart_ = lastFinishTimeStart;
+  setParameter(std::string("LastFinishTimeStart"), std::to_string(lastFinishTimeStart));
 }
 
-void DescribeInstancesRequest::setPageSize(int pageSize)
-{
-	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
+int DescribeInstancesRequest::getDataType() const {
+  return dataType_;
 }
 
-int DescribeInstancesRequest::getCheckStatus()const
-{
-	return checkStatus_;
+void DescribeInstancesRequest::setDataType(int dataType) {
+  dataType_ = dataType;
+  setParameter(std::string("DataType"), std::to_string(dataType));
 }
 
-void DescribeInstancesRequest::setCheckStatus(int checkStatus)
-{
-	checkStatus_ = checkStatus;
-	setParameter("CheckStatus", std::to_string(checkStatus));
+int DescribeInstancesRequest::getPageSize() const {
+  return pageSize_;
 }
 
-std::string DescribeInstancesRequest::getLang()const
-{
-	return lang_;
+void DescribeInstancesRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
 }
 
-void DescribeInstancesRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
+int DescribeInstancesRequest::getCheckStatus() const {
+  return checkStatus_;
 }
 
-int DescribeInstancesRequest::getQueryType()const
-{
-	return queryType_;
+void DescribeInstancesRequest::setCheckStatus(int checkStatus) {
+  checkStatus_ = checkStatus;
+  setParameter(std::string("CheckStatus"), std::to_string(checkStatus));
 }
 
-void DescribeInstancesRequest::setQueryType(int queryType)
-{
-	queryType_ = queryType;
-	setParameter("QueryType", std::to_string(queryType));
+std::string DescribeInstancesRequest::getLang() const {
+  return lang_;
 }
 
-std::string DescribeInstancesRequest::getServiceRegionId()const
-{
-	return serviceRegionId_;
+void DescribeInstancesRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 
-void DescribeInstancesRequest::setServiceRegionId(const std::string& serviceRegionId)
-{
-	serviceRegionId_ = serviceRegionId;
-	setParameter("ServiceRegionId", serviceRegionId);
+int DescribeInstancesRequest::getQueryType() const {
+  return queryType_;
 }
 
-std::string DescribeInstancesRequest::getEngineType()const
-{
-	return engineType_;
+void DescribeInstancesRequest::setQueryType(int queryType) {
+  queryType_ = queryType;
+  setParameter(std::string("QueryType"), std::to_string(queryType));
 }
 
-void DescribeInstancesRequest::setEngineType(const std::string& engineType)
-{
-	engineType_ = engineType;
-	setParameter("EngineType", engineType);
+std::string DescribeInstancesRequest::getServiceRegionId() const {
+  return serviceRegionId_;
 }
 
-int DescribeInstancesRequest::getFeatureType()const
-{
-	return featureType_;
+void DescribeInstancesRequest::setServiceRegionId(const std::string &serviceRegionId) {
+  serviceRegionId_ = serviceRegionId;
+  setParameter(std::string("ServiceRegionId"), serviceRegionId);
 }
 
-void DescribeInstancesRequest::setFeatureType(int featureType)
-{
-	featureType_ = featureType;
-	setParameter("FeatureType", std::to_string(featureType));
+std::string DescribeInstancesRequest::getEngineType() const {
+  return engineType_;
 }
 
-std::string DescribeInstancesRequest::getOrderBy()const
-{
-	return orderBy_;
+void DescribeInstancesRequest::setEngineType(const std::string &engineType) {
+  engineType_ = engineType;
+  setParameter(std::string("EngineType"), engineType);
 }
 
-void DescribeInstancesRequest::setOrderBy(const std::string& orderBy)
-{
-	orderBy_ = orderBy;
-	setParameter("OrderBy", orderBy);
+int DescribeInstancesRequest::getFeatureType() const {
+  return featureType_;
 }
 
-int DescribeInstancesRequest::getUserType()const
-{
-	return userType_;
+void DescribeInstancesRequest::setFeatureType(int featureType) {
+  featureType_ = featureType;
+  setParameter(std::string("FeatureType"), std::to_string(featureType));
 }
 
-void DescribeInstancesRequest::setUserType(int userType)
-{
-	userType_ = userType;
-	setParameter("UserType", std::to_string(userType));
+std::string DescribeInstancesRequest::getOrderBy() const {
+  return orderBy_;
 }
 
-long DescribeInstancesRequest::getEndTime()const
-{
-	return endTime_;
+void DescribeInstancesRequest::setOrderBy(const std::string &orderBy) {
+  orderBy_ = orderBy;
+  setParameter(std::string("OrderBy"), orderBy);
 }
 
-void DescribeInstancesRequest::setEndTime(long endTime)
-{
-	endTime_ = endTime;
-	setParameter("EndTime", std::to_string(endTime));
+int DescribeInstancesRequest::getUserType() const {
+  return userType_;
 }
 
-int DescribeInstancesRequest::getCurrentPage()const
-{
-	return currentPage_;
+void DescribeInstancesRequest::setUserType(int userType) {
+  userType_ = userType;
+  setParameter(std::string("UserType"), std::to_string(userType));
 }
 
-void DescribeInstancesRequest::setCurrentPage(int currentPage)
-{
-	currentPage_ = currentPage;
-	setParameter("CurrentPage", std::to_string(currentPage));
+long DescribeInstancesRequest::getEndTime() const {
+  return endTime_;
 }
 
-std::string DescribeInstancesRequest::getName()const
-{
-	return name_;
+void DescribeInstancesRequest::setEndTime(long endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), std::to_string(endTime));
 }
 
-void DescribeInstancesRequest::setName(const std::string& name)
-{
-	name_ = name;
-	setParameter("Name", name);
+int DescribeInstancesRequest::getCurrentPage() const {
+  return currentPage_;
 }
 
-long DescribeInstancesRequest::getRuleId()const
-{
-	return ruleId_;
+void DescribeInstancesRequest::setCurrentPage(int currentPage) {
+  currentPage_ = currentPage;
+  setParameter(std::string("CurrentPage"), std::to_string(currentPage));
 }
 
-void DescribeInstancesRequest::setRuleId(long ruleId)
-{
-	ruleId_ = ruleId;
-	setParameter("RuleId", std::to_string(ruleId));
+std::string DescribeInstancesRequest::getName() const {
+  return name_;
 }
 
-long DescribeInstancesRequest::getLastFinishTimeEnd()const
-{
-	return lastFinishTimeEnd_;
+void DescribeInstancesRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
 }
 
-void DescribeInstancesRequest::setLastFinishTimeEnd(long lastFinishTimeEnd)
-{
-	lastFinishTimeEnd_ = lastFinishTimeEnd;
-	setParameter("LastFinishTimeEnd", std::to_string(lastFinishTimeEnd));
+long DescribeInstancesRequest::getRuleId() const {
+  return ruleId_;
+}
+
+void DescribeInstancesRequest::setRuleId(long ruleId) {
+  ruleId_ = ruleId;
+  setParameter(std::string("RuleId"), std::to_string(ruleId));
+}
+
+long DescribeInstancesRequest::getLastFinishTimeEnd() const {
+  return lastFinishTimeEnd_;
+}
+
+void DescribeInstancesRequest::setLastFinishTimeEnd(long lastFinishTimeEnd) {
+  lastFinishTimeEnd_ = lastFinishTimeEnd;
+  setParameter(std::string("LastFinishTimeEnd"), std::to_string(lastFinishTimeEnd));
 }
 

sddp/src/model/DescribeInstancesResult.cc

@@ -43,72 +43,74 @@ void DescribeInstancesResult::parse(const std::string &payload)
 	for (auto valueItemsInstance : allItemsNode)
 	{
 		Instance itemsObject;
-		if(!valueItemsInstance["Id"].isNull())
-			itemsObject.id = std::stol(valueItemsInstance["Id"].asString());
-		if(!valueItemsInstance["Name"].isNull())
-			itemsObject.name = valueItemsInstance["Name"].asString();
-		if(!valueItemsInstance["Owner"].isNull())
-			itemsObject.owner = valueItemsInstance["Owner"].asString();
 		if(!valueItemsInstance["CreationTime"].isNull())
 			itemsObject.creationTime = std::stol(valueItemsInstance["CreationTime"].asString());
-		if(!valueItemsInstance["ProductId"].isNull())
-			itemsObject.productId = valueItemsInstance["ProductId"].asString();
-		if(!valueItemsInstance["ProductCode"].isNull())
-			itemsObject.productCode = valueItemsInstance["ProductCode"].asString();
-		if(!valueItemsInstance["Protection"].isNull())
-			itemsObject.protection = valueItemsInstance["Protection"].asString() == "true";
-		if(!valueItemsInstance["Labelsec"].isNull())
-			itemsObject.labelsec = valueItemsInstance["Labelsec"].asString() == "true";
-		if(!valueItemsInstance["OdpsRiskLevelName"].isNull())
-			itemsObject.odpsRiskLevelName = valueItemsInstance["OdpsRiskLevelName"].asString();
-		if(!valueItemsInstance["Sensitive"].isNull())
-			itemsObject.sensitive = valueItemsInstance["Sensitive"].asString() == "true";
-		if(!valueItemsInstance["RiskLevelId"].isNull())
-			itemsObject.riskLevelId = std::stol(valueItemsInstance["RiskLevelId"].asString());
-		if(!valueItemsInstance["RiskLevelName"].isNull())
-			itemsObject.riskLevelName = valueItemsInstance["RiskLevelName"].asString();
-		if(!valueItemsInstance["RuleName"].isNull())
-			itemsObject.ruleName = valueItemsInstance["RuleName"].asString();
-		if(!valueItemsInstance["DepartName"].isNull())
-			itemsObject.departName = valueItemsInstance["DepartName"].asString();
-		if(!valueItemsInstance["TotalCount"].isNull())
-			itemsObject.totalCount = std::stoi(valueItemsInstance["TotalCount"].asString());
-		if(!valueItemsInstance["SensitiveCount"].isNull())
-			itemsObject.sensitiveCount = std::stoi(valueItemsInstance["SensitiveCount"].asString());
 		if(!valueItemsInstance["Acl"].isNull())
 			itemsObject.acl = valueItemsInstance["Acl"].asString();
-		if(!valueItemsInstance["S2Count"].isNull())
-			itemsObject.s2Count = std::stoi(valueItemsInstance["S2Count"].asString());
-		if(!valueItemsInstance["S3Count"].isNull())
-			itemsObject.s3Count = std::stoi(valueItemsInstance["S3Count"].asString());
-		if(!valueItemsInstance["CountDetails"].isNull())
-			itemsObject.countDetails = valueItemsInstance["CountDetails"].asString();
 		if(!valueItemsInstance["LastFinishTime"].isNull())
 			itemsObject.lastFinishTime = std::stol(valueItemsInstance["LastFinishTime"].asString());
-		if(!valueItemsInstance["RegionName"].isNull())
-			itemsObject.regionName = valueItemsInstance["RegionName"].asString();
-		if(!valueItemsInstance["RegionId"].isNull())
-			itemsObject.regionId = valueItemsInstance["RegionId"].asString();
-		if(!valueItemsInstance["EngineType"].isNull())
-			itemsObject.engineType = valueItemsInstance["EngineType"].asString();
-		if(!valueItemsInstance["S1Count"].isNull())
-			itemsObject.s1Count = std::stoi(valueItemsInstance["S1Count"].asString());
-		if(!valueItemsInstance["RiskScore"].isNull())
-			itemsObject.riskScore = std::stof(valueItemsInstance["RiskScore"].asString());
-		if(!valueItemsInstance["LastRiskScore"].isNull())
-			itemsObject.lastRiskScore = std::stof(valueItemsInstance["LastRiskScore"].asString());
-		if(!valueItemsInstance["SensLevelName"].isNull())
-			itemsObject.sensLevelName = valueItemsInstance["SensLevelName"].asString();
-		if(!valueItemsInstance["InstanceDescription"].isNull())
-			itemsObject.instanceDescription = valueItemsInstance["InstanceDescription"].asString();
+		if(!valueItemsInstance["Owner"].isNull())
+			itemsObject.owner = valueItemsInstance["Owner"].asString();
+		if(!valueItemsInstance["CountDetails"].isNull())
+			itemsObject.countDetails = valueItemsInstance["CountDetails"].asString();
+		if(!valueItemsInstance["FileCountDetails"].isNull())
+			itemsObject.fileCountDetails = valueItemsInstance["FileCountDetails"].asString();
 		if(!valueItemsInstance["TenantName"].isNull())
 			itemsObject.tenantName = valueItemsInstance["TenantName"].asString();
+		if(!valueItemsInstance["Protection"].isNull())
+			itemsObject.protection = valueItemsInstance["Protection"].asString() == "true";
+		if(!valueItemsInstance["DepartName"].isNull())
+			itemsObject.departName = valueItemsInstance["DepartName"].asString();
+		if(!valueItemsInstance["Labelsec"].isNull())
+			itemsObject.labelsec = valueItemsInstance["Labelsec"].asString() == "true";
+		if(!valueItemsInstance["RiskScore"].isNull())
+			itemsObject.riskScore = std::stof(valueItemsInstance["RiskScore"].asString());
+		if(!valueItemsInstance["RiskLevelId"].isNull())
+			itemsObject.riskLevelId = std::stol(valueItemsInstance["RiskLevelId"].asString());
+		if(!valueItemsInstance["S3Count"].isNull())
+			itemsObject.s3Count = std::stoi(valueItemsInstance["S3Count"].asString());
+		if(!valueItemsInstance["S1Count"].isNull())
+			itemsObject.s1Count = std::stoi(valueItemsInstance["S1Count"].asString());
+		if(!valueItemsInstance["ProductId"].isNull())
+			itemsObject.productId = valueItemsInstance["ProductId"].asString();
+		if(!valueItemsInstance["Name"].isNull())
+			itemsObject.name = valueItemsInstance["Name"].asString();
+		if(!valueItemsInstance["S2Count"].isNull())
+			itemsObject.s2Count = std::stoi(valueItemsInstance["S2Count"].asString());
+		if(!valueItemsInstance["EngineType"].isNull())
+			itemsObject.engineType = valueItemsInstance["EngineType"].asString();
+		if(!valueItemsInstance["TotalCount"].isNull())
+			itemsObject.totalCount = std::stoi(valueItemsInstance["TotalCount"].asString());
+		if(!valueItemsInstance["InstanceDescription"].isNull())
+			itemsObject.instanceDescription = valueItemsInstance["InstanceDescription"].asString();
+		if(!valueItemsInstance["RuleName"].isNull())
+			itemsObject.ruleName = valueItemsInstance["RuleName"].asString();
+		if(!valueItemsInstance["RegionId"].isNull())
+			itemsObject.regionId = valueItemsInstance["RegionId"].asString();
+		if(!valueItemsInstance["Sensitive"].isNull())
+			itemsObject.sensitive = valueItemsInstance["Sensitive"].asString() == "true";
+		if(!valueItemsInstance["SensLevelName"].isNull())
+			itemsObject.sensLevelName = valueItemsInstance["SensLevelName"].asString();
+		if(!valueItemsInstance["RegionName"].isNull())
+			itemsObject.regionName = valueItemsInstance["RegionName"].asString();
+		if(!valueItemsInstance["LastRiskScore"].isNull())
+			itemsObject.lastRiskScore = std::stof(valueItemsInstance["LastRiskScore"].asString());
+		if(!valueItemsInstance["RiskLevelName"].isNull())
+			itemsObject.riskLevelName = valueItemsInstance["RiskLevelName"].asString();
+		if(!valueItemsInstance["OdpsRiskLevelName"].isNull())
+			itemsObject.odpsRiskLevelName = valueItemsInstance["OdpsRiskLevelName"].asString();
+		if(!valueItemsInstance["SensitiveCount"].isNull())
+			itemsObject.sensitiveCount = std::stoi(valueItemsInstance["SensitiveCount"].asString());
+		if(!valueItemsInstance["Id"].isNull())
+			itemsObject.id = std::stol(valueItemsInstance["Id"].asString());
+		if(!valueItemsInstance["ProductCode"].isNull())
+			itemsObject.productCode = valueItemsInstance["ProductCode"].asString();
 		items_.push_back(itemsObject);
 	}
-	if(!value["PageSize"].isNull())
-		pageSize_ = std::stoi(value["PageSize"].asString());
 	if(!value["CurrentPage"].isNull())
 		currentPage_ = std::stoi(value["CurrentPage"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
 	if(!value["TotalCount"].isNull())
 		totalCount_ = std::stoi(value["TotalCount"].asString());
 

sddp/src/model/DescribeOssObjectDetailRequest.cc

@@ -1,73 +1,63 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
-
-#include <alibabacloud/sddp/model/DescribeOssObjectDetailRequest.h>
-
-using AlibabaCloud::Sddp::Model::DescribeOssObjectDetailRequest;
-
-DescribeOssObjectDetailRequest::DescribeOssObjectDetailRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "DescribeOssObjectDetail")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeOssObjectDetailRequest::~DescribeOssObjectDetailRequest()
-{}
-
-std::string DescribeOssObjectDetailRequest::getSourceIp()const
-{
-	return sourceIp_;
+ */
+
+#include <alibabacloud/sddp/model/DescribeOssObjectDetailRequest.h>
+
+using AlibabaCloud::Sddp::Model::DescribeOssObjectDetailRequest;
+
+DescribeOssObjectDetailRequest::DescribeOssObjectDetailRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "DescribeOssObjectDetail") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeOssObjectDetailRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+DescribeOssObjectDetailRequest::~DescribeOssObjectDetailRequest() {}
+
+std::string DescribeOssObjectDetailRequest::getSourceIp() const {
+  return sourceIp_;
 }
 
-long DescribeOssObjectDetailRequest::getId()const
-{
-	return id_;
+void DescribeOssObjectDetailRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
 }
 
-void DescribeOssObjectDetailRequest::setId(long id)
-{
-	id_ = id;
-	setParameter("Id", std::to_string(id));
+long DescribeOssObjectDetailRequest::getId() const {
+  return id_;
 }
 
-std::string DescribeOssObjectDetailRequest::getLang()const
-{
-	return lang_;
+void DescribeOssObjectDetailRequest::setId(long id) {
+  id_ = id;
+  setParameter(std::string("Id"), std::to_string(id));
 }
 
-void DescribeOssObjectDetailRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
+std::string DescribeOssObjectDetailRequest::getLang() const {
+  return lang_;
 }
 
-int DescribeOssObjectDetailRequest::getFeatureType()const
-{
-	return featureType_;
+void DescribeOssObjectDetailRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 
-void DescribeOssObjectDetailRequest::setFeatureType(int featureType)
-{
-	featureType_ = featureType;
-	setParameter("FeatureType", std::to_string(featureType));
+int DescribeOssObjectDetailRequest::getFeatureType() const {
+  return featureType_;
+}
+
+void DescribeOssObjectDetailRequest::setFeatureType(int featureType) {
+  featureType_ = featureType;
+  setParameter(std::string("FeatureType"), std::to_string(featureType));
 }
 

sddp/src/model/DescribeOssObjectDetailResult.cc

@@ -40,32 +40,32 @@ void DescribeOssObjectDetailResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto ossObjectDetailNode = value["OssObjectDetail"];
-	if(!ossObjectDetailNode["Name"].isNull())
-		ossObjectDetail_.name = ossObjectDetailNode["Name"].asString();
-	if(!ossObjectDetailNode["RegionId"].isNull())
-		ossObjectDetail_.regionId = ossObjectDetailNode["RegionId"].asString();
-	if(!ossObjectDetailNode["RiskLevelName"].isNull())
-		ossObjectDetail_.riskLevelName = ossObjectDetailNode["RiskLevelName"].asString();
-	if(!ossObjectDetailNode["BucketName"].isNull())
-		ossObjectDetail_.bucketName = ossObjectDetailNode["BucketName"].asString();
 	if(!ossObjectDetailNode["CategoryName"].isNull())
 		ossObjectDetail_.categoryName = ossObjectDetailNode["CategoryName"].asString();
+	if(!ossObjectDetailNode["Name"].isNull())
+		ossObjectDetail_.name = ossObjectDetailNode["Name"].asString();
+	if(!ossObjectDetailNode["BucketName"].isNull())
+		ossObjectDetail_.bucketName = ossObjectDetailNode["BucketName"].asString();
+	if(!ossObjectDetailNode["RiskLevelName"].isNull())
+		ossObjectDetail_.riskLevelName = ossObjectDetailNode["RiskLevelName"].asString();
+	if(!ossObjectDetailNode["RegionId"].isNull())
+		ossObjectDetail_.regionId = ossObjectDetailNode["RegionId"].asString();
 	auto allRuleListNode = ossObjectDetailNode["RuleList"]["Rule"];
 	for (auto ossObjectDetailNodeRuleListRule : allRuleListNode)
 	{
 		OssObjectDetail::Rule ruleObject;
-		if(!ossObjectDetailNodeRuleListRule["RuleName"].isNull())
-			ruleObject.ruleName = ossObjectDetailNodeRuleListRule["RuleName"].asString();
-		if(!ossObjectDetailNodeRuleListRule["Count"].isNull())
-			ruleObject.count = std::stol(ossObjectDetailNodeRuleListRule["Count"].asString());
+		if(!ossObjectDetailNodeRuleListRule["RiskLevelName"].isNull())
+			ruleObject.riskLevelName = ossObjectDetailNodeRuleListRule["RiskLevelName"].asString();
 		if(!ossObjectDetailNodeRuleListRule["Category"].isNull())
 			ruleObject.category = std::stoi(ossObjectDetailNodeRuleListRule["Category"].asString());
 		if(!ossObjectDetailNodeRuleListRule["CategoryName"].isNull())
 			ruleObject.categoryName = ossObjectDetailNodeRuleListRule["CategoryName"].asString();
-		if(!ossObjectDetailNodeRuleListRule["RiskLevelName"].isNull())
-			ruleObject.riskLevelName = ossObjectDetailNodeRuleListRule["RiskLevelName"].asString();
 		if(!ossObjectDetailNodeRuleListRule["RiskLevelId"].isNull())
 			ruleObject.riskLevelId = std::stol(ossObjectDetailNodeRuleListRule["RiskLevelId"].asString());
+		if(!ossObjectDetailNodeRuleListRule["Count"].isNull())
+			ruleObject.count = std::stol(ossObjectDetailNodeRuleListRule["Count"].asString());
+		if(!ossObjectDetailNodeRuleListRule["RuleName"].isNull())
+			ruleObject.ruleName = ossObjectDetailNodeRuleListRule["RuleName"].asString();
 		auto allSampleList = value["SampleList"]["Sample"];
 		for (auto value : allSampleList)
 			ruleObject.sampleList.push_back(value.asString());

sddp/src/model/DescribeOssObjectsRequest.cc

@@ -1,227 +1,189 @@
 /*
  * 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/sddp/model/DescribeOssObjectsRequest.h>
-
-using AlibabaCloud::Sddp::Model::DescribeOssObjectsRequest;
-
-DescribeOssObjectsRequest::DescribeOssObjectsRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "DescribeOssObjects")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeOssObjectsRequest::~DescribeOssObjectsRequest()
-{}
-
-std::string DescribeOssObjectsRequest::getRiskLevels()const
-{
-	return riskLevels_;
+ */
+
+#include <alibabacloud/sddp/model/DescribeOssObjectsRequest.h>
+
+using AlibabaCloud::Sddp::Model::DescribeOssObjectsRequest;
+
+DescribeOssObjectsRequest::DescribeOssObjectsRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "DescribeOssObjects") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeOssObjectsRequest::setRiskLevels(const std::string& riskLevels)
-{
-	riskLevels_ = riskLevels;
-	setParameter("RiskLevels", riskLevels);
+DescribeOssObjectsRequest::~DescribeOssObjectsRequest() {}
+
+std::string DescribeOssObjectsRequest::getRiskLevels() const {
+  return riskLevels_;
 }
 
-bool DescribeOssObjectsRequest::getNeedRiskCount()const
-{
-	return needRiskCount_;
+void DescribeOssObjectsRequest::setRiskLevels(const std::string &riskLevels) {
+  riskLevels_ = riskLevels;
+  setParameter(std::string("RiskLevels"), riskLevels);
 }
 
-void DescribeOssObjectsRequest::setNeedRiskCount(bool needRiskCount)
-{
-	needRiskCount_ = needRiskCount;
-	setParameter("NeedRiskCount", needRiskCount ? "true" : "false");
+bool DescribeOssObjectsRequest::getNeedRiskCount() const {
+  return needRiskCount_;
 }
 
-std::string DescribeOssObjectsRequest::getQueryName()const
-{
-	return queryName_;
+void DescribeOssObjectsRequest::setNeedRiskCount(bool needRiskCount) {
+  needRiskCount_ = needRiskCount;
+  setParameter(std::string("NeedRiskCount"), needRiskCount ? "true" : "false");
 }
 
-void DescribeOssObjectsRequest::setQueryName(const std::string& queryName)
-{
-	queryName_ = queryName;
-	setParameter("QueryName", queryName);
+std::string DescribeOssObjectsRequest::getQueryName() const {
+  return queryName_;
 }
 
-int DescribeOssObjectsRequest::getRiskLevelId()const
-{
-	return riskLevelId_;
+void DescribeOssObjectsRequest::setQueryName(const std::string &queryName) {
+  queryName_ = queryName;
+  setParameter(std::string("QueryName"), queryName);
 }
 
-void DescribeOssObjectsRequest::setRiskLevelId(int riskLevelId)
-{
-	riskLevelId_ = riskLevelId;
-	setParameter("RiskLevelId", std::to_string(riskLevelId));
+int DescribeOssObjectsRequest::getRiskLevelId() const {
+  return riskLevelId_;
 }
 
-long DescribeOssObjectsRequest::getLastScanTimeEnd()const
-{
-	return lastScanTimeEnd_;
+void DescribeOssObjectsRequest::setRiskLevelId(int riskLevelId) {
+  riskLevelId_ = riskLevelId;
+  setParameter(std::string("RiskLevelId"), std::to_string(riskLevelId));
 }
 
-void DescribeOssObjectsRequest::setLastScanTimeEnd(long lastScanTimeEnd)
-{
-	lastScanTimeEnd_ = lastScanTimeEnd;
-	setParameter("LastScanTimeEnd", std::to_string(lastScanTimeEnd));
+long DescribeOssObjectsRequest::getLastScanTimeEnd() const {
+  return lastScanTimeEnd_;
 }
 
-long DescribeOssObjectsRequest::getLastScanTimeStart()const
-{
-	return lastScanTimeStart_;
+void DescribeOssObjectsRequest::setLastScanTimeEnd(long lastScanTimeEnd) {
+  lastScanTimeEnd_ = lastScanTimeEnd;
+  setParameter(std::string("LastScanTimeEnd"), std::to_string(lastScanTimeEnd));
 }
 
-void DescribeOssObjectsRequest::setLastScanTimeStart(long lastScanTimeStart)
-{
-	lastScanTimeStart_ = lastScanTimeStart;
-	setParameter("LastScanTimeStart", std::to_string(lastScanTimeStart));
+long DescribeOssObjectsRequest::getLastScanTimeStart() const {
+  return lastScanTimeStart_;
 }
 
-std::string DescribeOssObjectsRequest::getSourceIp()const
-{
-	return sourceIp_;
+void DescribeOssObjectsRequest::setLastScanTimeStart(long lastScanTimeStart) {
+  lastScanTimeStart_ = lastScanTimeStart;
+  setParameter(std::string("LastScanTimeStart"), std::to_string(lastScanTimeStart));
 }
 
-void DescribeOssObjectsRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+std::string DescribeOssObjectsRequest::getSourceIp() const {
+  return sourceIp_;
 }
 
-int DescribeOssObjectsRequest::getPageSize()const
-{
-	return pageSize_;
+void DescribeOssObjectsRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
 }
 
-void DescribeOssObjectsRequest::setPageSize(int pageSize)
-{
-	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
+int DescribeOssObjectsRequest::getPageSize() const {
+  return pageSize_;
 }
 
-std::string DescribeOssObjectsRequest::getLang()const
-{
-	return lang_;
+void DescribeOssObjectsRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
 }
 
-void DescribeOssObjectsRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
+std::string DescribeOssObjectsRequest::getLang() const {
+  return lang_;
 }
 
-std::string DescribeOssObjectsRequest::getServiceRegionId()const
-{
-	return serviceRegionId_;
+void DescribeOssObjectsRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 
-void DescribeOssObjectsRequest::setServiceRegionId(const std::string& serviceRegionId)
-{
-	serviceRegionId_ = serviceRegionId;
-	setParameter("ServiceRegionId", serviceRegionId);
+std::string DescribeOssObjectsRequest::getServiceRegionId() const {
+  return serviceRegionId_;
 }
 
-int DescribeOssObjectsRequest::getFeatureType()const
-{
-	return featureType_;
+void DescribeOssObjectsRequest::setServiceRegionId(const std::string &serviceRegionId) {
+  serviceRegionId_ = serviceRegionId;
+  setParameter(std::string("ServiceRegionId"), serviceRegionId);
 }
 
-void DescribeOssObjectsRequest::setFeatureType(int featureType)
-{
-	featureType_ = featureType;
-	setParameter("FeatureType", std::to_string(featureType));
+int DescribeOssObjectsRequest::getFeatureType() const {
+  return featureType_;
 }
 
-std::string DescribeOssObjectsRequest::getOrderBy()const
-{
-	return orderBy_;
+void DescribeOssObjectsRequest::setFeatureType(int featureType) {
+  featureType_ = featureType;
+  setParameter(std::string("FeatureType"), std::to_string(featureType));
 }
 
-void DescribeOssObjectsRequest::setOrderBy(const std::string& orderBy)
-{
-	orderBy_ = orderBy;
-	setParameter("OrderBy", orderBy);
+std::string DescribeOssObjectsRequest::getOrderBy() const {
+  return orderBy_;
 }
 
-int DescribeOssObjectsRequest::getCurrentPage()const
-{
-	return currentPage_;
+void DescribeOssObjectsRequest::setOrderBy(const std::string &orderBy) {
+  orderBy_ = orderBy;
+  setParameter(std::string("OrderBy"), orderBy);
 }
 
-void DescribeOssObjectsRequest::setCurrentPage(int currentPage)
-{
-	currentPage_ = currentPage;
-	setParameter("CurrentPage", std::to_string(currentPage));
+int DescribeOssObjectsRequest::getCurrentPage() const {
+  return currentPage_;
 }
 
-std::string DescribeOssObjectsRequest::getRuleIds()const
-{
-	return ruleIds_;
+void DescribeOssObjectsRequest::setCurrentPage(int currentPage) {
+  currentPage_ = currentPage;
+  setParameter(std::string("CurrentPage"), std::to_string(currentPage));
 }
 
-void DescribeOssObjectsRequest::setRuleIds(const std::string& ruleIds)
-{
-	ruleIds_ = ruleIds;
-	setParameter("RuleIds", ruleIds);
+std::string DescribeOssObjectsRequest::getRuleIds() const {
+  return ruleIds_;
 }
 
-std::string DescribeOssObjectsRequest::getInstanceId()const
-{
-	return instanceId_;
+void DescribeOssObjectsRequest::setRuleIds(const std::string &ruleIds) {
+  ruleIds_ = ruleIds;
+  setParameter(std::string("RuleIds"), ruleIds);
 }
 
-void DescribeOssObjectsRequest::setInstanceId(const std::string& instanceId)
-{
-	instanceId_ = instanceId;
-	setParameter("InstanceId", instanceId);
+std::string DescribeOssObjectsRequest::getInstanceId() const {
+  return instanceId_;
 }
 
-std::string DescribeOssObjectsRequest::getName()const
-{
-	return name_;
+void DescribeOssObjectsRequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setParameter(std::string("InstanceId"), instanceId);
 }
 
-void DescribeOssObjectsRequest::setName(const std::string& name)
-{
-	name_ = name;
-	setParameter("Name", name);
+std::string DescribeOssObjectsRequest::getName() const {
+  return name_;
 }
 
-long DescribeOssObjectsRequest::getRuleId()const
-{
-	return ruleId_;
+void DescribeOssObjectsRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
 }
 
-void DescribeOssObjectsRequest::setRuleId(long ruleId)
-{
-	ruleId_ = ruleId;
-	setParameter("RuleId", std::to_string(ruleId));
+long DescribeOssObjectsRequest::getRuleId() const {
+  return ruleId_;
 }
 
-int DescribeOssObjectsRequest::getCategory()const
-{
-	return category_;
+void DescribeOssObjectsRequest::setRuleId(long ruleId) {
+  ruleId_ = ruleId;
+  setParameter(std::string("RuleId"), std::to_string(ruleId));
 }
 
-void DescribeOssObjectsRequest::setCategory(int category)
-{
-	category_ = category;
-	setParameter("Category", std::to_string(category));
+int DescribeOssObjectsRequest::getCategory() const {
+  return category_;
+}
+
+void DescribeOssObjectsRequest::setCategory(int category) {
+  category_ = category;
+  setParameter(std::string("Category"), std::to_string(category));
 }
 

sddp/src/model/DescribeOssObjectsResult.cc

@@ -43,54 +43,54 @@ void DescribeOssObjectsResult::parse(const std::string &payload)
 	for (auto valueItemsColumn : allItemsNode)
 	{
 		Column itemsObject;
-		if(!valueItemsColumn["Id"].isNull())
-			itemsObject.id = valueItemsColumn["Id"].asString();
-		if(!valueItemsColumn["Name"].isNull())
-			itemsObject.name = valueItemsColumn["Name"].asString();
-		if(!valueItemsColumn["RegionId"].isNull())
-			itemsObject.regionId = valueItemsColumn["RegionId"].asString();
-		if(!valueItemsColumn["RiskLevelId"].isNull())
-			itemsObject.riskLevelId = std::stol(valueItemsColumn["RiskLevelId"].asString());
-		if(!valueItemsColumn["Category"].isNull())
-			itemsObject.category = std::stol(valueItemsColumn["Category"].asString());
 		if(!valueItemsColumn["InstanceId"].isNull())
 			itemsObject.instanceId = std::stol(valueItemsColumn["InstanceId"].asString());
-		if(!valueItemsColumn["FileId"].isNull())
-			itemsObject.fileId = valueItemsColumn["FileId"].asString();
-		if(!valueItemsColumn["RiskLevelName"].isNull())
-			itemsObject.riskLevelName = valueItemsColumn["RiskLevelName"].asString();
-		if(!valueItemsColumn["Size"].isNull())
-			itemsObject.size = std::stol(valueItemsColumn["Size"].asString());
-		if(!valueItemsColumn["SensitiveCount"].isNull())
-			itemsObject.sensitiveCount = std::stoi(valueItemsColumn["SensitiveCount"].asString());
-		if(!valueItemsColumn["RuleCount"].isNull())
-			itemsObject.ruleCount = std::stoi(valueItemsColumn["RuleCount"].asString());
 		if(!valueItemsColumn["CategoryName"].isNull())
 			itemsObject.categoryName = valueItemsColumn["CategoryName"].asString();
-		if(!valueItemsColumn["BucketName"].isNull())
-			itemsObject.bucketName = valueItemsColumn["BucketName"].asString();
-		if(!valueItemsColumn["RegionName"].isNull())
-			itemsObject.regionName = valueItemsColumn["RegionName"].asString();
+		if(!valueItemsColumn["RiskLevelId"].isNull())
+			itemsObject.riskLevelId = std::stol(valueItemsColumn["RiskLevelId"].asString());
+		if(!valueItemsColumn["RegionId"].isNull())
+			itemsObject.regionId = valueItemsColumn["RegionId"].asString();
+		if(!valueItemsColumn["FileId"].isNull())
+			itemsObject.fileId = valueItemsColumn["FileId"].asString();
 		if(!valueItemsColumn["LastScanTime"].isNull())
 			itemsObject.lastScanTime = std::stol(valueItemsColumn["LastScanTime"].asString());
+		if(!valueItemsColumn["RegionName"].isNull())
+			itemsObject.regionName = valueItemsColumn["RegionName"].asString();
+		if(!valueItemsColumn["Size"].isNull())
+			itemsObject.size = std::stol(valueItemsColumn["Size"].asString());
+		if(!valueItemsColumn["BucketName"].isNull())
+			itemsObject.bucketName = valueItemsColumn["BucketName"].asString();
+		if(!valueItemsColumn["RiskLevelName"].isNull())
+			itemsObject.riskLevelName = valueItemsColumn["RiskLevelName"].asString();
+		if(!valueItemsColumn["Category"].isNull())
+			itemsObject.category = std::stol(valueItemsColumn["Category"].asString());
+		if(!valueItemsColumn["Name"].isNull())
+			itemsObject.name = valueItemsColumn["Name"].asString();
+		if(!valueItemsColumn["RuleCount"].isNull())
+			itemsObject.ruleCount = std::stoi(valueItemsColumn["RuleCount"].asString());
+		if(!valueItemsColumn["SensitiveCount"].isNull())
+			itemsObject.sensitiveCount = std::stoi(valueItemsColumn["SensitiveCount"].asString());
+		if(!valueItemsColumn["Id"].isNull())
+			itemsObject.id = valueItemsColumn["Id"].asString();
 		auto allRuleListNode = valueItemsColumn["RuleList"]["Rule"];
 		for (auto valueItemsColumnRuleListRule : allRuleListNode)
 		{
 			Column::Rule ruleListObject;
 			if(!valueItemsColumnRuleListRule["Name"].isNull())
 				ruleListObject.name = valueItemsColumnRuleListRule["Name"].asString();
-			if(!valueItemsColumnRuleListRule["Count"].isNull())
-				ruleListObject.count = std::stol(valueItemsColumnRuleListRule["Count"].asString());
 			if(!valueItemsColumnRuleListRule["RiskLevelId"].isNull())
 				ruleListObject.riskLevelId = std::stol(valueItemsColumnRuleListRule["RiskLevelId"].asString());
+			if(!valueItemsColumnRuleListRule["Count"].isNull())
+				ruleListObject.count = std::stol(valueItemsColumnRuleListRule["Count"].asString());
 			itemsObject.ruleList.push_back(ruleListObject);
 		}
 		items_.push_back(itemsObject);
 	}
-	if(!value["PageSize"].isNull())
-		pageSize_ = std::stoi(value["PageSize"].asString());
 	if(!value["CurrentPage"].isNull())
 		currentPage_ = std::stoi(value["CurrentPage"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
 	if(!value["TotalCount"].isNull())
 		totalCount_ = std::stoi(value["TotalCount"].asString());
 

sddp/src/model/DescribePackagesRequest.cc

@@ -1,183 +1,153 @@
 /*
  * 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/sddp/model/DescribePackagesRequest.h>
-
-using AlibabaCloud::Sddp::Model::DescribePackagesRequest;
-
-DescribePackagesRequest::DescribePackagesRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "DescribePackages")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribePackagesRequest::~DescribePackagesRequest()
-{}
-
-long DescribePackagesRequest::getProductId()const
-{
-	return productId_;
+ */
+
+#include <alibabacloud/sddp/model/DescribePackagesRequest.h>
+
+using AlibabaCloud::Sddp::Model::DescribePackagesRequest;
+
+DescribePackagesRequest::DescribePackagesRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "DescribePackages") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribePackagesRequest::setProductId(long productId)
-{
-	productId_ = productId;
-	setParameter("ProductId", std::to_string(productId));
+DescribePackagesRequest::~DescribePackagesRequest() {}
+
+long DescribePackagesRequest::getProductId() const {
+  return productId_;
 }
 
-std::string DescribePackagesRequest::getRiskLevels()const
-{
-	return riskLevels_;
+void DescribePackagesRequest::setProductId(long productId) {
+  productId_ = productId;
+  setParameter(std::string("ProductId"), std::to_string(productId));
 }
 
-void DescribePackagesRequest::setRiskLevels(const std::string& riskLevels)
-{
-	riskLevels_ = riskLevels;
-	setParameter("RiskLevels", riskLevels);
+std::string DescribePackagesRequest::getRiskLevels() const {
+  return riskLevels_;
 }
 
-std::string DescribePackagesRequest::getQueryName()const
-{
-	return queryName_;
+void DescribePackagesRequest::setRiskLevels(const std::string &riskLevels) {
+  riskLevels_ = riskLevels;
+  setParameter(std::string("RiskLevels"), riskLevels);
 }
 
-void DescribePackagesRequest::setQueryName(const std::string& queryName)
-{
-	queryName_ = queryName;
-	setParameter("QueryName", queryName);
+std::string DescribePackagesRequest::getQueryName() const {
+  return queryName_;
 }
 
-long DescribePackagesRequest::getRiskLevelId()const
-{
-	return riskLevelId_;
+void DescribePackagesRequest::setQueryName(const std::string &queryName) {
+  queryName_ = queryName;
+  setParameter(std::string("QueryName"), queryName);
 }
 
-void DescribePackagesRequest::setRiskLevelId(long riskLevelId)
-{
-	riskLevelId_ = riskLevelId;
-	setParameter("RiskLevelId", std::to_string(riskLevelId));
+long DescribePackagesRequest::getRiskLevelId() const {
+  return riskLevelId_;
 }
 
-std::string DescribePackagesRequest::getSourceIp()const
-{
-	return sourceIp_;
+void DescribePackagesRequest::setRiskLevelId(long riskLevelId) {
+  riskLevelId_ = riskLevelId;
+  setParameter(std::string("RiskLevelId"), std::to_string(riskLevelId));
 }
 
-void DescribePackagesRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+std::string DescribePackagesRequest::getSourceIp() const {
+  return sourceIp_;
 }
 
-int DescribePackagesRequest::getPageSize()const
-{
-	return pageSize_;
+void DescribePackagesRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
 }
 
-void DescribePackagesRequest::setPageSize(int pageSize)
-{
-	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
+int DescribePackagesRequest::getPageSize() const {
+  return pageSize_;
 }
 
-std::string DescribePackagesRequest::getLang()const
-{
-	return lang_;
+void DescribePackagesRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
 }
 
-void DescribePackagesRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
+std::string DescribePackagesRequest::getLang() const {
+  return lang_;
 }
 
-int DescribePackagesRequest::getQueryType()const
-{
-	return queryType_;
+void DescribePackagesRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 
-void DescribePackagesRequest::setQueryType(int queryType)
-{
-	queryType_ = queryType;
-	setParameter("QueryType", std::to_string(queryType));
+int DescribePackagesRequest::getQueryType() const {
+  return queryType_;
 }
 
-int DescribePackagesRequest::getFeatureType()const
-{
-	return featureType_;
+void DescribePackagesRequest::setQueryType(int queryType) {
+  queryType_ = queryType;
+  setParameter(std::string("QueryType"), std::to_string(queryType));
 }
 
-void DescribePackagesRequest::setFeatureType(int featureType)
-{
-	featureType_ = featureType;
-	setParameter("FeatureType", std::to_string(featureType));
+int DescribePackagesRequest::getFeatureType() const {
+  return featureType_;
 }
 
-std::string DescribePackagesRequest::getOrderBy()const
-{
-	return orderBy_;
+void DescribePackagesRequest::setFeatureType(int featureType) {
+  featureType_ = featureType;
+  setParameter(std::string("FeatureType"), std::to_string(featureType));
 }
 
-void DescribePackagesRequest::setOrderBy(const std::string& orderBy)
-{
-	orderBy_ = orderBy;
-	setParameter("OrderBy", orderBy);
+std::string DescribePackagesRequest::getOrderBy() const {
+  return orderBy_;
 }
 
-int DescribePackagesRequest::getCurrentPage()const
-{
-	return currentPage_;
+void DescribePackagesRequest::setOrderBy(const std::string &orderBy) {
+  orderBy_ = orderBy;
+  setParameter(std::string("OrderBy"), orderBy);
 }
 
-void DescribePackagesRequest::setCurrentPage(int currentPage)
-{
-	currentPage_ = currentPage;
-	setParameter("CurrentPage", std::to_string(currentPage));
+int DescribePackagesRequest::getCurrentPage() const {
+  return currentPage_;
 }
 
-long DescribePackagesRequest::getInstanceId()const
-{
-	return instanceId_;
+void DescribePackagesRequest::setCurrentPage(int currentPage) {
+  currentPage_ = currentPage;
+  setParameter(std::string("CurrentPage"), std::to_string(currentPage));
 }
 
-void DescribePackagesRequest::setInstanceId(long instanceId)
-{
-	instanceId_ = instanceId;
-	setParameter("InstanceId", std::to_string(instanceId));
+long DescribePackagesRequest::getInstanceId() const {
+  return instanceId_;
 }
 
-std::string DescribePackagesRequest::getName()const
-{
-	return name_;
+void DescribePackagesRequest::setInstanceId(long instanceId) {
+  instanceId_ = instanceId;
+  setParameter(std::string("InstanceId"), std::to_string(instanceId));
 }
 
-void DescribePackagesRequest::setName(const std::string& name)
-{
-	name_ = name;
-	setParameter("Name", name);
+std::string DescribePackagesRequest::getName() const {
+  return name_;
 }
 
-long DescribePackagesRequest::getRuleId()const
-{
-	return ruleId_;
+void DescribePackagesRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
 }
 
-void DescribePackagesRequest::setRuleId(long ruleId)
-{
-	ruleId_ = ruleId;
-	setParameter("RuleId", std::to_string(ruleId));
+long DescribePackagesRequest::getRuleId() const {
+  return ruleId_;
+}
+
+void DescribePackagesRequest::setRuleId(long ruleId) {
+  ruleId_ = ruleId;
+  setParameter(std::string("RuleId"), std::to_string(ruleId));
 }
 

sddp/src/model/DescribePackagesResult.cc

@@ -43,34 +43,34 @@ void DescribePackagesResult::parse(const std::string &payload)
 	for (auto valueItemsPackage : allItemsNode)
 	{
 		Package itemsObject;
-		if(!valueItemsPackage["Id"].isNull())
-			itemsObject.id = std::stol(valueItemsPackage["Id"].asString());
-		if(!valueItemsPackage["Name"].isNull())
-			itemsObject.name = valueItemsPackage["Name"].asString();
-		if(!valueItemsPackage["Owner"].isNull())
-			itemsObject.owner = valueItemsPackage["Owner"].asString();
 		if(!valueItemsPackage["CreationTime"].isNull())
 			itemsObject.creationTime = std::stol(valueItemsPackage["CreationTime"].asString());
 		if(!valueItemsPackage["Sensitive"].isNull())
 			itemsObject.sensitive = valueItemsPackage["Sensitive"].asString() == "true";
-		if(!valueItemsPackage["RiskLevelId"].isNull())
-			itemsObject.riskLevelId = std::stol(valueItemsPackage["RiskLevelId"].asString());
+		if(!valueItemsPackage["Owner"].isNull())
+			itemsObject.owner = valueItemsPackage["Owner"].asString();
 		if(!valueItemsPackage["RiskLevelName"].isNull())
 			itemsObject.riskLevelName = valueItemsPackage["RiskLevelName"].asString();
 		if(!valueItemsPackage["DepartName"].isNull())
 			itemsObject.departName = valueItemsPackage["DepartName"].asString();
-		if(!valueItemsPackage["TotalCount"].isNull())
-			itemsObject.totalCount = std::stoi(valueItemsPackage["TotalCount"].asString());
-		if(!valueItemsPackage["SensitiveCount"].isNull())
-			itemsObject.sensitiveCount = std::stoi(valueItemsPackage["SensitiveCount"].asString());
 		if(!valueItemsPackage["InstanceId"].isNull())
 			itemsObject.instanceId = std::stol(valueItemsPackage["InstanceId"].asString());
+		if(!valueItemsPackage["TotalCount"].isNull())
+			itemsObject.totalCount = std::stoi(valueItemsPackage["TotalCount"].asString());
+		if(!valueItemsPackage["Name"].isNull())
+			itemsObject.name = valueItemsPackage["Name"].asString();
+		if(!valueItemsPackage["SensitiveCount"].isNull())
+			itemsObject.sensitiveCount = std::stoi(valueItemsPackage["SensitiveCount"].asString());
+		if(!valueItemsPackage["RiskLevelId"].isNull())
+			itemsObject.riskLevelId = std::stol(valueItemsPackage["RiskLevelId"].asString());
+		if(!valueItemsPackage["Id"].isNull())
+			itemsObject.id = std::stol(valueItemsPackage["Id"].asString());
 		items_.push_back(itemsObject);
 	}
-	if(!value["PageSize"].isNull())
-		pageSize_ = std::stoi(value["PageSize"].asString());
 	if(!value["CurrentPage"].isNull())
 		currentPage_ = std::stoi(value["CurrentPage"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
 	if(!value["TotalCount"].isNull())
 		totalCount_ = std::stoi(value["TotalCount"].asString());
 

sddp/src/model/DescribeRiskLevelsRequest.cc

@@ -1,62 +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.
- */
-
-#include <alibabacloud/sddp/model/DescribeRiskLevelsRequest.h>
-
-using AlibabaCloud::Sddp::Model::DescribeRiskLevelsRequest;
-
-DescribeRiskLevelsRequest::DescribeRiskLevelsRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "DescribeRiskLevels")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeRiskLevelsRequest::~DescribeRiskLevelsRequest()
-{}
-
-int DescribeRiskLevelsRequest::getCustomType()const
-{
-	return customType_;
+ */
+
+#include <alibabacloud/sddp/model/DescribeRiskLevelsRequest.h>
+
+using AlibabaCloud::Sddp::Model::DescribeRiskLevelsRequest;
+
+DescribeRiskLevelsRequest::DescribeRiskLevelsRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "DescribeRiskLevels") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeRiskLevelsRequest::setCustomType(int customType)
-{
-	customType_ = customType;
-	setParameter("CustomType", std::to_string(customType));
+DescribeRiskLevelsRequest::~DescribeRiskLevelsRequest() {}
+
+int DescribeRiskLevelsRequest::getCustomType() const {
+  return customType_;
 }
 
-std::string DescribeRiskLevelsRequest::getSourceIp()const
-{
-	return sourceIp_;
+void DescribeRiskLevelsRequest::setCustomType(int customType) {
+  customType_ = customType;
+  setParameter(std::string("CustomType"), std::to_string(customType));
 }
 
-void DescribeRiskLevelsRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+std::string DescribeRiskLevelsRequest::getSourceIp() const {
+  return sourceIp_;
 }
 
-std::string DescribeRiskLevelsRequest::getLang()const
-{
-	return lang_;
+void DescribeRiskLevelsRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
 }
 
-void DescribeRiskLevelsRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
+std::string DescribeRiskLevelsRequest::getLang() const {
+  return lang_;
+}
+
+void DescribeRiskLevelsRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 

sddp/src/model/DescribeRiskLevelsResult.cc

@@ -43,14 +43,14 @@ void DescribeRiskLevelsResult::parse(const std::string &payload)
 	for (auto valueRiskLevelListRiskLevel : allRiskLevelListNode)
 	{
 		RiskLevel riskLevelListObject;
-		if(!valueRiskLevelListRiskLevel["Id"].isNull())
-			riskLevelListObject.id = std::stol(valueRiskLevelListRiskLevel["Id"].asString());
-		if(!valueRiskLevelListRiskLevel["Description"].isNull())
-			riskLevelListObject.description = valueRiskLevelListRiskLevel["Description"].asString();
 		if(!valueRiskLevelListRiskLevel["Name"].isNull())
 			riskLevelListObject.name = valueRiskLevelListRiskLevel["Name"].asString();
+		if(!valueRiskLevelListRiskLevel["Description"].isNull())
+			riskLevelListObject.description = valueRiskLevelListRiskLevel["Description"].asString();
 		if(!valueRiskLevelListRiskLevel["Alias"].isNull())
 			riskLevelListObject.alias = valueRiskLevelListRiskLevel["Alias"].asString();
+		if(!valueRiskLevelListRiskLevel["Id"].isNull())
+			riskLevelListObject.id = std::stol(valueRiskLevelListRiskLevel["Id"].asString());
 		if(!valueRiskLevelListRiskLevel["ReferenceNum"].isNull())
 			riskLevelListObject.referenceNum = std::stoi(valueRiskLevelListRiskLevel["ReferenceNum"].asString());
 		riskLevelList_.push_back(riskLevelListObject);

sddp/src/model/DescribeRuleCategoryRequest.cc

@@ -1,62 +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/sddp/model/DescribeRuleCategoryRequest.h>
-
-using AlibabaCloud::Sddp::Model::DescribeRuleCategoryRequest;
-
-DescribeRuleCategoryRequest::DescribeRuleCategoryRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "DescribeRuleCategory")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeRuleCategoryRequest::~DescribeRuleCategoryRequest()
-{}
-
-long DescribeRuleCategoryRequest::getProductId()const
-{
-	return productId_;
-}
-
-void DescribeRuleCategoryRequest::setProductId(long productId)
-{
-	productId_ = productId;
-	setParameter("ProductId", std::to_string(productId));
-}
-
-std::string DescribeRuleCategoryRequest::getSourceIp()const
-{
-	return sourceIp_;
-}
-
-void DescribeRuleCategoryRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
-}
-
-std::string DescribeRuleCategoryRequest::getLang()const
-{
-	return lang_;
-}
-
-void DescribeRuleCategoryRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
-}
-

sddp/src/model/DescribeRuleCategoryResult.cc

@@ -1,88 +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/sddp/model/DescribeRuleCategoryResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Sddp;
-using namespace AlibabaCloud::Sddp::Model;
-
-DescribeRuleCategoryResult::DescribeRuleCategoryResult() :
-	ServiceResult()
-{}
-
-DescribeRuleCategoryResult::DescribeRuleCategoryResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-DescribeRuleCategoryResult::~DescribeRuleCategoryResult()
-{}
-
-void DescribeRuleCategoryResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto allRuleListNode = value["RuleList"]["Rule"];
-	for (auto valueRuleListRule : allRuleListNode)
-	{
-		Rule ruleListObject;
-		if(!valueRuleListRule["GroupId"].isNull())
-			ruleListObject.groupId = valueRuleListRule["GroupId"].asString();
-		if(!valueRuleListRule["Name"].isNull())
-			ruleListObject.name = valueRuleListRule["Name"].asString();
-		auto allChildListNode = valueRuleListRule["ChildList"]["ChildRule"];
-		for (auto valueRuleListRuleChildListChildRule : allChildListNode)
-		{
-			Rule::ChildRule childListObject;
-			if(!valueRuleListRuleChildListChildRule["Id"].isNull())
-				childListObject.id = std::stol(valueRuleListRuleChildListChildRule["Id"].asString());
-			if(!valueRuleListRuleChildListChildRule["GroupId"].isNull())
-				childListObject.groupId = valueRuleListRuleChildListChildRule["GroupId"].asString();
-			if(!valueRuleListRuleChildListChildRule["Name"].isNull())
-				childListObject.name = valueRuleListRuleChildListChildRule["Name"].asString();
-			if(!valueRuleListRuleChildListChildRule["ParentId"].isNull())
-				childListObject.parentId = valueRuleListRuleChildListChildRule["ParentId"].asString();
-			ruleListObject.childList.push_back(childListObject);
-		}
-		ruleList_.push_back(ruleListObject);
-	}
-	auto allProductListNode = value["ProductList"]["Product"];
-	for (auto valueProductListProduct : allProductListNode)
-	{
-		Product productListObject;
-		if(!valueProductListProduct["value"].isNull())
-			productListObject.value = valueProductListProduct["value"].asString();
-		if(!valueProductListProduct["label"].isNull())
-			productListObject.label = valueProductListProduct["label"].asString();
-		productList_.push_back(productListObject);
-	}
-
-}
-
-std::vector<DescribeRuleCategoryResult::Product> DescribeRuleCategoryResult::getProductList()const
-{
-	return productList_;
-}
-
-std::vector<DescribeRuleCategoryResult::Rule> DescribeRuleCategoryResult::getRuleList()const
-{
-	return ruleList_;
-}
-

sddp/src/model/DescribeRulesRequest.cc

@@ -1,205 +1,171 @@
 /*
  * 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/sddp/model/DescribeRulesRequest.h>
-
-using AlibabaCloud::Sddp::Model::DescribeRulesRequest;
-
-DescribeRulesRequest::DescribeRulesRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "DescribeRules")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeRulesRequest::~DescribeRulesRequest()
-{}
-
-int DescribeRulesRequest::getWarnLevel()const
-{
-	return warnLevel_;
+ */
+
+#include <alibabacloud/sddp/model/DescribeRulesRequest.h>
+
+using AlibabaCloud::Sddp::Model::DescribeRulesRequest;
+
+DescribeRulesRequest::DescribeRulesRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "DescribeRules") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeRulesRequest::setWarnLevel(int warnLevel)
-{
-	warnLevel_ = warnLevel;
-	setParameter("WarnLevel", std::to_string(warnLevel));
+DescribeRulesRequest::~DescribeRulesRequest() {}
+
+int DescribeRulesRequest::getWarnLevel() const {
+  return warnLevel_;
 }
 
-int DescribeRulesRequest::getProductCode()const
-{
-	return productCode_;
+void DescribeRulesRequest::setWarnLevel(int warnLevel) {
+  warnLevel_ = warnLevel;
+  setParameter(std::string("WarnLevel"), std::to_string(warnLevel));
 }
 
-void DescribeRulesRequest::setProductCode(int productCode)
-{
-	productCode_ = productCode;
-	setParameter("ProductCode", std::to_string(productCode));
+int DescribeRulesRequest::getProductCode() const {
+  return productCode_;
 }
 
-long DescribeRulesRequest::getProductId()const
-{
-	return productId_;
+void DescribeRulesRequest::setProductCode(int productCode) {
+  productCode_ = productCode;
+  setParameter(std::string("ProductCode"), std::to_string(productCode));
 }
 
-void DescribeRulesRequest::setProductId(long productId)
-{
-	productId_ = productId;
-	setParameter("ProductId", std::to_string(productId));
+long DescribeRulesRequest::getProductId() const {
+  return productId_;
 }
 
-long DescribeRulesRequest::getRiskLevelId()const
-{
-	return riskLevelId_;
+void DescribeRulesRequest::setProductId(long productId) {
+  productId_ = productId;
+  setParameter(std::string("ProductId"), std::to_string(productId));
 }
 
-void DescribeRulesRequest::setRiskLevelId(long riskLevelId)
-{
-	riskLevelId_ = riskLevelId;
-	setParameter("RiskLevelId", std::to_string(riskLevelId));
+long DescribeRulesRequest::getRiskLevelId() const {
+  return riskLevelId_;
 }
 
-std::string DescribeRulesRequest::getSourceIp()const
-{
-	return sourceIp_;
+void DescribeRulesRequest::setRiskLevelId(long riskLevelId) {
+  riskLevelId_ = riskLevelId;
+  setParameter(std::string("RiskLevelId"), std::to_string(riskLevelId));
 }
 
-void DescribeRulesRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+std::string DescribeRulesRequest::getSourceIp() const {
+  return sourceIp_;
 }
 
-int DescribeRulesRequest::getPageSize()const
-{
-	return pageSize_;
+void DescribeRulesRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
 }
 
-void DescribeRulesRequest::setPageSize(int pageSize)
-{
-	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
+int DescribeRulesRequest::getPageSize() const {
+  return pageSize_;
 }
 
-std::string DescribeRulesRequest::getLang()const
-{
-	return lang_;
+void DescribeRulesRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
 }
 
-void DescribeRulesRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
+std::string DescribeRulesRequest::getLang() const {
+  return lang_;
 }
 
-bool DescribeRulesRequest::getKeywordCompatible()const
-{
-	return keywordCompatible_;
+void DescribeRulesRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 
-void DescribeRulesRequest::setKeywordCompatible(bool keywordCompatible)
-{
-	keywordCompatible_ = keywordCompatible;
-	setParameter("KeywordCompatible", keywordCompatible ? "true" : "false");
+bool DescribeRulesRequest::getKeywordCompatible() const {
+  return keywordCompatible_;
 }
 
-int DescribeRulesRequest::getRuleType()const
-{
-	return ruleType_;
+void DescribeRulesRequest::setKeywordCompatible(bool keywordCompatible) {
+  keywordCompatible_ = keywordCompatible;
+  setParameter(std::string("KeywordCompatible"), keywordCompatible ? "true" : "false");
 }
 
-void DescribeRulesRequest::setRuleType(int ruleType)
-{
-	ruleType_ = ruleType;
-	setParameter("RuleType", std::to_string(ruleType));
+int DescribeRulesRequest::getRuleType() const {
+  return ruleType_;
 }
 
-std::string DescribeRulesRequest::getGroupId()const
-{
-	return groupId_;
+void DescribeRulesRequest::setRuleType(int ruleType) {
+  ruleType_ = ruleType;
+  setParameter(std::string("RuleType"), std::to_string(ruleType));
 }
 
-void DescribeRulesRequest::setGroupId(const std::string& groupId)
-{
-	groupId_ = groupId;
-	setParameter("GroupId", groupId);
+std::string DescribeRulesRequest::getGroupId() const {
+  return groupId_;
 }
 
-int DescribeRulesRequest::getContentCategory()const
-{
-	return contentCategory_;
+void DescribeRulesRequest::setGroupId(const std::string &groupId) {
+  groupId_ = groupId;
+  setParameter(std::string("GroupId"), groupId);
 }
 
-void DescribeRulesRequest::setContentCategory(int contentCategory)
-{
-	contentCategory_ = contentCategory;
-	setParameter("ContentCategory", std::to_string(contentCategory));
+int DescribeRulesRequest::getContentCategory() const {
+  return contentCategory_;
 }
 
-int DescribeRulesRequest::getCurrentPage()const
-{
-	return currentPage_;
+void DescribeRulesRequest::setContentCategory(int contentCategory) {
+  contentCategory_ = contentCategory;
+  setParameter(std::string("ContentCategory"), std::to_string(contentCategory));
 }
 
-void DescribeRulesRequest::setCurrentPage(int currentPage)
-{
-	currentPage_ = currentPage;
-	setParameter("CurrentPage", std::to_string(currentPage));
+int DescribeRulesRequest::getCurrentPage() const {
+  return currentPage_;
 }
 
-int DescribeRulesRequest::getCustomType()const
-{
-	return customType_;
+void DescribeRulesRequest::setCurrentPage(int currentPage) {
+  currentPage_ = currentPage;
+  setParameter(std::string("CurrentPage"), std::to_string(currentPage));
 }
 
-void DescribeRulesRequest::setCustomType(int customType)
-{
-	customType_ = customType;
-	setParameter("CustomType", std::to_string(customType));
+int DescribeRulesRequest::getCustomType() const {
+  return customType_;
 }
 
-std::string DescribeRulesRequest::getName()const
-{
-	return name_;
+void DescribeRulesRequest::setCustomType(int customType) {
+  customType_ = customType;
+  setParameter(std::string("CustomType"), std::to_string(customType));
 }
 
-void DescribeRulesRequest::setName(const std::string& name)
-{
-	name_ = name;
-	setParameter("Name", name);
+std::string DescribeRulesRequest::getName() const {
+  return name_;
 }
 
-int DescribeRulesRequest::getCategory()const
-{
-	return category_;
+void DescribeRulesRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
 }
 
-void DescribeRulesRequest::setCategory(int category)
-{
-	category_ = category;
-	setParameter("Category", std::to_string(category));
+int DescribeRulesRequest::getCategory() const {
+  return category_;
 }
 
-int DescribeRulesRequest::getStatus()const
-{
-	return status_;
+void DescribeRulesRequest::setCategory(int category) {
+  category_ = category;
+  setParameter(std::string("Category"), std::to_string(category));
 }
 
-void DescribeRulesRequest::setStatus(int status)
-{
-	status_ = status;
-	setParameter("Status", std::to_string(status));
+int DescribeRulesRequest::getStatus() const {
+  return status_;
+}
+
+void DescribeRulesRequest::setStatus(int status) {
+  status_ = status;
+  setParameter(std::string("Status"), std::to_string(status));
 }
 

sddp/src/model/DescribeRulesResult.cc

@@ -43,62 +43,62 @@ void DescribeRulesResult::parse(const std::string &payload)
 	for (auto valueItemsRule : allItemsNode)
 	{
 		Rule itemsObject;
-		if(!valueItemsRule["Id"].isNull())
-			itemsObject.id = std::stol(valueItemsRule["Id"].asString());
-		if(!valueItemsRule["GmtCreate"].isNull())
-			itemsObject.gmtCreate = std::stol(valueItemsRule["GmtCreate"].asString());
-		if(!valueItemsRule["GmtModified"].isNull())
-			itemsObject.gmtModified = std::stol(valueItemsRule["GmtModified"].asString());
-		if(!valueItemsRule["CustomType"].isNull())
-			itemsObject.customType = std::stoi(valueItemsRule["CustomType"].asString());
-		if(!valueItemsRule["Name"].isNull())
-			itemsObject.name = valueItemsRule["Name"].asString();
-		if(!valueItemsRule["Description"].isNull())
-			itemsObject.description = valueItemsRule["Description"].asString();
-		if(!valueItemsRule["UserId"].isNull())
-			itemsObject.userId = std::stol(valueItemsRule["UserId"].asString());
-		if(!valueItemsRule["LoginName"].isNull())
-			itemsObject.loginName = valueItemsRule["LoginName"].asString();
 		if(!valueItemsRule["DisplayName"].isNull())
 			itemsObject.displayName = valueItemsRule["DisplayName"].asString();
-		if(!valueItemsRule["Category"].isNull())
-			itemsObject.category = std::stoi(valueItemsRule["Category"].asString());
-		if(!valueItemsRule["CategoryName"].isNull())
-			itemsObject.categoryName = valueItemsRule["CategoryName"].asString();
 		if(!valueItemsRule["Status"].isNull())
 			itemsObject.status = std::stoi(valueItemsRule["Status"].asString());
-		if(!valueItemsRule["RiskLevelName"].isNull())
-			itemsObject.riskLevelName = valueItemsRule["RiskLevelName"].asString();
-		if(!valueItemsRule["RiskLevelId"].isNull())
-			itemsObject.riskLevelId = std::stol(valueItemsRule["RiskLevelId"].asString());
-		if(!valueItemsRule["Content"].isNull())
-			itemsObject.content = valueItemsRule["Content"].asString();
+		if(!valueItemsRule["WarnLevel"].isNull())
+			itemsObject.warnLevel = std::stoi(valueItemsRule["WarnLevel"].asString());
+		if(!valueItemsRule["UserId"].isNull())
+			itemsObject.userId = std::stol(valueItemsRule["UserId"].asString());
 		if(!valueItemsRule["DepartName"].isNull())
 			itemsObject.departName = valueItemsRule["DepartName"].asString();
 		if(!valueItemsRule["StatExpress"].isNull())
 			itemsObject.statExpress = valueItemsRule["StatExpress"].asString();
+		if(!valueItemsRule["GmtModified"].isNull())
+			itemsObject.gmtModified = std::stol(valueItemsRule["GmtModified"].asString());
+		if(!valueItemsRule["RiskLevelId"].isNull())
+			itemsObject.riskLevelId = std::stol(valueItemsRule["RiskLevelId"].asString());
+		if(!valueItemsRule["Description"].isNull())
+			itemsObject.description = valueItemsRule["Description"].asString();
 		if(!valueItemsRule["ProductId"].isNull())
 			itemsObject.productId = std::stol(valueItemsRule["ProductId"].asString());
-		if(!valueItemsRule["HitTotalCount"].isNull())
-			itemsObject.hitTotalCount = std::stoi(valueItemsRule["HitTotalCount"].asString());
-		if(!valueItemsRule["ProductCode"].isNull())
-			itemsObject.productCode = valueItemsRule["ProductCode"].asString();
-		if(!valueItemsRule["WarnLevel"].isNull())
-			itemsObject.warnLevel = std::stoi(valueItemsRule["WarnLevel"].asString());
-		if(!valueItemsRule["MajorKey"].isNull())
-			itemsObject.majorKey = valueItemsRule["MajorKey"].asString();
-		if(!valueItemsRule["ContentCategory"].isNull())
-			itemsObject.contentCategory = valueItemsRule["ContentCategory"].asString();
+		if(!valueItemsRule["Name"].isNull())
+			itemsObject.name = valueItemsRule["Name"].asString();
+		if(!valueItemsRule["Content"].isNull())
+			itemsObject.content = valueItemsRule["Content"].asString();
 		if(!valueItemsRule["Target"].isNull())
 			itemsObject.target = valueItemsRule["Target"].asString();
+		if(!valueItemsRule["LoginName"].isNull())
+			itemsObject.loginName = valueItemsRule["LoginName"].asString();
+		if(!valueItemsRule["CategoryName"].isNull())
+			itemsObject.categoryName = valueItemsRule["CategoryName"].asString();
+		if(!valueItemsRule["ContentCategory"].isNull())
+			itemsObject.contentCategory = valueItemsRule["ContentCategory"].asString();
+		if(!valueItemsRule["HitTotalCount"].isNull())
+			itemsObject.hitTotalCount = std::stoi(valueItemsRule["HitTotalCount"].asString());
 		if(!valueItemsRule["GroupId"].isNull())
 			itemsObject.groupId = valueItemsRule["GroupId"].asString();
+		if(!valueItemsRule["CustomType"].isNull())
+			itemsObject.customType = std::stoi(valueItemsRule["CustomType"].asString());
+		if(!valueItemsRule["RiskLevelName"].isNull())
+			itemsObject.riskLevelName = valueItemsRule["RiskLevelName"].asString();
+		if(!valueItemsRule["GmtCreate"].isNull())
+			itemsObject.gmtCreate = std::stol(valueItemsRule["GmtCreate"].asString());
+		if(!valueItemsRule["Category"].isNull())
+			itemsObject.category = std::stoi(valueItemsRule["Category"].asString());
+		if(!valueItemsRule["MajorKey"].isNull())
+			itemsObject.majorKey = valueItemsRule["MajorKey"].asString();
+		if(!valueItemsRule["Id"].isNull())
+			itemsObject.id = std::stol(valueItemsRule["Id"].asString());
+		if(!valueItemsRule["ProductCode"].isNull())
+			itemsObject.productCode = valueItemsRule["ProductCode"].asString();
 		items_.push_back(itemsObject);
 	}
-	if(!value["PageSize"].isNull())
-		pageSize_ = std::stoi(value["PageSize"].asString());
 	if(!value["CurrentPage"].isNull())
 		currentPage_ = std::stoi(value["CurrentPage"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
 	if(!value["TotalCount"].isNull())
 		totalCount_ = std::stoi(value["TotalCount"].asString());
 

sddp/src/model/DescribeTablesRequest.cc

@@ -1,326 +1,270 @@
 /*
  * 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/sddp/model/DescribeTablesRequest.h>
-
-using AlibabaCloud::Sddp::Model::DescribeTablesRequest;
-
-DescribeTablesRequest::DescribeTablesRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "DescribeTables")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeTablesRequest::~DescribeTablesRequest()
-{}
-
-std::string DescribeTablesRequest::getProductCode()const
-{
-	return productCode_;
+ */
+
+#include <alibabacloud/sddp/model/DescribeTablesRequest.h>
+
+using AlibabaCloud::Sddp::Model::DescribeTablesRequest;
+
+DescribeTablesRequest::DescribeTablesRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "DescribeTables") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeTablesRequest::setProductCode(const std::string& productCode)
-{
-	productCode_ = productCode;
-	setParameter("ProductCode", productCode);
+DescribeTablesRequest::~DescribeTablesRequest() {}
+
+std::string DescribeTablesRequest::getProductCode() const {
+  return productCode_;
 }
 
-long DescribeTablesRequest::getProductId()const
-{
-	return productId_;
+void DescribeTablesRequest::setProductCode(const std::string &productCode) {
+  productCode_ = productCode;
+  setParameter(std::string("ProductCode"), productCode);
 }
 
-void DescribeTablesRequest::setProductId(long productId)
-{
-	productId_ = productId;
-	setParameter("ProductId", std::to_string(productId));
+long DescribeTablesRequest::getProductId() const {
+  return productId_;
 }
 
-std::string DescribeTablesRequest::getRiskLevels()const
-{
-	return riskLevels_;
+void DescribeTablesRequest::setProductId(long productId) {
+  productId_ = productId;
+  setParameter(std::string("ProductId"), std::to_string(productId));
 }
 
-void DescribeTablesRequest::setRiskLevels(const std::string& riskLevels)
-{
-	riskLevels_ = riskLevels;
-	setParameter("RiskLevels", riskLevels);
+std::string DescribeTablesRequest::getRiskLevels() const {
+  return riskLevels_;
 }
 
-bool DescribeTablesRequest::getNeedRiskCount()const
-{
-	return needRiskCount_;
+void DescribeTablesRequest::setRiskLevels(const std::string &riskLevels) {
+  riskLevels_ = riskLevels;
+  setParameter(std::string("RiskLevels"), riskLevels);
 }
 
-void DescribeTablesRequest::setNeedRiskCount(bool needRiskCount)
-{
-	needRiskCount_ = needRiskCount;
-	setParameter("NeedRiskCount", needRiskCount ? "true" : "false");
+bool DescribeTablesRequest::getNeedRiskCount() const {
+  return needRiskCount_;
 }
 
-long DescribeTablesRequest::getPackageId()const
-{
-	return packageId_;
+void DescribeTablesRequest::setNeedRiskCount(bool needRiskCount) {
+  needRiskCount_ = needRiskCount;
+  setParameter(std::string("NeedRiskCount"), needRiskCount ? "true" : "false");
 }
 
-void DescribeTablesRequest::setPackageId(long packageId)
-{
-	packageId_ = packageId;
-	setParameter("PackageId", std::to_string(packageId));
+long DescribeTablesRequest::getPackageId() const {
+  return packageId_;
 }
 
-std::string DescribeTablesRequest::getRuleName()const
-{
-	return ruleName_;
+void DescribeTablesRequest::setPackageId(long packageId) {
+  packageId_ = packageId;
+  setParameter(std::string("PackageId"), std::to_string(packageId));
 }
 
-void DescribeTablesRequest::setRuleName(const std::string& ruleName)
-{
-	ruleName_ = ruleName;
-	setParameter("RuleName", ruleName);
+std::string DescribeTablesRequest::getRuleName() const {
+  return ruleName_;
 }
 
-std::string DescribeTablesRequest::getQueryName()const
-{
-	return queryName_;
+void DescribeTablesRequest::setRuleName(const std::string &ruleName) {
+  ruleName_ = ruleName;
+  setParameter(std::string("RuleName"), ruleName);
 }
 
-void DescribeTablesRequest::setQueryName(const std::string& queryName)
-{
-	queryName_ = queryName;
-	setParameter("QueryName", queryName);
+std::string DescribeTablesRequest::getQueryName() const {
+  return queryName_;
 }
 
-long DescribeTablesRequest::getRiskLevelId()const
-{
-	return riskLevelId_;
+void DescribeTablesRequest::setQueryName(const std::string &queryName) {
+  queryName_ = queryName;
+  setParameter(std::string("QueryName"), queryName);
 }
 
-void DescribeTablesRequest::setRiskLevelId(long riskLevelId)
-{
-	riskLevelId_ = riskLevelId;
-	setParameter("RiskLevelId", std::to_string(riskLevelId));
+long DescribeTablesRequest::getRiskLevelId() const {
+  return riskLevelId_;
 }
 
-long DescribeTablesRequest::getStartTime()const
-{
-	return startTime_;
+void DescribeTablesRequest::setRiskLevelId(long riskLevelId) {
+  riskLevelId_ = riskLevelId;
+  setParameter(std::string("RiskLevelId"), std::to_string(riskLevelId));
 }
 
-void DescribeTablesRequest::setStartTime(long startTime)
-{
-	startTime_ = startTime;
-	setParameter("StartTime", std::to_string(startTime));
+long DescribeTablesRequest::getStartTime() const {
+  return startTime_;
 }
 
-long DescribeTablesRequest::getLastScanTimeEnd()const
-{
-	return lastScanTimeEnd_;
+void DescribeTablesRequest::setStartTime(long startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), std::to_string(startTime));
 }
 
-void DescribeTablesRequest::setLastScanTimeEnd(long lastScanTimeEnd)
-{
-	lastScanTimeEnd_ = lastScanTimeEnd;
-	setParameter("LastScanTimeEnd", std::to_string(lastScanTimeEnd));
+long DescribeTablesRequest::getLastScanTimeEnd() const {
+  return lastScanTimeEnd_;
 }
 
-long DescribeTablesRequest::getLastScanTimeStart()const
-{
-	return lastScanTimeStart_;
+void DescribeTablesRequest::setLastScanTimeEnd(long lastScanTimeEnd) {
+  lastScanTimeEnd_ = lastScanTimeEnd;
+  setParameter(std::string("LastScanTimeEnd"), std::to_string(lastScanTimeEnd));
 }
 
-void DescribeTablesRequest::setLastScanTimeStart(long lastScanTimeStart)
-{
-	lastScanTimeStart_ = lastScanTimeStart;
-	setParameter("LastScanTimeStart", std::to_string(lastScanTimeStart));
+long DescribeTablesRequest::getLastScanTimeStart() const {
+  return lastScanTimeStart_;
 }
 
-std::string DescribeTablesRequest::getSensLevelName()const
-{
-	return sensLevelName_;
+void DescribeTablesRequest::setLastScanTimeStart(long lastScanTimeStart) {
+  lastScanTimeStart_ = lastScanTimeStart;
+  setParameter(std::string("LastScanTimeStart"), std::to_string(lastScanTimeStart));
 }
 
-void DescribeTablesRequest::setSensLevelName(const std::string& sensLevelName)
-{
-	sensLevelName_ = sensLevelName;
-	setParameter("SensLevelName", sensLevelName);
+std::string DescribeTablesRequest::getSensLevelName() const {
+  return sensLevelName_;
 }
 
-std::string DescribeTablesRequest::getSourceIp()const
-{
-	return sourceIp_;
+void DescribeTablesRequest::setSensLevelName(const std::string &sensLevelName) {
+  sensLevelName_ = sensLevelName;
+  setParameter(std::string("SensLevelName"), sensLevelName);
 }
 
-void DescribeTablesRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+std::string DescribeTablesRequest::getSourceIp() const {
+  return sourceIp_;
 }
 
-int DescribeTablesRequest::getPageSize()const
-{
-	return pageSize_;
+void DescribeTablesRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
 }
 
-void DescribeTablesRequest::setPageSize(int pageSize)
-{
-	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
+int DescribeTablesRequest::getPageSize() const {
+  return pageSize_;
 }
 
-std::string DescribeTablesRequest::getInstanceDescription()const
-{
-	return instanceDescription_;
+void DescribeTablesRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
 }
 
-void DescribeTablesRequest::setInstanceDescription(const std::string& instanceDescription)
-{
-	instanceDescription_ = instanceDescription;
-	setParameter("InstanceDescription", instanceDescription);
+std::string DescribeTablesRequest::getInstanceDescription() const {
+  return instanceDescription_;
 }
 
-std::string DescribeTablesRequest::getLang()const
-{
-	return lang_;
+void DescribeTablesRequest::setInstanceDescription(const std::string &instanceDescription) {
+  instanceDescription_ = instanceDescription;
+  setParameter(std::string("InstanceDescription"), instanceDescription);
 }
 
-void DescribeTablesRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
+std::string DescribeTablesRequest::getLang() const {
+  return lang_;
 }
 
-int DescribeTablesRequest::getQueryType()const
-{
-	return queryType_;
+void DescribeTablesRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 
-void DescribeTablesRequest::setQueryType(int queryType)
-{
-	queryType_ = queryType;
-	setParameter("QueryType", std::to_string(queryType));
+int DescribeTablesRequest::getQueryType() const {
+  return queryType_;
 }
 
-std::string DescribeTablesRequest::getServiceRegionId()const
-{
-	return serviceRegionId_;
+void DescribeTablesRequest::setQueryType(int queryType) {
+  queryType_ = queryType;
+  setParameter(std::string("QueryType"), std::to_string(queryType));
 }
 
-void DescribeTablesRequest::setServiceRegionId(const std::string& serviceRegionId)
-{
-	serviceRegionId_ = serviceRegionId;
-	setParameter("ServiceRegionId", serviceRegionId);
+std::string DescribeTablesRequest::getServiceRegionId() const {
+  return serviceRegionId_;
 }
 
-int DescribeTablesRequest::getFeatureType()const
-{
-	return featureType_;
+void DescribeTablesRequest::setServiceRegionId(const std::string &serviceRegionId) {
+  serviceRegionId_ = serviceRegionId;
+  setParameter(std::string("ServiceRegionId"), serviceRegionId);
 }
 
-void DescribeTablesRequest::setFeatureType(int featureType)
-{
-	featureType_ = featureType;
-	setParameter("FeatureType", std::to_string(featureType));
+int DescribeTablesRequest::getFeatureType() const {
+  return featureType_;
 }
 
-std::string DescribeTablesRequest::getOrderBy()const
-{
-	return orderBy_;
+void DescribeTablesRequest::setFeatureType(int featureType) {
+  featureType_ = featureType;
+  setParameter(std::string("FeatureType"), std::to_string(featureType));
 }
 
-void DescribeTablesRequest::setOrderBy(const std::string& orderBy)
-{
-	orderBy_ = orderBy;
-	setParameter("OrderBy", orderBy);
+std::string DescribeTablesRequest::getOrderBy() const {
+  return orderBy_;
 }
 
-long DescribeTablesRequest::getEndTime()const
-{
-	return endTime_;
+void DescribeTablesRequest::setOrderBy(const std::string &orderBy) {
+  orderBy_ = orderBy;
+  setParameter(std::string("OrderBy"), orderBy);
 }
 
-void DescribeTablesRequest::setEndTime(long endTime)
-{
-	endTime_ = endTime;
-	setParameter("EndTime", std::to_string(endTime));
+long DescribeTablesRequest::getEndTime() const {
+  return endTime_;
 }
 
-int DescribeTablesRequest::getCurrentPage()const
-{
-	return currentPage_;
+void DescribeTablesRequest::setEndTime(long endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), std::to_string(endTime));
 }
 
-void DescribeTablesRequest::setCurrentPage(int currentPage)
-{
-	currentPage_ = currentPage;
-	setParameter("CurrentPage", std::to_string(currentPage));
+int DescribeTablesRequest::getCurrentPage() const {
+  return currentPage_;
 }
 
-std::string DescribeTablesRequest::getRuleIds()const
-{
-	return ruleIds_;
+void DescribeTablesRequest::setCurrentPage(int currentPage) {
+  currentPage_ = currentPage;
+  setParameter(std::string("CurrentPage"), std::to_string(currentPage));
 }
 
-void DescribeTablesRequest::setRuleIds(const std::string& ruleIds)
-{
-	ruleIds_ = ruleIds;
-	setParameter("RuleIds", ruleIds);
+std::string DescribeTablesRequest::getRuleIds() const {
+  return ruleIds_;
 }
 
-long DescribeTablesRequest::getInstanceId()const
-{
-	return instanceId_;
+void DescribeTablesRequest::setRuleIds(const std::string &ruleIds) {
+  ruleIds_ = ruleIds;
+  setParameter(std::string("RuleIds"), ruleIds);
 }
 
-void DescribeTablesRequest::setInstanceId(long instanceId)
-{
-	instanceId_ = instanceId;
-	setParameter("InstanceId", std::to_string(instanceId));
+long DescribeTablesRequest::getInstanceId() const {
+  return instanceId_;
 }
 
-std::string DescribeTablesRequest::getInstanceName()const
-{
-	return instanceName_;
+void DescribeTablesRequest::setInstanceId(long instanceId) {
+  instanceId_ = instanceId;
+  setParameter(std::string("InstanceId"), std::to_string(instanceId));
 }
 
-void DescribeTablesRequest::setInstanceName(const std::string& instanceName)
-{
-	instanceName_ = instanceName;
-	setParameter("InstanceName", instanceName);
+std::string DescribeTablesRequest::getInstanceName() const {
+  return instanceName_;
 }
 
-std::string DescribeTablesRequest::getName()const
-{
-	return name_;
+void DescribeTablesRequest::setInstanceName(const std::string &instanceName) {
+  instanceName_ = instanceName;
+  setParameter(std::string("InstanceName"), instanceName);
 }
 
-void DescribeTablesRequest::setName(const std::string& name)
-{
-	name_ = name;
-	setParameter("Name", name);
+std::string DescribeTablesRequest::getName() const {
+  return name_;
 }
 
-long DescribeTablesRequest::getRuleId()const
-{
-	return ruleId_;
+void DescribeTablesRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
 }
 
-void DescribeTablesRequest::setRuleId(long ruleId)
-{
-	ruleId_ = ruleId;
-	setParameter("RuleId", std::to_string(ruleId));
+long DescribeTablesRequest::getRuleId() const {
+  return ruleId_;
+}
+
+void DescribeTablesRequest::setRuleId(long ruleId) {
+  ruleId_ = ruleId;
+  setParameter(std::string("RuleId"), std::to_string(ruleId));
 }
 

sddp/src/model/DescribeTablesResult.cc

@@ -43,76 +43,80 @@ void DescribeTablesResult::parse(const std::string &payload)
 	for (auto valueItemsTable : allItemsNode)
 	{
 		Table itemsObject;
-		if(!valueItemsTable["Id"].isNull())
-			itemsObject.id = std::stol(valueItemsTable["Id"].asString());
-		if(!valueItemsTable["Name"].isNull())
-			itemsObject.name = valueItemsTable["Name"].asString();
-		if(!valueItemsTable["Owner"].isNull())
-			itemsObject.owner = valueItemsTable["Owner"].asString();
 		if(!valueItemsTable["CreationTime"].isNull())
 			itemsObject.creationTime = std::stol(valueItemsTable["CreationTime"].asString());
-		if(!valueItemsTable["ProductId"].isNull())
-			itemsObject.productId = valueItemsTable["ProductId"].asString();
-		if(!valueItemsTable["ProductCode"].isNull())
-			itemsObject.productCode = valueItemsTable["ProductCode"].asString();
-		if(!valueItemsTable["Sensitive"].isNull())
-			itemsObject.sensitive = valueItemsTable["Sensitive"].asString() == "true";
-		if(!valueItemsTable["RiskLevelId"].isNull())
-			itemsObject.riskLevelId = std::stol(valueItemsTable["RiskLevelId"].asString());
-		if(!valueItemsTable["RiskLevelName"].isNull())
-			itemsObject.riskLevelName = valueItemsTable["RiskLevelName"].asString();
-		if(!valueItemsTable["DepartName"].isNull())
-			itemsObject.departName = valueItemsTable["DepartName"].asString();
-		if(!valueItemsTable["TotalCount"].isNull())
-			itemsObject.totalCount = std::stoi(valueItemsTable["TotalCount"].asString());
-		if(!valueItemsTable["SensitiveCount"].isNull())
-			itemsObject.sensitiveCount = std::stoi(valueItemsTable["SensitiveCount"].asString());
+		if(!valueItemsTable["Owner"].isNull())
+			itemsObject.owner = valueItemsTable["Owner"].asString();
+		if(!valueItemsTable["CountDetails"].isNull())
+			itemsObject.countDetails = valueItemsTable["CountDetails"].asString();
 		if(!valueItemsTable["SensitiveRatio"].isNull())
 			itemsObject.sensitiveRatio = valueItemsTable["SensitiveRatio"].asString();
-		if(!valueItemsTable["InstanceId"].isNull())
-			itemsObject.instanceId = std::stol(valueItemsTable["InstanceId"].asString());
-		if(!valueItemsTable["S2Count"].isNull())
-			itemsObject.s2Count = std::stoi(valueItemsTable["S2Count"].asString());
+		if(!valueItemsTable["TenantName"].isNull())
+			itemsObject.tenantName = valueItemsTable["TenantName"].asString();
+		if(!valueItemsTable["DepartName"].isNull())
+			itemsObject.departName = valueItemsTable["DepartName"].asString();
+		if(!valueItemsTable["RiskLevelId"].isNull())
+			itemsObject.riskLevelId = std::stol(valueItemsTable["RiskLevelId"].asString());
+		if(!valueItemsTable["InstanceName"].isNull())
+			itemsObject.instanceName = valueItemsTable["InstanceName"].asString();
 		if(!valueItemsTable["S3Count"].isNull())
 			itemsObject.s3Count = std::stoi(valueItemsTable["S3Count"].asString());
 		if(!valueItemsTable["S1Count"].isNull())
 			itemsObject.s1Count = std::stoi(valueItemsTable["S1Count"].asString());
-		if(!valueItemsTable["CountDetails"].isNull())
-			itemsObject.countDetails = valueItemsTable["CountDetails"].asString();
-		if(!valueItemsTable["TotalRows"].isNull())
-			itemsObject.totalRows = std::stoi(valueItemsTable["TotalRows"].asString());
+		if(!valueItemsTable["ProductId"].isNull())
+			itemsObject.productId = valueItemsTable["ProductId"].asString();
+		if(!valueItemsTable["Name"].isNull())
+			itemsObject.name = valueItemsTable["Name"].asString();
+		if(!valueItemsTable["S2Count"].isNull())
+			itemsObject.s2Count = std::stoi(valueItemsTable["S2Count"].asString());
+		if(!valueItemsTable["InstanceId"].isNull())
+			itemsObject.instanceId = std::stol(valueItemsTable["InstanceId"].asString());
+		if(!valueItemsTable["TotalCount"].isNull())
+			itemsObject.totalCount = std::stoi(valueItemsTable["TotalCount"].asString());
+		if(!valueItemsTable["InstanceDescription"].isNull())
+			itemsObject.instanceDescription = valueItemsTable["InstanceDescription"].asString();
+		if(!valueItemsTable["Sensitive"].isNull())
+			itemsObject.sensitive = valueItemsTable["Sensitive"].asString() == "true";
+		if(!valueItemsTable["SensLevelName"].isNull())
+			itemsObject.sensLevelName = valueItemsTable["SensLevelName"].asString();
 		if(!valueItemsTable["LastScanTime"].isNull())
 			itemsObject.lastScanTime = std::stol(valueItemsTable["LastScanTime"].asString());
 		if(!valueItemsTable["RegionName"].isNull())
 			itemsObject.regionName = valueItemsTable["RegionName"].asString();
-		if(!valueItemsTable["InstanceName"].isNull())
-			itemsObject.instanceName = valueItemsTable["InstanceName"].asString();
-		if(!valueItemsTable["SensLevelName"].isNull())
-			itemsObject.sensLevelName = valueItemsTable["SensLevelName"].asString();
-		if(!valueItemsTable["InstanceDescription"].isNull())
-			itemsObject.instanceDescription = valueItemsTable["InstanceDescription"].asString();
-		if(!valueItemsTable["TenantName"].isNull())
-			itemsObject.tenantName = valueItemsTable["TenantName"].asString();
+		if(!valueItemsTable["RiskLevelName"].isNull())
+			itemsObject.riskLevelName = valueItemsTable["RiskLevelName"].asString();
+		if(!valueItemsTable["TotalRows"].isNull())
+			itemsObject.totalRows = std::stoi(valueItemsTable["TotalRows"].asString());
+		if(!valueItemsTable["SensitiveCount"].isNull())
+			itemsObject.sensitiveCount = std::stoi(valueItemsTable["SensitiveCount"].asString());
+		if(!valueItemsTable["Id"].isNull())
+			itemsObject.id = std::stol(valueItemsTable["Id"].asString());
+		if(!valueItemsTable["ProductCode"].isNull())
+			itemsObject.productCode = valueItemsTable["ProductCode"].asString();
+		if(!valueItemsTable["ObjectHex"].isNull())
+			itemsObject.objectHex = valueItemsTable["ObjectHex"].asString();
+		if(!valueItemsTable["DataType"].isNull())
+			itemsObject.dataType = std::stoi(valueItemsTable["DataType"].asString());
 		auto allRuleListNode = valueItemsTable["RuleList"]["Rule"];
 		for (auto valueItemsTableRuleListRule : allRuleListNode)
 		{
 			Table::Rule ruleListObject;
-			if(!valueItemsTableRuleListRule["Name"].isNull())
-				ruleListObject.name = valueItemsTableRuleListRule["Name"].asString();
 			if(!valueItemsTableRuleListRule["DisplayName"].isNull())
 				ruleListObject.displayName = valueItemsTableRuleListRule["DisplayName"].asString();
-			if(!valueItemsTableRuleListRule["Count"].isNull())
-				ruleListObject.count = std::stol(valueItemsTableRuleListRule["Count"].asString());
+			if(!valueItemsTableRuleListRule["Name"].isNull())
+				ruleListObject.name = valueItemsTableRuleListRule["Name"].asString();
 			if(!valueItemsTableRuleListRule["RiskLevelId"].isNull())
 				ruleListObject.riskLevelId = std::stol(valueItemsTableRuleListRule["RiskLevelId"].asString());
+			if(!valueItemsTableRuleListRule["Count"].isNull())
+				ruleListObject.count = std::stol(valueItemsTableRuleListRule["Count"].asString());
 			itemsObject.ruleList.push_back(ruleListObject);
 		}
 		items_.push_back(itemsObject);
 	}
-	if(!value["PageSize"].isNull())
-		pageSize_ = std::stoi(value["PageSize"].asString());
 	if(!value["CurrentPage"].isNull())
 		currentPage_ = std::stoi(value["CurrentPage"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
 	if(!value["TotalCount"].isNull())
 		totalCount_ = std::stoi(value["TotalCount"].asString());
 

sddp/src/model/DescribeUserCountRequest.cc

@@ -1,51 +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/sddp/model/DescribeUserCountRequest.h>
-
-using AlibabaCloud::Sddp::Model::DescribeUserCountRequest;
-
-DescribeUserCountRequest::DescribeUserCountRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "DescribeUserCount")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeUserCountRequest::~DescribeUserCountRequest()
-{}
-
-std::string DescribeUserCountRequest::getSourceIp()const
-{
-	return sourceIp_;
-}
-
-void DescribeUserCountRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
-}
-
-std::string DescribeUserCountRequest::getLang()const
-{
-	return lang_;
-}
-
-void DescribeUserCountRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
-}
-

sddp/src/model/DescribeUserCountResult.cc

@@ -1,68 +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/sddp/model/DescribeUserCountResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Sddp;
-using namespace AlibabaCloud::Sddp::Model;
-
-DescribeUserCountResult::DescribeUserCountResult() :
-	ServiceResult()
-{}
-
-DescribeUserCountResult::DescribeUserCountResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-DescribeUserCountResult::~DescribeUserCountResult()
-{}
-
-void DescribeUserCountResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto userCountNode = value["UserCount"];
-	if(!userCountNode["Authed"].isNull())
-		userCount_.authed = userCountNode["Authed"].asString() == "true";
-	if(!userCountNode["Buyed"].isNull())
-		userCount_.buyed = userCountNode["Buyed"].asString() == "true";
-	if(!userCountNode["AuthCount"].isNull())
-		userCount_.authCount = std::stoi(userCountNode["AuthCount"].asString());
-	if(!userCountNode["UnAuthCount"].isNull())
-		userCount_.unAuthCount = std::stoi(userCountNode["UnAuthCount"].asString());
-	if(!userCountNode["TotalAuthCount"].isNull())
-		userCount_.totalAuthCount = std::stoi(userCountNode["TotalAuthCount"].asString());
-	if(!userCountNode["WarnTotalCount"].isNull())
-		userCount_.warnTotalCount = std::stol(userCountNode["WarnTotalCount"].asString());
-	if(!userCountNode["SaleInstanceStatus"].isNull())
-		userCount_.saleInstanceStatus = std::stoi(userCountNode["SaleInstanceStatus"].asString());
-	if(!userCountNode["WarnAddCount"].isNull())
-		userCount_.warnAddCount = std::stol(userCountNode["WarnAddCount"].asString());
-	if(!userCountNode["SaleInstanceId"].isNull())
-		userCount_.saleInstanceId = userCountNode["SaleInstanceId"].asString();
-
-}
-
-DescribeUserCountResult::UserCount DescribeUserCountResult::getUserCount()const
-{
-	return userCount_;
-}
-

sddp/src/model/DescribeUserStatusRequest.cc

@@ -1,51 +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/sddp/model/DescribeUserStatusRequest.h>
-
-using AlibabaCloud::Sddp::Model::DescribeUserStatusRequest;
-
-DescribeUserStatusRequest::DescribeUserStatusRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "DescribeUserStatus")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeUserStatusRequest::~DescribeUserStatusRequest()
-{}
-
-std::string DescribeUserStatusRequest::getSourceIp()const
-{
-	return sourceIp_;
+ */
+
+#include <alibabacloud/sddp/model/DescribeUserStatusRequest.h>
+
+using AlibabaCloud::Sddp::Model::DescribeUserStatusRequest;
+
+DescribeUserStatusRequest::DescribeUserStatusRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "DescribeUserStatus") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeUserStatusRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+DescribeUserStatusRequest::~DescribeUserStatusRequest() {}
+
+std::string DescribeUserStatusRequest::getSourceIp() const {
+  return sourceIp_;
 }
 
-std::string DescribeUserStatusRequest::getLang()const
-{
-	return lang_;
+void DescribeUserStatusRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
 }
 
-void DescribeUserStatusRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
+std::string DescribeUserStatusRequest::getLang() const {
+  return lang_;
+}
+
+void DescribeUserStatusRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 

sddp/src/model/DescribeUserStatusResult.cc

@@ -40,84 +40,86 @@ void DescribeUserStatusResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto userStatusNode = value["UserStatus"];
-	if(!userStatusNode["Authed"].isNull())
-		userStatus_.authed = userStatusNode["Authed"].asString() == "true";
-	if(!userStatusNode["Buyed"].isNull())
-		userStatus_.buyed = userStatusNode["Buyed"].asString() == "true";
-	if(!userStatusNode["OssBucketSet"].isNull())
-		userStatus_.ossBucketSet = userStatusNode["OssBucketSet"].asString() == "true";
-	if(!userStatusNode["OdpsSet"].isNull())
-		userStatus_.odpsSet = userStatusNode["OdpsSet"].asString() == "true";
-	if(!userStatusNode["RdsSet"].isNull())
-		userStatus_.rdsSet = userStatusNode["RdsSet"].asString() == "true";
-	if(!userStatusNode["AuthProductList"].isNull())
-		userStatus_.authProductList = userStatusNode["AuthProductList"].asString();
-	if(!userStatusNode["AccessKeyId"].isNull())
-		userStatus_.accessKeyId = userStatusNode["AccessKeyId"].asString();
-	if(!userStatusNode["Trail"].isNull())
-		userStatus_.trail = userStatusNode["Trail"].asString() == "true";
-	if(!userStatusNode["InstanceStatus"].isNull())
-		userStatus_.instanceStatus = std::stoi(userStatusNode["InstanceStatus"].asString());
-	if(!userStatusNode["InstanceId"].isNull())
-		userStatus_.instanceId = userStatusNode["InstanceId"].asString();
-	if(!userStatusNode["RemainDays"].isNull())
-		userStatus_.remainDays = std::stoi(userStatusNode["RemainDays"].asString());
-	if(!userStatusNode["RenewStatus"].isNull())
-		userStatus_.renewStatus = userStatusNode["RenewStatus"].asString() == "true";
-	if(!userStatusNode["InstanceNum"].isNull())
-		userStatus_.instanceNum = std::stoi(userStatusNode["InstanceNum"].asString());
-	if(!userStatusNode["UseInstanceNum"].isNull())
-		userStatus_.useInstanceNum = std::stoi(userStatusNode["UseInstanceNum"].asString());
-	if(!userStatusNode["OssSize"].isNull())
-		userStatus_.ossSize = std::stol(userStatusNode["OssSize"].asString());
 	if(!userStatusNode["UseOssSize"].isNull())
 		userStatus_.useOssSize = std::stol(userStatusNode["UseOssSize"].asString());
+	if(!userStatusNode["UseInstanceNum"].isNull())
+		userStatus_.useInstanceNum = std::stoi(userStatusNode["UseInstanceNum"].asString());
+	if(!userStatusNode["InstanceNum"].isNull())
+		userStatus_.instanceNum = std::stoi(userStatusNode["InstanceNum"].asString());
 	if(!userStatusNode["ChargeType"].isNull())
 		userStatus_.chargeType = userStatusNode["ChargeType"].asString();
+	if(!userStatusNode["IncSensitiveTables"].isNull())
+		userStatus_.incSensitiveTables = std::stol(userStatusNode["IncSensitiveTables"].asString());
+	if(!userStatusNode["AuditUpgradeStatus"].isNull())
+		userStatus_.auditUpgradeStatus = userStatusNode["AuditUpgradeStatus"].asString() == "true";
+	if(!userStatusNode["DataMaskTasks"].isNull())
+		userStatus_.dataMaskTasks = std::stol(userStatusNode["DataMaskTasks"].asString());
+	if(!userStatusNode["Authed"].isNull())
+		userStatus_.authed = userStatusNode["Authed"].asString() == "true";
 	if(!userStatusNode["LabStatus"].isNull())
 		userStatus_.labStatus = std::stoi(userStatusNode["LabStatus"].asString());
 	if(!userStatusNode["Version"].isNull())
 		userStatus_.version = userStatusNode["Version"].asString();
-	if(!userStatusNode["DbAuditStatus"].isNull())
-		userStatus_.dbAuditStatus = std::stoi(userStatusNode["DbAuditStatus"].asString());
-	if(!userStatusNode["AssetScanned"].isNull())
-		userStatus_.assetScanned = userStatusNode["AssetScanned"].asString() == "true";
-	if(!userStatusNode["AuditUpgradeStatus"].isNull())
-		userStatus_.auditUpgradeStatus = userStatusNode["AuditUpgradeStatus"].asString() == "true";
+	if(!userStatusNode["OdpsSet"].isNull())
+		userStatus_.odpsSet = userStatusNode["OdpsSet"].asString() == "true";
+	if(!userStatusNode["OssBucketSet"].isNull())
+		userStatus_.ossBucketSet = userStatusNode["OssBucketSet"].asString() == "true";
 	if(!userStatusNode["SensitiveTable"].isNull())
 		userStatus_.sensitiveTable = std::stol(userStatusNode["SensitiveTable"].asString());
-	if(!userStatusNode["SensitiveObject"].isNull())
-		userStatus_.sensitiveObject = std::stol(userStatusNode["SensitiveObject"].asString());
-	if(!userStatusNode["DatamaskColumns"].isNull())
-		userStatus_.datamaskColumns = std::stol(userStatusNode["DatamaskColumns"].asString());
-	if(!userStatusNode["AlarmCount"].isNull())
-		userStatus_.alarmCount = std::stol(userStatusNode["AlarmCount"].asString());
-	if(!userStatusNode["DivulgeCount"].isNull())
-		userStatus_.divulgeCount = std::stol(userStatusNode["DivulgeCount"].asString());
-	if(!userStatusNode["DisplayTime"].isNull())
-		userStatus_.displayTime = userStatusNode["DisplayTime"].asString();
+	if(!userStatusNode["RemainDays"].isNull())
+		userStatus_.remainDays = std::stoi(userStatusNode["RemainDays"].asString());
 	if(!userStatusNode["TotalDataMaskColumns"].isNull())
 		userStatus_.totalDataMaskColumns = std::stol(userStatusNode["TotalDataMaskColumns"].asString());
-	if(!userStatusNode["DataMaskTasks"].isNull())
-		userStatus_.dataMaskTasks = std::stol(userStatusNode["DataMaskTasks"].asString());
-	if(!userStatusNode["DataMaskColumns"].isNull())
-		userStatus_.dataMaskColumns = std::stol(userStatusNode["DataMaskColumns"].asString());
-	if(!userStatusNode["SensitiveTables"].isNull())
-		userStatus_.sensitiveTables = std::stol(userStatusNode["SensitiveTables"].asString());
+	if(!userStatusNode["DatamaskColumns"].isNull())
+		userStatus_.datamaskColumns = std::stol(userStatusNode["DatamaskColumns"].asString());
+	if(!userStatusNode["AuthProductList"].isNull())
+		userStatus_.authProductList = userStatusNode["AuthProductList"].asString();
+	if(!userStatusNode["Trail"].isNull())
+		userStatus_.trail = userStatusNode["Trail"].asString() == "true";
+	if(!userStatusNode["DivulgeCount"].isNull())
+		userStatus_.divulgeCount = std::stol(userStatusNode["DivulgeCount"].asString());
+	if(!userStatusNode["RdsSet"].isNull())
+		userStatus_.rdsSet = userStatusNode["RdsSet"].asString() == "true";
+	if(!userStatusNode["DbAuditStatus"].isNull())
+		userStatus_.dbAuditStatus = std::stoi(userStatusNode["DbAuditStatus"].asString());
+	if(!userStatusNode["RenewStatus"].isNull())
+		userStatus_.renewStatus = userStatusNode["RenewStatus"].asString() == "true";
 	if(!userStatusNode["SensitiveObjects"].isNull())
 		userStatus_.sensitiveObjects = std::stol(userStatusNode["SensitiveObjects"].asString());
-	if(!userStatusNode["IncSensitiveTables"].isNull())
-		userStatus_.incSensitiveTables = std::stol(userStatusNode["IncSensitiveTables"].asString());
-	if(!userStatusNode["IncSensitiveObjects"].isNull())
-		userStatus_.incSensitiveObjects = std::stol(userStatusNode["IncSensitiveObjects"].asString());
-	if(!userStatusNode["SensitiveTop"].isNull())
-		userStatus_.sensitiveTop = userStatusNode["SensitiveTop"].asString();
+	if(!userStatusNode["DataMaskColumns"].isNull())
+		userStatus_.dataMaskColumns = std::stol(userStatusNode["DataMaskColumns"].asString());
 	if(!userStatusNode["DlpTotalCount"].isNull())
 		userStatus_.dlpTotalCount = std::stol(userStatusNode["DlpTotalCount"].asString());
+	if(!userStatusNode["SensitiveObject"].isNull())
+		userStatus_.sensitiveObject = std::stol(userStatusNode["SensitiveObject"].asString());
 	if(!userStatusNode["DlpCount"].isNull())
 		userStatus_.dlpCount = std::stol(userStatusNode["DlpCount"].asString());
+	if(!userStatusNode["InstanceId"].isNull())
+		userStatus_.instanceId = userStatusNode["InstanceId"].asString();
+	if(!userStatusNode["AccessKeyId"].isNull())
+		userStatus_.accessKeyId = userStatusNode["AccessKeyId"].asString();
+	if(!userStatusNode["OssSize"].isNull())
+		userStatus_.ossSize = std::stol(userStatusNode["OssSize"].asString());
 	if(!userStatusNode["SensitiveTotalTop"].isNull())
 		userStatus_.sensitiveTotalTop = userStatusNode["SensitiveTotalTop"].asString();
+	if(!userStatusNode["SensitiveTables"].isNull())
+		userStatus_.sensitiveTables = std::stol(userStatusNode["SensitiveTables"].asString());
+	if(!userStatusNode["SensitiveTop"].isNull())
+		userStatus_.sensitiveTop = userStatusNode["SensitiveTop"].asString();
+	if(!userStatusNode["Purchased"].isNull())
+		userStatus_.purchased = userStatusNode["Purchased"].asString() == "true";
+	if(!userStatusNode["Buyed"].isNull())
+		userStatus_.buyed = userStatusNode["Buyed"].asString() == "true";
+	if(!userStatusNode["IncSensitiveObjects"].isNull())
+		userStatus_.incSensitiveObjects = std::stol(userStatusNode["IncSensitiveObjects"].asString());
+	if(!userStatusNode["InstanceStatus"].isNull())
+		userStatus_.instanceStatus = std::stoi(userStatusNode["InstanceStatus"].asString());
+	if(!userStatusNode["AssetScanned"].isNull())
+		userStatus_.assetScanned = userStatusNode["AssetScanned"].asString() == "true";
+	if(!userStatusNode["AlarmCount"].isNull())
+		userStatus_.alarmCount = std::stol(userStatusNode["AlarmCount"].asString());
+	if(!userStatusNode["DisplayTime"].isNull())
+		userStatus_.displayTime = userStatusNode["DisplayTime"].asString();
 
 }
 

sddp/src/model/DisableUserConfigRequest.cc

@@ -1,62 +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.
- */
-
-#include <alibabacloud/sddp/model/DisableUserConfigRequest.h>
-
-using AlibabaCloud::Sddp::Model::DisableUserConfigRequest;
-
-DisableUserConfigRequest::DisableUserConfigRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "DisableUserConfig")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DisableUserConfigRequest::~DisableUserConfigRequest()
-{}
-
-std::string DisableUserConfigRequest::getCode()const
-{
-	return code_;
+ */
+
+#include <alibabacloud/sddp/model/DisableUserConfigRequest.h>
+
+using AlibabaCloud::Sddp::Model::DisableUserConfigRequest;
+
+DisableUserConfigRequest::DisableUserConfigRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "DisableUserConfig") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DisableUserConfigRequest::setCode(const std::string& code)
-{
-	code_ = code;
-	setParameter("Code", code);
+DisableUserConfigRequest::~DisableUserConfigRequest() {}
+
+std::string DisableUserConfigRequest::getCode() const {
+  return code_;
 }
 
-std::string DisableUserConfigRequest::getSourceIp()const
-{
-	return sourceIp_;
+void DisableUserConfigRequest::setCode(const std::string &code) {
+  code_ = code;
+  setParameter(std::string("Code"), code);
 }
 
-void DisableUserConfigRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+std::string DisableUserConfigRequest::getSourceIp() const {
+  return sourceIp_;
 }
 
-std::string DisableUserConfigRequest::getLang()const
-{
-	return lang_;
+void DisableUserConfigRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
 }
 
-void DisableUserConfigRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
+std::string DisableUserConfigRequest::getLang() const {
+  return lang_;
+}
+
+void DisableUserConfigRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 

sddp/src/model/ExecDatamaskRequest.cc

@@ -1,62 +1,63 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
-
-#include <alibabacloud/sddp/model/ExecDatamaskRequest.h>
-
-using AlibabaCloud::Sddp::Model::ExecDatamaskRequest;
-
-ExecDatamaskRequest::ExecDatamaskRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "ExecDatamask")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-ExecDatamaskRequest::~ExecDatamaskRequest()
-{}
-
-std::string ExecDatamaskRequest::getData()const
-{
-	return data_;
+ */
+
+#include <alibabacloud/sddp/model/ExecDatamaskRequest.h>
+
+using AlibabaCloud::Sddp::Model::ExecDatamaskRequest;
+
+ExecDatamaskRequest::ExecDatamaskRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "ExecDatamask") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void ExecDatamaskRequest::setData(const std::string& data)
-{
-	data_ = data;
-	setParameter("Data", data);
+ExecDatamaskRequest::~ExecDatamaskRequest() {}
+
+std::string ExecDatamaskRequest::getData() const {
+  return data_;
 }
 
-long ExecDatamaskRequest::getTemplateId()const
-{
-	return templateId_;
+void ExecDatamaskRequest::setData(const std::string &data) {
+  data_ = data;
+  setParameter(std::string("Data"), data);
 }
 
-void ExecDatamaskRequest::setTemplateId(long templateId)
-{
-	templateId_ = templateId;
-	setParameter("TemplateId", std::to_string(templateId));
+long ExecDatamaskRequest::getTemplateId() const {
+  return templateId_;
 }
 
-std::string ExecDatamaskRequest::getSourceIp()const
-{
-	return sourceIp_;
+void ExecDatamaskRequest::setTemplateId(long templateId) {
+  templateId_ = templateId;
+  setParameter(std::string("TemplateId"), std::to_string(templateId));
 }
 
-void ExecDatamaskRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+std::string ExecDatamaskRequest::getSourceIp() const {
+  return sourceIp_;
+}
+
+void ExecDatamaskRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
+}
+
+std::string ExecDatamaskRequest::getLang() const {
+  return lang_;
+}
+
+void ExecDatamaskRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 

sddp/src/model/ManualTriggerMaskingProcessRequest.cc

@@ -1,73 +1,63 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
-
-#include <alibabacloud/sddp/model/ManualTriggerMaskingProcessRequest.h>
-
-using AlibabaCloud::Sddp::Model::ManualTriggerMaskingProcessRequest;
-
-ManualTriggerMaskingProcessRequest::ManualTriggerMaskingProcessRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "ManualTriggerMaskingProcess")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-ManualTriggerMaskingProcessRequest::~ManualTriggerMaskingProcessRequest()
-{}
-
-int ManualTriggerMaskingProcessRequest::getFeatureType()const
-{
-	return featureType_;
+ */
+
+#include <alibabacloud/sddp/model/ManualTriggerMaskingProcessRequest.h>
+
+using AlibabaCloud::Sddp::Model::ManualTriggerMaskingProcessRequest;
+
+ManualTriggerMaskingProcessRequest::ManualTriggerMaskingProcessRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "ManualTriggerMaskingProcess") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void ManualTriggerMaskingProcessRequest::setFeatureType(int featureType)
-{
-	featureType_ = featureType;
-	setParameter("FeatureType", std::to_string(featureType));
+ManualTriggerMaskingProcessRequest::~ManualTriggerMaskingProcessRequest() {}
+
+int ManualTriggerMaskingProcessRequest::getFeatureType() const {
+  return featureType_;
 }
 
-std::string ManualTriggerMaskingProcessRequest::getSourceIp()const
-{
-	return sourceIp_;
+void ManualTriggerMaskingProcessRequest::setFeatureType(int featureType) {
+  featureType_ = featureType;
+  setParameter(std::string("FeatureType"), std::to_string(featureType));
 }
 
-void ManualTriggerMaskingProcessRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+std::string ManualTriggerMaskingProcessRequest::getSourceIp() const {
+  return sourceIp_;
 }
 
-long ManualTriggerMaskingProcessRequest::getId()const
-{
-	return id_;
+void ManualTriggerMaskingProcessRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
 }
 
-void ManualTriggerMaskingProcessRequest::setId(long id)
-{
-	id_ = id;
-	setParameter("Id", std::to_string(id));
+long ManualTriggerMaskingProcessRequest::getId() const {
+  return id_;
 }
 
-std::string ManualTriggerMaskingProcessRequest::getLang()const
-{
-	return lang_;
+void ManualTriggerMaskingProcessRequest::setId(long id) {
+  id_ = id;
+  setParameter(std::string("Id"), std::to_string(id));
 }
 
-void ManualTriggerMaskingProcessRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
+std::string ManualTriggerMaskingProcessRequest::getLang() const {
+  return lang_;
+}
+
+void ManualTriggerMaskingProcessRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 

sddp/src/model/ModifyDataLimitRequest.cc

@@ -1,183 +1,153 @@
 /*
  * 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/sddp/model/ModifyDataLimitRequest.h>
-
-using AlibabaCloud::Sddp::Model::ModifyDataLimitRequest;
-
-ModifyDataLimitRequest::ModifyDataLimitRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "ModifyDataLimit")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-ModifyDataLimitRequest::~ModifyDataLimitRequest()
-{}
-
-bool ModifyDataLimitRequest::getModifyPassword()const
-{
-	return modifyPassword_;
+ */
+
+#include <alibabacloud/sddp/model/ModifyDataLimitRequest.h>
+
+using AlibabaCloud::Sddp::Model::ModifyDataLimitRequest;
+
+ModifyDataLimitRequest::ModifyDataLimitRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "ModifyDataLimit") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void ModifyDataLimitRequest::setModifyPassword(bool modifyPassword)
-{
-	modifyPassword_ = modifyPassword;
-	setParameter("ModifyPassword", modifyPassword ? "true" : "false");
+ModifyDataLimitRequest::~ModifyDataLimitRequest() {}
+
+bool ModifyDataLimitRequest::getModifyPassword() const {
+  return modifyPassword_;
 }
 
-std::string ModifyDataLimitRequest::getPassword()const
-{
-	return password_;
+void ModifyDataLimitRequest::setModifyPassword(bool modifyPassword) {
+  modifyPassword_ = modifyPassword;
+  setParameter(std::string("ModifyPassword"), modifyPassword ? "true" : "false");
 }
 
-void ModifyDataLimitRequest::setPassword(const std::string& password)
-{
-	password_ = password;
-	setParameter("Password", password);
+std::string ModifyDataLimitRequest::getPassword() const {
+  return password_;
 }
 
-std::string ModifyDataLimitRequest::getSourceIp()const
-{
-	return sourceIp_;
+void ModifyDataLimitRequest::setPassword(const std::string &password) {
+  password_ = password;
+  setParameter(std::string("Password"), password);
 }
 
-void ModifyDataLimitRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+std::string ModifyDataLimitRequest::getSourceIp() const {
+  return sourceIp_;
 }
 
-long ModifyDataLimitRequest::getId()const
-{
-	return id_;
+void ModifyDataLimitRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
 }
 
-void ModifyDataLimitRequest::setId(long id)
-{
-	id_ = id;
-	setParameter("Id", std::to_string(id));
+long ModifyDataLimitRequest::getId() const {
+  return id_;
 }
 
-std::string ModifyDataLimitRequest::getLang()const
-{
-	return lang_;
+void ModifyDataLimitRequest::setId(long id) {
+  id_ = id;
+  setParameter(std::string("Id"), std::to_string(id));
 }
 
-void ModifyDataLimitRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
+std::string ModifyDataLimitRequest::getLang() const {
+  return lang_;
 }
 
-std::string ModifyDataLimitRequest::getServiceRegionId()const
-{
-	return serviceRegionId_;
+void ModifyDataLimitRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 
-void ModifyDataLimitRequest::setServiceRegionId(const std::string& serviceRegionId)
-{
-	serviceRegionId_ = serviceRegionId;
-	setParameter("ServiceRegionId", serviceRegionId);
+std::string ModifyDataLimitRequest::getServiceRegionId() const {
+  return serviceRegionId_;
 }
 
-std::string ModifyDataLimitRequest::getEngineType()const
-{
-	return engineType_;
+void ModifyDataLimitRequest::setServiceRegionId(const std::string &serviceRegionId) {
+  serviceRegionId_ = serviceRegionId;
+  setParameter(std::string("ServiceRegionId"), serviceRegionId);
 }
 
-void ModifyDataLimitRequest::setEngineType(const std::string& engineType)
-{
-	engineType_ = engineType;
-	setParameter("EngineType", engineType);
+std::string ModifyDataLimitRequest::getEngineType() const {
+  return engineType_;
 }
 
-int ModifyDataLimitRequest::getAuditStatus()const
-{
-	return auditStatus_;
+void ModifyDataLimitRequest::setEngineType(const std::string &engineType) {
+  engineType_ = engineType;
+  setParameter(std::string("EngineType"), engineType);
 }
 
-void ModifyDataLimitRequest::setAuditStatus(int auditStatus)
-{
-	auditStatus_ = auditStatus;
-	setParameter("AuditStatus", std::to_string(auditStatus));
+int ModifyDataLimitRequest::getAuditStatus() const {
+  return auditStatus_;
 }
 
-int ModifyDataLimitRequest::getAutoScan()const
-{
-	return autoScan_;
+void ModifyDataLimitRequest::setAuditStatus(int auditStatus) {
+  auditStatus_ = auditStatus;
+  setParameter(std::string("AuditStatus"), std::to_string(auditStatus));
 }
 
-void ModifyDataLimitRequest::setAutoScan(int autoScan)
-{
-	autoScan_ = autoScan;
-	setParameter("AutoScan", std::to_string(autoScan));
+int ModifyDataLimitRequest::getAutoScan() const {
+  return autoScan_;
 }
 
-int ModifyDataLimitRequest::getLogStoreDay()const
-{
-	return logStoreDay_;
+void ModifyDataLimitRequest::setAutoScan(int autoScan) {
+  autoScan_ = autoScan;
+  setParameter(std::string("AutoScan"), std::to_string(autoScan));
 }
 
-void ModifyDataLimitRequest::setLogStoreDay(int logStoreDay)
-{
-	logStoreDay_ = logStoreDay;
-	setParameter("LogStoreDay", std::to_string(logStoreDay));
+int ModifyDataLimitRequest::getLogStoreDay() const {
+  return logStoreDay_;
 }
 
-int ModifyDataLimitRequest::getResourceType()const
-{
-	return resourceType_;
+void ModifyDataLimitRequest::setLogStoreDay(int logStoreDay) {
+  logStoreDay_ = logStoreDay;
+  setParameter(std::string("LogStoreDay"), std::to_string(logStoreDay));
 }
 
-void ModifyDataLimitRequest::setResourceType(int resourceType)
-{
-	resourceType_ = resourceType;
-	setParameter("ResourceType", std::to_string(resourceType));
+int ModifyDataLimitRequest::getResourceType() const {
+  return resourceType_;
 }
 
-std::string ModifyDataLimitRequest::getConnector()const
-{
-	return connector_;
+void ModifyDataLimitRequest::setResourceType(int resourceType) {
+  resourceType_ = resourceType;
+  setParameter(std::string("ResourceType"), std::to_string(resourceType));
 }
 
-void ModifyDataLimitRequest::setConnector(const std::string& connector)
-{
-	connector_ = connector;
-	setParameter("Connector", connector);
+std::string ModifyDataLimitRequest::getConnector() const {
+  return connector_;
 }
 
-int ModifyDataLimitRequest::getPort()const
-{
-	return port_;
+void ModifyDataLimitRequest::setConnector(const std::string &connector) {
+  connector_ = connector;
+  setParameter(std::string("Connector"), connector);
 }
 
-void ModifyDataLimitRequest::setPort(int port)
-{
-	port_ = port;
-	setParameter("Port", std::to_string(port));
+int ModifyDataLimitRequest::getPort() const {
+  return port_;
 }
 
-std::string ModifyDataLimitRequest::getUserName()const
-{
-	return userName_;
+void ModifyDataLimitRequest::setPort(int port) {
+  port_ = port;
+  setParameter(std::string("Port"), std::to_string(port));
 }
 
-void ModifyDataLimitRequest::setUserName(const std::string& userName)
-{
-	userName_ = userName;
-	setParameter("UserName", userName);
+std::string ModifyDataLimitRequest::getUserName() const {
+  return userName_;
+}
+
+void ModifyDataLimitRequest::setUserName(const std::string &userName) {
+  userName_ = userName;
+  setParameter(std::string("UserName"), userName);
 }
 

sddp/src/model/ModifyDefaultLevelRequest.cc

@@ -1,84 +1,72 @@
 /*
  * 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/sddp/model/ModifyDefaultLevelRequest.h>
-
-using AlibabaCloud::Sddp::Model::ModifyDefaultLevelRequest;
-
-ModifyDefaultLevelRequest::ModifyDefaultLevelRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "ModifyDefaultLevel")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-ModifyDefaultLevelRequest::~ModifyDefaultLevelRequest()
-{}
-
-int ModifyDefaultLevelRequest::getFeatureType()const
-{
-	return featureType_;
+ */
+
+#include <alibabacloud/sddp/model/ModifyDefaultLevelRequest.h>
+
+using AlibabaCloud::Sddp::Model::ModifyDefaultLevelRequest;
+
+ModifyDefaultLevelRequest::ModifyDefaultLevelRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "ModifyDefaultLevel") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void ModifyDefaultLevelRequest::setFeatureType(int featureType)
-{
-	featureType_ = featureType;
-	setParameter("FeatureType", std::to_string(featureType));
+ModifyDefaultLevelRequest::~ModifyDefaultLevelRequest() {}
+
+int ModifyDefaultLevelRequest::getFeatureType() const {
+  return featureType_;
 }
 
-long ModifyDefaultLevelRequest::getDefaultId()const
-{
-	return defaultId_;
+void ModifyDefaultLevelRequest::setFeatureType(int featureType) {
+  featureType_ = featureType;
+  setParameter(std::string("FeatureType"), std::to_string(featureType));
 }
 
-void ModifyDefaultLevelRequest::setDefaultId(long defaultId)
-{
-	defaultId_ = defaultId;
-	setParameter("DefaultId", std::to_string(defaultId));
+long ModifyDefaultLevelRequest::getDefaultId() const {
+  return defaultId_;
 }
 
-std::string ModifyDefaultLevelRequest::getSourceIp()const
-{
-	return sourceIp_;
+void ModifyDefaultLevelRequest::setDefaultId(long defaultId) {
+  defaultId_ = defaultId;
+  setParameter(std::string("DefaultId"), std::to_string(defaultId));
 }
 
-void ModifyDefaultLevelRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+std::string ModifyDefaultLevelRequest::getSourceIp() const {
+  return sourceIp_;
 }
 
-std::string ModifyDefaultLevelRequest::getLang()const
-{
-	return lang_;
+void ModifyDefaultLevelRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
 }
 
-void ModifyDefaultLevelRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
+std::string ModifyDefaultLevelRequest::getLang() const {
+  return lang_;
 }
 
-std::string ModifyDefaultLevelRequest::getSensitiveIds()const
-{
-	return sensitiveIds_;
+void ModifyDefaultLevelRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 
-void ModifyDefaultLevelRequest::setSensitiveIds(const std::string& sensitiveIds)
-{
-	sensitiveIds_ = sensitiveIds;
-	setParameter("SensitiveIds", sensitiveIds);
+std::string ModifyDefaultLevelRequest::getSensitiveIds() const {
+  return sensitiveIds_;
+}
+
+void ModifyDefaultLevelRequest::setSensitiveIds(const std::string &sensitiveIds) {
+  sensitiveIds_ = sensitiveIds;
+  setParameter(std::string("SensitiveIds"), sensitiveIds);
 }
 

sddp/src/model/ModifyEventStatusRequest.cc

@@ -1,117 +1,99 @@
 /*
  * 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/sddp/model/ModifyEventStatusRequest.h>
-
-using AlibabaCloud::Sddp::Model::ModifyEventStatusRequest;
-
-ModifyEventStatusRequest::ModifyEventStatusRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "ModifyEventStatus")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-ModifyEventStatusRequest::~ModifyEventStatusRequest()
-{}
-
-bool ModifyEventStatusRequest::getBacked()const
-{
-	return backed_;
+ */
+
+#include <alibabacloud/sddp/model/ModifyEventStatusRequest.h>
+
+using AlibabaCloud::Sddp::Model::ModifyEventStatusRequest;
+
+ModifyEventStatusRequest::ModifyEventStatusRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "ModifyEventStatus") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void ModifyEventStatusRequest::setBacked(bool backed)
-{
-	backed_ = backed;
-	setParameter("Backed", backed ? "true" : "false");
+ModifyEventStatusRequest::~ModifyEventStatusRequest() {}
+
+bool ModifyEventStatusRequest::getBacked() const {
+  return backed_;
 }
 
-std::string ModifyEventStatusRequest::getSourceIp()const
-{
-	return sourceIp_;
+void ModifyEventStatusRequest::setBacked(bool backed) {
+  backed_ = backed;
+  setParameter(std::string("Backed"), backed ? "true" : "false");
 }
 
-void ModifyEventStatusRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+std::string ModifyEventStatusRequest::getSourceIp() const {
+  return sourceIp_;
 }
 
-std::string ModifyEventStatusRequest::getHandleInfo()const
-{
-	return handleInfo_;
+void ModifyEventStatusRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
 }
 
-void ModifyEventStatusRequest::setHandleInfo(const std::string& handleInfo)
-{
-	handleInfo_ = handleInfo;
-	setParameter("HandleInfo", handleInfo);
+std::string ModifyEventStatusRequest::getHandleInfo() const {
+  return handleInfo_;
 }
 
-std::string ModifyEventStatusRequest::getDealReason()const
-{
-	return dealReason_;
+void ModifyEventStatusRequest::setHandleInfo(const std::string &handleInfo) {
+  handleInfo_ = handleInfo;
+  setParameter(std::string("HandleInfo"), handleInfo);
 }
 
-void ModifyEventStatusRequest::setDealReason(const std::string& dealReason)
-{
-	dealReason_ = dealReason;
-	setParameter("DealReason", dealReason);
+std::string ModifyEventStatusRequest::getDealReason() const {
+  return dealReason_;
 }
 
-long ModifyEventStatusRequest::getId()const
-{
-	return id_;
+void ModifyEventStatusRequest::setDealReason(const std::string &dealReason) {
+  dealReason_ = dealReason;
+  setParameter(std::string("DealReason"), dealReason);
 }
 
-void ModifyEventStatusRequest::setId(long id)
-{
-	id_ = id;
-	setParameter("Id", std::to_string(id));
+long ModifyEventStatusRequest::getId() const {
+  return id_;
 }
 
-std::string ModifyEventStatusRequest::getLang()const
-{
-	return lang_;
+void ModifyEventStatusRequest::setId(long id) {
+  id_ = id;
+  setParameter(std::string("Id"), std::to_string(id));
 }
 
-void ModifyEventStatusRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
+std::string ModifyEventStatusRequest::getLang() const {
+  return lang_;
 }
 
-int ModifyEventStatusRequest::getFeatureType()const
-{
-	return featureType_;
+void ModifyEventStatusRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 
-void ModifyEventStatusRequest::setFeatureType(int featureType)
-{
-	featureType_ = featureType;
-	setParameter("FeatureType", std::to_string(featureType));
+int ModifyEventStatusRequest::getFeatureType() const {
+  return featureType_;
 }
 
-int ModifyEventStatusRequest::getStatus()const
-{
-	return status_;
+void ModifyEventStatusRequest::setFeatureType(int featureType) {
+  featureType_ = featureType;
+  setParameter(std::string("FeatureType"), std::to_string(featureType));
 }
 
-void ModifyEventStatusRequest::setStatus(int status)
-{
-	status_ = status;
-	setParameter("Status", std::to_string(status));
+int ModifyEventStatusRequest::getStatus() const {
+  return status_;
+}
+
+void ModifyEventStatusRequest::setStatus(int status) {
+  status_ = status;
+  setParameter(std::string("Status"), std::to_string(status));
 }
 

sddp/src/model/ModifyEventTypeStatusRequest.cc

@@ -1,62 +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.
- */
-
-#include <alibabacloud/sddp/model/ModifyEventTypeStatusRequest.h>
-
-using AlibabaCloud::Sddp::Model::ModifyEventTypeStatusRequest;
-
-ModifyEventTypeStatusRequest::ModifyEventTypeStatusRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "ModifyEventTypeStatus")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-ModifyEventTypeStatusRequest::~ModifyEventTypeStatusRequest()
-{}
-
-std::string ModifyEventTypeStatusRequest::getSubTypeIds()const
-{
-	return subTypeIds_;
+ */
+
+#include <alibabacloud/sddp/model/ModifyEventTypeStatusRequest.h>
+
+using AlibabaCloud::Sddp::Model::ModifyEventTypeStatusRequest;
+
+ModifyEventTypeStatusRequest::ModifyEventTypeStatusRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "ModifyEventTypeStatus") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void ModifyEventTypeStatusRequest::setSubTypeIds(const std::string& subTypeIds)
-{
-	subTypeIds_ = subTypeIds;
-	setParameter("SubTypeIds", subTypeIds);
+ModifyEventTypeStatusRequest::~ModifyEventTypeStatusRequest() {}
+
+std::string ModifyEventTypeStatusRequest::getSubTypeIds() const {
+  return subTypeIds_;
 }
 
-std::string ModifyEventTypeStatusRequest::getSourceIp()const
-{
-	return sourceIp_;
+void ModifyEventTypeStatusRequest::setSubTypeIds(const std::string &subTypeIds) {
+  subTypeIds_ = subTypeIds;
+  setParameter(std::string("SubTypeIds"), subTypeIds);
 }
 
-void ModifyEventTypeStatusRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+std::string ModifyEventTypeStatusRequest::getSourceIp() const {
+  return sourceIp_;
 }
 
-std::string ModifyEventTypeStatusRequest::getLang()const
-{
-	return lang_;
+void ModifyEventTypeStatusRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
 }
 
-void ModifyEventTypeStatusRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
+std::string ModifyEventTypeStatusRequest::getLang() const {
+  return lang_;
+}
+
+void ModifyEventTypeStatusRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 

sddp/src/model/ModifyReportTaskStatusRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/sddp/model/ModifyReportTaskStatusRequest.h>
+
+using AlibabaCloud::Sddp::Model::ModifyReportTaskStatusRequest;
+
+ModifyReportTaskStatusRequest::ModifyReportTaskStatusRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "ModifyReportTaskStatus") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ModifyReportTaskStatusRequest::~ModifyReportTaskStatusRequest() {}
+
+std::string ModifyReportTaskStatusRequest::getSourceIp() const {
+  return sourceIp_;
+}
+
+void ModifyReportTaskStatusRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
+}
+
+int ModifyReportTaskStatusRequest::getReportTaskStatus() const {
+  return reportTaskStatus_;
+}
+
+void ModifyReportTaskStatusRequest::setReportTaskStatus(int reportTaskStatus) {
+  reportTaskStatus_ = reportTaskStatus;
+  setParameter(std::string("ReportTaskStatus"), std::to_string(reportTaskStatus));
+}
+
+std::string ModifyReportTaskStatusRequest::getLang() const {
+  return lang_;
+}
+
+void ModifyReportTaskStatusRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
+}
+

sddp/src/model/ModifyReportTaskStatusResult.cc

@@ -14,26 +14,26 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/sddp/model/BatchDeleteDataLimitResult.h>
+#include <alibabacloud/sddp/model/ModifyReportTaskStatusResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Sddp;
 using namespace AlibabaCloud::Sddp::Model;
 
-BatchDeleteDataLimitResult::BatchDeleteDataLimitResult() :
+ModifyReportTaskStatusResult::ModifyReportTaskStatusResult() :
 	ServiceResult()
 {}
 
-BatchDeleteDataLimitResult::BatchDeleteDataLimitResult(const std::string &payload) :
+ModifyReportTaskStatusResult::ModifyReportTaskStatusResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-BatchDeleteDataLimitResult::~BatchDeleteDataLimitResult()
+ModifyReportTaskStatusResult::~ModifyReportTaskStatusResult()
 {}
 
-void BatchDeleteDataLimitResult::parse(const std::string &payload)
+void ModifyReportTaskStatusResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;

sddp/src/model/ModifyRuleRequest.cc

@@ -1,216 +1,180 @@
 /*
  * 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/sddp/model/ModifyRuleRequest.h>
-
-using AlibabaCloud::Sddp::Model::ModifyRuleRequest;
-
-ModifyRuleRequest::ModifyRuleRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "ModifyRule")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-ModifyRuleRequest::~ModifyRuleRequest()
-{}
-
-int ModifyRuleRequest::getWarnLevel()const
-{
-	return warnLevel_;
+ */
+
+#include <alibabacloud/sddp/model/ModifyRuleRequest.h>
+
+using AlibabaCloud::Sddp::Model::ModifyRuleRequest;
+
+ModifyRuleRequest::ModifyRuleRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "ModifyRule") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void ModifyRuleRequest::setWarnLevel(int warnLevel)
-{
-	warnLevel_ = warnLevel;
-	setParameter("WarnLevel", std::to_string(warnLevel));
+ModifyRuleRequest::~ModifyRuleRequest() {}
+
+int ModifyRuleRequest::getWarnLevel() const {
+  return warnLevel_;
 }
 
-std::string ModifyRuleRequest::getProductCode()const
-{
-	return productCode_;
+void ModifyRuleRequest::setWarnLevel(int warnLevel) {
+  warnLevel_ = warnLevel;
+  setParameter(std::string("WarnLevel"), std::to_string(warnLevel));
 }
 
-void ModifyRuleRequest::setProductCode(const std::string& productCode)
-{
-	productCode_ = productCode;
-	setParameter("ProductCode", productCode);
+std::string ModifyRuleRequest::getProductCode() const {
+  return productCode_;
 }
 
-long ModifyRuleRequest::getProductId()const
-{
-	return productId_;
+void ModifyRuleRequest::setProductCode(const std::string &productCode) {
+  productCode_ = productCode;
+  setParameter(std::string("ProductCode"), productCode);
 }
 
-void ModifyRuleRequest::setProductId(long productId)
-{
-	productId_ = productId;
-	setParameter("ProductId", std::to_string(productId));
+long ModifyRuleRequest::getProductId() const {
+  return productId_;
 }
 
-std::string ModifyRuleRequest::getDescription()const
-{
-	return description_;
+void ModifyRuleRequest::setProductId(long productId) {
+  productId_ = productId;
+  setParameter(std::string("ProductId"), std::to_string(productId));
 }
 
-void ModifyRuleRequest::setDescription(const std::string& description)
-{
-	description_ = description;
-	setParameter("Description", description);
+std::string ModifyRuleRequest::getDescription() const {
+  return description_;
 }
 
-long ModifyRuleRequest::getRiskLevelId()const
-{
-	return riskLevelId_;
+void ModifyRuleRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
 }
 
-void ModifyRuleRequest::setRiskLevelId(long riskLevelId)
-{
-	riskLevelId_ = riskLevelId;
-	setParameter("RiskLevelId", std::to_string(riskLevelId));
+long ModifyRuleRequest::getRiskLevelId() const {
+  return riskLevelId_;
 }
 
-std::string ModifyRuleRequest::getContent()const
-{
-	return content_;
+void ModifyRuleRequest::setRiskLevelId(long riskLevelId) {
+  riskLevelId_ = riskLevelId;
+  setParameter(std::string("RiskLevelId"), std::to_string(riskLevelId));
 }
 
-void ModifyRuleRequest::setContent(const std::string& content)
-{
-	content_ = content;
-	setParameter("Content", content);
+std::string ModifyRuleRequest::getContent() const {
+  return content_;
 }
 
-std::string ModifyRuleRequest::getSourceIp()const
-{
-	return sourceIp_;
+void ModifyRuleRequest::setContent(const std::string &content) {
+  content_ = content;
+  setParameter(std::string("Content"), content);
 }
 
-void ModifyRuleRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+std::string ModifyRuleRequest::getSourceIp() const {
+  return sourceIp_;
 }
 
-long ModifyRuleRequest::getId()const
-{
-	return id_;
+void ModifyRuleRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
 }
 
-void ModifyRuleRequest::setId(long id)
-{
-	id_ = id;
-	setParameter("Id", std::to_string(id));
+long ModifyRuleRequest::getId() const {
+  return id_;
 }
 
-std::string ModifyRuleRequest::getLang()const
-{
-	return lang_;
+void ModifyRuleRequest::setId(long id) {
+  id_ = id;
+  setParameter(std::string("Id"), std::to_string(id));
 }
 
-void ModifyRuleRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
+std::string ModifyRuleRequest::getLang() const {
+  return lang_;
 }
 
-int ModifyRuleRequest::getFeatureType()const
-{
-	return featureType_;
+void ModifyRuleRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 
-void ModifyRuleRequest::setFeatureType(int featureType)
-{
-	featureType_ = featureType;
-	setParameter("FeatureType", std::to_string(featureType));
+int ModifyRuleRequest::getFeatureType() const {
+  return featureType_;
 }
 
-int ModifyRuleRequest::getRuleType()const
-{
-	return ruleType_;
+void ModifyRuleRequest::setFeatureType(int featureType) {
+  featureType_ = featureType;
+  setParameter(std::string("FeatureType"), std::to_string(featureType));
 }
 
-void ModifyRuleRequest::setRuleType(int ruleType)
-{
-	ruleType_ = ruleType;
-	setParameter("RuleType", std::to_string(ruleType));
+int ModifyRuleRequest::getRuleType() const {
+  return ruleType_;
 }
 
-std::string ModifyRuleRequest::getStatExpress()const
-{
-	return statExpress_;
+void ModifyRuleRequest::setRuleType(int ruleType) {
+  ruleType_ = ruleType;
+  setParameter(std::string("RuleType"), std::to_string(ruleType));
 }
 
-void ModifyRuleRequest::setStatExpress(const std::string& statExpress)
-{
-	statExpress_ = statExpress;
-	setParameter("StatExpress", statExpress);
+std::string ModifyRuleRequest::getStatExpress() const {
+  return statExpress_;
 }
 
-int ModifyRuleRequest::getContentCategory()const
-{
-	return contentCategory_;
+void ModifyRuleRequest::setStatExpress(const std::string &statExpress) {
+  statExpress_ = statExpress;
+  setParameter(std::string("StatExpress"), statExpress);
 }
 
-void ModifyRuleRequest::setContentCategory(int contentCategory)
-{
-	contentCategory_ = contentCategory;
-	setParameter("ContentCategory", std::to_string(contentCategory));
+int ModifyRuleRequest::getContentCategory() const {
+  return contentCategory_;
 }
 
-int ModifyRuleRequest::getCustomType()const
-{
-	return customType_;
+void ModifyRuleRequest::setContentCategory(int contentCategory) {
+  contentCategory_ = contentCategory;
+  setParameter(std::string("ContentCategory"), std::to_string(contentCategory));
 }
 
-void ModifyRuleRequest::setCustomType(int customType)
-{
-	customType_ = customType;
-	setParameter("CustomType", std::to_string(customType));
+int ModifyRuleRequest::getCustomType() const {
+  return customType_;
 }
 
-std::string ModifyRuleRequest::getTarget()const
-{
-	return target_;
+void ModifyRuleRequest::setCustomType(int customType) {
+  customType_ = customType;
+  setParameter(std::string("CustomType"), std::to_string(customType));
 }
 
-void ModifyRuleRequest::setTarget(const std::string& target)
-{
-	target_ = target;
-	setParameter("Target", target);
+std::string ModifyRuleRequest::getTarget() const {
+  return target_;
 }
 
-std::string ModifyRuleRequest::getName()const
-{
-	return name_;
+void ModifyRuleRequest::setTarget(const std::string &target) {
+  target_ = target;
+  setParameter(std::string("Target"), target);
 }
 
-void ModifyRuleRequest::setName(const std::string& name)
-{
-	name_ = name;
-	setParameter("Name", name);
+std::string ModifyRuleRequest::getName() const {
+  return name_;
 }
 
-int ModifyRuleRequest::getCategory()const
-{
-	return category_;
+void ModifyRuleRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
 }
 
-void ModifyRuleRequest::setCategory(int category)
-{
-	category_ = category;
-	setParameter("Category", std::to_string(category));
+int ModifyRuleRequest::getCategory() const {
+  return category_;
+}
+
+void ModifyRuleRequest::setCategory(int category) {
+  category_ = category;
+  setParameter(std::string("Category"), std::to_string(category));
 }
 

sddp/src/model/ModifyRuleStatusRequest.cc

@@ -1,95 +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/sddp/model/ModifyRuleStatusRequest.h>
-
-using AlibabaCloud::Sddp::Model::ModifyRuleStatusRequest;
-
-ModifyRuleStatusRequest::ModifyRuleStatusRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "ModifyRuleStatus")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-ModifyRuleStatusRequest::~ModifyRuleStatusRequest()
-{}
-
-int ModifyRuleStatusRequest::getFeatureType()const
-{
-	return featureType_;
+ */
+
+#include <alibabacloud/sddp/model/ModifyRuleStatusRequest.h>
+
+using AlibabaCloud::Sddp::Model::ModifyRuleStatusRequest;
+
+ModifyRuleStatusRequest::ModifyRuleStatusRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "ModifyRuleStatus") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void ModifyRuleStatusRequest::setFeatureType(int featureType)
-{
-	featureType_ = featureType;
-	setParameter("FeatureType", std::to_string(featureType));
+ModifyRuleStatusRequest::~ModifyRuleStatusRequest() {}
+
+int ModifyRuleStatusRequest::getFeatureType() const {
+  return featureType_;
 }
 
-std::string ModifyRuleStatusRequest::getSourceIp()const
-{
-	return sourceIp_;
+void ModifyRuleStatusRequest::setFeatureType(int featureType) {
+  featureType_ = featureType;
+  setParameter(std::string("FeatureType"), std::to_string(featureType));
 }
 
-void ModifyRuleStatusRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+std::string ModifyRuleStatusRequest::getSourceIp() const {
+  return sourceIp_;
 }
 
-std::string ModifyRuleStatusRequest::getIds()const
-{
-	return ids_;
+void ModifyRuleStatusRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
 }
 
-void ModifyRuleStatusRequest::setIds(const std::string& ids)
-{
-	ids_ = ids;
-	setParameter("Ids", ids);
+std::string ModifyRuleStatusRequest::getIds() const {
+  return ids_;
 }
 
-long ModifyRuleStatusRequest::getId()const
-{
-	return id_;
+void ModifyRuleStatusRequest::setIds(const std::string &ids) {
+  ids_ = ids;
+  setParameter(std::string("Ids"), ids);
 }
 
-void ModifyRuleStatusRequest::setId(long id)
-{
-	id_ = id;
-	setParameter("Id", std::to_string(id));
+long ModifyRuleStatusRequest::getId() const {
+  return id_;
 }
 
-std::string ModifyRuleStatusRequest::getLang()const
-{
-	return lang_;
+void ModifyRuleStatusRequest::setId(long id) {
+  id_ = id;
+  setParameter(std::string("Id"), std::to_string(id));
 }
 
-void ModifyRuleStatusRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
+std::string ModifyRuleStatusRequest::getLang() const {
+  return lang_;
 }
 
-int ModifyRuleStatusRequest::getStatus()const
-{
-	return status_;
+void ModifyRuleStatusRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 
-void ModifyRuleStatusRequest::setStatus(int status)
-{
-	status_ = status;
-	setParameter("Status", std::to_string(status));
+int ModifyRuleStatusRequest::getStatus() const {
+  return status_;
+}
+
+void ModifyRuleStatusRequest::setStatus(int status) {
+  status_ = status;
+  setParameter(std::string("Status"), std::to_string(status));
 }
 

sddp/src/model/StopMaskingProcessRequest.cc

@@ -1,73 +1,63 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
-
-#include <alibabacloud/sddp/model/StopMaskingProcessRequest.h>
-
-using AlibabaCloud::Sddp::Model::StopMaskingProcessRequest;
-
-StopMaskingProcessRequest::StopMaskingProcessRequest() :
-	RpcServiceRequest("sddp", "2019-01-03", "StopMaskingProcess")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-StopMaskingProcessRequest::~StopMaskingProcessRequest()
-{}
-
-std::string StopMaskingProcessRequest::getSourceIp()const
-{
-	return sourceIp_;
+ */
+
+#include <alibabacloud/sddp/model/StopMaskingProcessRequest.h>
+
+using AlibabaCloud::Sddp::Model::StopMaskingProcessRequest;
+
+StopMaskingProcessRequest::StopMaskingProcessRequest()
+    : RpcServiceRequest("sddp", "2019-01-03", "StopMaskingProcess") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void StopMaskingProcessRequest::setSourceIp(const std::string& sourceIp)
-{
-	sourceIp_ = sourceIp;
-	setParameter("SourceIp", sourceIp);
+StopMaskingProcessRequest::~StopMaskingProcessRequest() {}
+
+std::string StopMaskingProcessRequest::getSourceIp() const {
+  return sourceIp_;
 }
 
-long StopMaskingProcessRequest::getId()const
-{
-	return id_;
+void StopMaskingProcessRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
 }
 
-void StopMaskingProcessRequest::setId(long id)
-{
-	id_ = id;
-	setParameter("Id", std::to_string(id));
+long StopMaskingProcessRequest::getId() const {
+  return id_;
 }
 
-std::string StopMaskingProcessRequest::getLang()const
-{
-	return lang_;
+void StopMaskingProcessRequest::setId(long id) {
+  id_ = id;
+  setParameter(std::string("Id"), std::to_string(id));
 }
 
-void StopMaskingProcessRequest::setLang(const std::string& lang)
-{
-	lang_ = lang;
-	setParameter("Lang", lang);
+std::string StopMaskingProcessRequest::getLang() const {
+  return lang_;
 }
 
-int StopMaskingProcessRequest::getFeatureType()const
-{
-	return featureType_;
+void StopMaskingProcessRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
 }
 
-void StopMaskingProcessRequest::setFeatureType(int featureType)
-{
-	featureType_ = featureType;
-	setParameter("FeatureType", std::to_string(featureType));
+int StopMaskingProcessRequest::getFeatureType() const {
+  return featureType_;
+}
+
+void StopMaskingProcessRequest::setFeatureType(int featureType) {
+  featureType_ = featureType;
+  setParameter(std::string("FeatureType"), std::to_string(featureType));
 }