Support create serverless by day price type.

dds/src/DdsClient.cc

@@ -339,6 +339,42 @@ DdsClient::CreateRecommendationTaskOutcomeCallable DdsClient::createRecommendati
 	return task->get_future();
 }
 
+DdsClient::CreateServerlessDBInstanceOutcome DdsClient::createServerlessDBInstance(const CreateServerlessDBInstanceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateServerlessDBInstanceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateServerlessDBInstanceOutcome(CreateServerlessDBInstanceResult(outcome.result()));
+	else
+		return CreateServerlessDBInstanceOutcome(outcome.error());
+}
+
+void DdsClient::createServerlessDBInstanceAsync(const CreateServerlessDBInstanceRequest& request, const CreateServerlessDBInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createServerlessDBInstance(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DdsClient::CreateServerlessDBInstanceOutcomeCallable DdsClient::createServerlessDBInstanceCallable(const CreateServerlessDBInstanceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateServerlessDBInstanceOutcome()>>(
+			[this, request]()
+			{
+			return this->createServerlessDBInstance(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DdsClient::CreateShardingDBInstanceOutcome DdsClient::createShardingDBInstance(const CreateShardingDBInstanceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1167,6 +1203,42 @@ DdsClient::DescribeDBInstancesOutcomeCallable DdsClient::describeDBInstancesCall
 	return task->get_future();
 }
 
+DdsClient::DescribeDedicatedClusterInstanceListOutcome DdsClient::describeDedicatedClusterInstanceList(const DescribeDedicatedClusterInstanceListRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDedicatedClusterInstanceListOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDedicatedClusterInstanceListOutcome(DescribeDedicatedClusterInstanceListResult(outcome.result()));
+	else
+		return DescribeDedicatedClusterInstanceListOutcome(outcome.error());
+}
+
+void DdsClient::describeDedicatedClusterInstanceListAsync(const DescribeDedicatedClusterInstanceListRequest& request, const DescribeDedicatedClusterInstanceListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDedicatedClusterInstanceList(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DdsClient::DescribeDedicatedClusterInstanceListOutcomeCallable DdsClient::describeDedicatedClusterInstanceListCallable(const DescribeDedicatedClusterInstanceListRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDedicatedClusterInstanceListOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDedicatedClusterInstanceList(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DdsClient::DescribeErrorLogRecordsOutcome DdsClient::describeErrorLogRecords(const DescribeErrorLogRecordsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

dds/src/model/CreateDBInstanceRequest.cc

@@ -335,6 +335,17 @@ void CreateDBInstanceRequest::setOwnerAccount(const std::string& ownerAccount)
 	setParameter("OwnerAccount", ownerAccount);
 }
 
+std::string CreateDBInstanceRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void CreateDBInstanceRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setParameter("ClusterId", clusterId);
+}
+
 std::string CreateDBInstanceRequest::getAccountPassword()const
 {
 	return accountPassword_;

dds/src/model/CreateServerlessDBInstanceRequest.cc

@@ -0,0 +1,293 @@
+/*
+ * 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/dds/model/CreateServerlessDBInstanceRequest.h>
+
+using AlibabaCloud::Dds::Model::CreateServerlessDBInstanceRequest;
+
+CreateServerlessDBInstanceRequest::CreateServerlessDBInstanceRequest() :
+	RpcServiceRequest("dds", "2015-12-01", "CreateServerlessDBInstance")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateServerlessDBInstanceRequest::~CreateServerlessDBInstanceRequest()
+{}
+
+long CreateServerlessDBInstanceRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void CreateServerlessDBInstanceRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+int CreateServerlessDBInstanceRequest::getDBInstanceStorage()const
+{
+	return dBInstanceStorage_;
+}
+
+void CreateServerlessDBInstanceRequest::setDBInstanceStorage(int dBInstanceStorage)
+{
+	dBInstanceStorage_ = dBInstanceStorage;
+	setParameter("DBInstanceStorage", std::to_string(dBInstanceStorage));
+}
+
+std::string CreateServerlessDBInstanceRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void CreateServerlessDBInstanceRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string CreateServerlessDBInstanceRequest::getPeriodPriceType()const
+{
+	return periodPriceType_;
+}
+
+void CreateServerlessDBInstanceRequest::setPeriodPriceType(const std::string& periodPriceType)
+{
+	periodPriceType_ = periodPriceType;
+	setParameter("PeriodPriceType", periodPriceType);
+}
+
+std::string CreateServerlessDBInstanceRequest::getEngineVersion()const
+{
+	return engineVersion_;
+}
+
+void CreateServerlessDBInstanceRequest::setEngineVersion(const std::string& engineVersion)
+{
+	engineVersion_ = engineVersion;
+	setParameter("EngineVersion", engineVersion);
+}
+
+std::string CreateServerlessDBInstanceRequest::getNetworkType()const
+{
+	return networkType_;
+}
+
+void CreateServerlessDBInstanceRequest::setNetworkType(const std::string& networkType)
+{
+	networkType_ = networkType;
+	setParameter("NetworkType", networkType);
+}
+
+std::string CreateServerlessDBInstanceRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void CreateServerlessDBInstanceRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string CreateServerlessDBInstanceRequest::getStorageEngine()const
+{
+	return storageEngine_;
+}
+
+void CreateServerlessDBInstanceRequest::setStorageEngine(const std::string& storageEngine)
+{
+	storageEngine_ = storageEngine;
+	setParameter("StorageEngine", storageEngine);
+}
+
+std::string CreateServerlessDBInstanceRequest::getResourceGroupId()const
+{
+	return resourceGroupId_;
+}
+
+void CreateServerlessDBInstanceRequest::setResourceGroupId(const std::string& resourceGroupId)
+{
+	resourceGroupId_ = resourceGroupId;
+	setParameter("ResourceGroupId", resourceGroupId);
+}
+
+std::string CreateServerlessDBInstanceRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void CreateServerlessDBInstanceRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string CreateServerlessDBInstanceRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateServerlessDBInstanceRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string CreateServerlessDBInstanceRequest::getEngine()const
+{
+	return engine_;
+}
+
+void CreateServerlessDBInstanceRequest::setEngine(const std::string& engine)
+{
+	engine_ = engine;
+	setParameter("Engine", engine);
+}
+
+std::string CreateServerlessDBInstanceRequest::getDBInstanceDescription()const
+{
+	return dBInstanceDescription_;
+}
+
+void CreateServerlessDBInstanceRequest::setDBInstanceDescription(const std::string& dBInstanceDescription)
+{
+	dBInstanceDescription_ = dBInstanceDescription;
+	setParameter("DBInstanceDescription", dBInstanceDescription);
+}
+
+int CreateServerlessDBInstanceRequest::getPeriod()const
+{
+	return period_;
+}
+
+void CreateServerlessDBInstanceRequest::setPeriod(int period)
+{
+	period_ = period;
+	setParameter("Period", std::to_string(period));
+}
+
+std::string CreateServerlessDBInstanceRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void CreateServerlessDBInstanceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string CreateServerlessDBInstanceRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void CreateServerlessDBInstanceRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long CreateServerlessDBInstanceRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CreateServerlessDBInstanceRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string CreateServerlessDBInstanceRequest::getSecurityIPList()const
+{
+	return securityIPList_;
+}
+
+void CreateServerlessDBInstanceRequest::setSecurityIPList(const std::string& securityIPList)
+{
+	securityIPList_ = securityIPList;
+	setParameter("SecurityIPList", securityIPList);
+}
+
+std::string CreateServerlessDBInstanceRequest::getVSwitchId()const
+{
+	return vSwitchId_;
+}
+
+void CreateServerlessDBInstanceRequest::setVSwitchId(const std::string& vSwitchId)
+{
+	vSwitchId_ = vSwitchId;
+	setParameter("VSwitchId", vSwitchId);
+}
+
+std::string CreateServerlessDBInstanceRequest::getAccountPassword()const
+{
+	return accountPassword_;
+}
+
+void CreateServerlessDBInstanceRequest::setAccountPassword(const std::string& accountPassword)
+{
+	accountPassword_ = accountPassword;
+	setParameter("AccountPassword", accountPassword);
+}
+
+std::string CreateServerlessDBInstanceRequest::getAutoRenew()const
+{
+	return autoRenew_;
+}
+
+void CreateServerlessDBInstanceRequest::setAutoRenew(const std::string& autoRenew)
+{
+	autoRenew_ = autoRenew;
+	setParameter("AutoRenew", autoRenew);
+}
+
+std::string CreateServerlessDBInstanceRequest::getVpcId()const
+{
+	return vpcId_;
+}
+
+void CreateServerlessDBInstanceRequest::setVpcId(const std::string& vpcId)
+{
+	vpcId_ = vpcId;
+	setParameter("VpcId", vpcId);
+}
+
+std::string CreateServerlessDBInstanceRequest::getZoneId()const
+{
+	return zoneId_;
+}
+
+void CreateServerlessDBInstanceRequest::setZoneId(const std::string& zoneId)
+{
+	zoneId_ = zoneId;
+	setParameter("ZoneId", zoneId);
+}
+
+std::string CreateServerlessDBInstanceRequest::getChargeType()const
+{
+	return chargeType_;
+}
+
+void CreateServerlessDBInstanceRequest::setChargeType(const std::string& chargeType)
+{
+	chargeType_ = chargeType;
+	setParameter("ChargeType", chargeType);
+}
+

dds/src/model/CreateServerlessDBInstanceResult.cc

@@ -0,0 +1,58 @@
+/*
+ * 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/dds/model/CreateServerlessDBInstanceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dds;
+using namespace AlibabaCloud::Dds::Model;
+
+CreateServerlessDBInstanceResult::CreateServerlessDBInstanceResult() :
+	ServiceResult()
+{}
+
+CreateServerlessDBInstanceResult::CreateServerlessDBInstanceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateServerlessDBInstanceResult::~CreateServerlessDBInstanceResult()
+{}
+
+void CreateServerlessDBInstanceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["OrderId"].isNull())
+		orderId_ = value["OrderId"].asString();
+	if(!value["DBInstanceId"].isNull())
+		dBInstanceId_ = value["DBInstanceId"].asString();
+
+}
+
+std::string CreateServerlessDBInstanceResult::getDBInstanceId()const
+{
+	return dBInstanceId_;
+}
+
+std::string CreateServerlessDBInstanceResult::getOrderId()const
+{
+	return orderId_;
+}
+

dds/src/model/DescribeDBInstancesResult.cc

@@ -61,6 +61,8 @@ void DescribeDBInstancesResult::parse(const std::string &payload)
 			dBInstancesObject.dBInstanceClass = valueDBInstancesDBInstance["DBInstanceClass"].asString();
 		if(!valueDBInstancesDBInstance["DBInstanceStorage"].isNull())
 			dBInstancesObject.dBInstanceStorage = std::stoi(valueDBInstancesDBInstance["DBInstanceStorage"].asString());
+		if(!valueDBInstancesDBInstance["KindCode"].isNull())
+			dBInstancesObject.kindCode = valueDBInstancesDBInstance["KindCode"].asString();
 		if(!valueDBInstancesDBInstance["DBInstanceStatus"].isNull())
 			dBInstancesObject.dBInstanceStatus = valueDBInstancesDBInstance["DBInstanceStatus"].asString();
 		if(!valueDBInstancesDBInstance["LockMode"].isNull())

dds/src/model/DescribeDedicatedClusterInstanceListRequest.cc

@@ -0,0 +1,194 @@
+/*
+ * 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/dds/model/DescribeDedicatedClusterInstanceListRequest.h>
+
+using AlibabaCloud::Dds::Model::DescribeDedicatedClusterInstanceListRequest;
+
+DescribeDedicatedClusterInstanceListRequest::DescribeDedicatedClusterInstanceListRequest() :
+	RpcServiceRequest("dds", "2015-12-01", "DescribeDedicatedClusterInstanceList")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDedicatedClusterInstanceListRequest::~DescribeDedicatedClusterInstanceListRequest()
+{}
+
+long DescribeDedicatedClusterInstanceListRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DescribeDedicatedClusterInstanceListRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DescribeDedicatedClusterInstanceListRequest::getEngineVersion()const
+{
+	return engineVersion_;
+}
+
+void DescribeDedicatedClusterInstanceListRequest::setEngineVersion(const std::string& engineVersion)
+{
+	engineVersion_ = engineVersion;
+	setParameter("EngineVersion", engineVersion);
+}
+
+int DescribeDedicatedClusterInstanceListRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void DescribeDedicatedClusterInstanceListRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::string DescribeDedicatedClusterInstanceListRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeDedicatedClusterInstanceListRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DescribeDedicatedClusterInstanceListRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeDedicatedClusterInstanceListRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DescribeDedicatedClusterInstanceListRequest::getEngine()const
+{
+	return engine_;
+}
+
+void DescribeDedicatedClusterInstanceListRequest::setEngine(const std::string& engine)
+{
+	engine_ = engine;
+	setParameter("Engine", engine);
+}
+
+int DescribeDedicatedClusterInstanceListRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void DescribeDedicatedClusterInstanceListRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+
+int DescribeDedicatedClusterInstanceListRequest::getInstanceStatus()const
+{
+	return instanceStatus_;
+}
+
+void DescribeDedicatedClusterInstanceListRequest::setInstanceStatus(int instanceStatus)
+{
+	instanceStatus_ = instanceStatus;
+	setParameter("InstanceStatus", std::to_string(instanceStatus));
+}
+
+std::string DescribeDedicatedClusterInstanceListRequest::getDedicatedHostName()const
+{
+	return dedicatedHostName_;
+}
+
+void DescribeDedicatedClusterInstanceListRequest::setDedicatedHostName(const std::string& dedicatedHostName)
+{
+	dedicatedHostName_ = dedicatedHostName;
+	setParameter("DedicatedHostName", dedicatedHostName);
+}
+
+std::string DescribeDedicatedClusterInstanceListRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DescribeDedicatedClusterInstanceListRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DescribeDedicatedClusterInstanceListRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DescribeDedicatedClusterInstanceListRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string DescribeDedicatedClusterInstanceListRequest::getInstanceNetType()const
+{
+	return instanceNetType_;
+}
+
+void DescribeDedicatedClusterInstanceListRequest::setInstanceNetType(const std::string& instanceNetType)
+{
+	instanceNetType_ = instanceNetType;
+	setParameter("InstanceNetType", instanceNetType);
+}
+
+std::string DescribeDedicatedClusterInstanceListRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void DescribeDedicatedClusterInstanceListRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setParameter("ClusterId", clusterId);
+}
+
+long DescribeDedicatedClusterInstanceListRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeDedicatedClusterInstanceListRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeDedicatedClusterInstanceListRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void DescribeDedicatedClusterInstanceListRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+

dds/src/model/DescribeDedicatedClusterInstanceListResult.cc

@@ -0,0 +1,138 @@
+/*
+ * 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/dds/model/DescribeDedicatedClusterInstanceListResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dds;
+using namespace AlibabaCloud::Dds::Model;
+
+DescribeDedicatedClusterInstanceListResult::DescribeDedicatedClusterInstanceListResult() :
+	ServiceResult()
+{}
+
+DescribeDedicatedClusterInstanceListResult::DescribeDedicatedClusterInstanceListResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDedicatedClusterInstanceListResult::~DescribeDedicatedClusterInstanceListResult()
+{}
+
+void DescribeDedicatedClusterInstanceListResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allInstancesNode = value["Instances"]["dbInstance"];
+	for (auto valueInstancesdbInstance : allInstancesNode)
+	{
+		DbInstance instancesObject;
+		if(!valueInstancesdbInstance["Region"].isNull())
+			instancesObject.region = valueInstancesdbInstance["Region"].asString();
+		if(!valueInstancesdbInstance["ClusterId"].isNull())
+			instancesObject.clusterId = valueInstancesdbInstance["ClusterId"].asString();
+		if(!valueInstancesdbInstance["ClusterName"].isNull())
+			instancesObject.clusterName = valueInstancesdbInstance["ClusterName"].asString();
+		if(!valueInstancesdbInstance["InstanceId"].isNull())
+			instancesObject.instanceId = valueInstancesdbInstance["InstanceId"].asString();
+		if(!valueInstancesdbInstance["InstanceName"].isNull())
+			instancesObject.instanceName = valueInstancesdbInstance["InstanceName"].asString();
+		if(!valueInstancesdbInstance["InstanceStatus"].isNull())
+			instancesObject.instanceStatus = valueInstancesdbInstance["InstanceStatus"].asString();
+		if(!valueInstancesdbInstance["EngineVersion"].isNull())
+			instancesObject.engineVersion = valueInstancesdbInstance["EngineVersion"].asString();
+		if(!valueInstancesdbInstance["CharacterType"].isNull())
+			instancesObject.characterType = std::stoi(valueInstancesdbInstance["CharacterType"].asString());
+		if(!valueInstancesdbInstance["MaintainStartTime"].isNull())
+			instancesObject.maintainStartTime = valueInstancesdbInstance["MaintainStartTime"].asString();
+		if(!valueInstancesdbInstance["MaintainEndTime"].isNull())
+			instancesObject.maintainEndTime = valueInstancesdbInstance["MaintainEndTime"].asString();
+		if(!valueInstancesdbInstance["RegionId"].isNull())
+			instancesObject.regionId = valueInstancesdbInstance["RegionId"].asString();
+		if(!valueInstancesdbInstance["VpcId"].isNull())
+			instancesObject.vpcId = valueInstancesdbInstance["VpcId"].asString();
+		if(!valueInstancesdbInstance["VswitchId"].isNull())
+			instancesObject.vswitchId = valueInstancesdbInstance["VswitchId"].asString();
+		if(!valueInstancesdbInstance["ZoneId"].isNull())
+			instancesObject.zoneId = valueInstancesdbInstance["ZoneId"].asString();
+		if(!valueInstancesdbInstance["CustomId"].isNull())
+			instancesObject.customId = valueInstancesdbInstance["CustomId"].asString();
+		if(!valueInstancesdbInstance["InstanceClass"].isNull())
+			instancesObject.instanceClass = valueInstancesdbInstance["InstanceClass"].asString();
+		if(!valueInstancesdbInstance["Engine"].isNull())
+			instancesObject.engine = valueInstancesdbInstance["Engine"].asString();
+		if(!valueInstancesdbInstance["StorageType"].isNull())
+			instancesObject.storageType = valueInstancesdbInstance["StorageType"].asString();
+		if(!valueInstancesdbInstance["ConnectionDomain"].isNull())
+			instancesObject.connectionDomain = valueInstancesdbInstance["ConnectionDomain"].asString();
+		if(!valueInstancesdbInstance["CreateTime"].isNull())
+			instancesObject.createTime = valueInstancesdbInstance["CreateTime"].asString();
+		auto allInstanceNodeListNode = allInstancesNode["InstanceNodeList"]["InstanceNodes"];
+		for (auto allInstancesNodeInstanceNodeListInstanceNodes : allInstanceNodeListNode)
+		{
+			DbInstance::InstanceNodes instanceNodeListObject;
+			if(!allInstancesNodeInstanceNodeListInstanceNodes["InsName"].isNull())
+				instanceNodeListObject.insName = allInstancesNodeInstanceNodeListInstanceNodes["InsName"].asString();
+			if(!allInstancesNodeInstanceNodeListInstanceNodes["Role"].isNull())
+				instanceNodeListObject.role = allInstancesNodeInstanceNodeListInstanceNodes["Role"].asString();
+			if(!allInstancesNodeInstanceNodeListInstanceNodes["NodeId"].isNull())
+				instanceNodeListObject.nodeId = std::stoi(allInstancesNodeInstanceNodeListInstanceNodes["NodeId"].asString());
+			if(!allInstancesNodeInstanceNodeListInstanceNodes["NodeType"].isNull())
+				instanceNodeListObject.nodeType = allInstancesNodeInstanceNodeListInstanceNodes["NodeType"].asString();
+			if(!allInstancesNodeInstanceNodeListInstanceNodes["NodeIp"].isNull())
+				instanceNodeListObject.nodeIp = allInstancesNodeInstanceNodeListInstanceNodes["NodeIp"].asString();
+			if(!allInstancesNodeInstanceNodeListInstanceNodes["Port"].isNull())
+				instanceNodeListObject.port = std::stoi(allInstancesNodeInstanceNodeListInstanceNodes["Port"].asString());
+			if(!allInstancesNodeInstanceNodeListInstanceNodes["ZoneId"].isNull())
+				instanceNodeListObject.zoneId = allInstancesNodeInstanceNodeListInstanceNodes["ZoneId"].asString();
+			if(!allInstancesNodeInstanceNodeListInstanceNodes["DedicatedHostName"].isNull())
+				instanceNodeListObject.dedicatedHostName = allInstancesNodeInstanceNodeListInstanceNodes["DedicatedHostName"].asString();
+			instancesObject.instanceNodeList.push_back(instanceNodeListObject);
+		}
+		instances_.push_back(instancesObject);
+	}
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+
+}
+
+std::vector<DescribeDedicatedClusterInstanceListResult::DbInstance> DescribeDedicatedClusterInstanceListResult::getInstances()const
+{
+	return instances_;
+}
+
+int DescribeDedicatedClusterInstanceListResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int DescribeDedicatedClusterInstanceListResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeDedicatedClusterInstanceListResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+

dds/src/model/DescribeRegionsResult.cc

@@ -55,6 +55,8 @@ void DescribeRegionsResult::parse(const std::string &payload)
 				zonesObject.zoneId = allRegionsNodeZonesZone["ZoneId"].asString();
 			if(!allRegionsNodeZonesZone["VpcEnabled"].isNull())
 				zonesObject.vpcEnabled = allRegionsNodeZonesZone["VpcEnabled"].asString() == "true";
+			if(!allRegionsNodeZonesZone["ZoneName"].isNull())
+				zonesObject.zoneName = allRegionsNodeZonesZone["ZoneName"].asString();
 			regionsObject.zones.push_back(zonesObject);
 		}
 		regions_.push_back(regionsObject);