Supported set high definition monitor log status for eip.

vpc/src/model/ActivateRouterInterfaceRequest.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/vpc/model/ActivateRouterInterfaceRequest.h>
-
-using AlibabaCloud::Vpc::Model::ActivateRouterInterfaceRequest;
-
-ActivateRouterInterfaceRequest::ActivateRouterInterfaceRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "ActivateRouterInterface")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-ActivateRouterInterfaceRequest::~ActivateRouterInterfaceRequest()
-{}
-
-long ActivateRouterInterfaceRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/ActivateRouterInterfaceRequest.h>
+
+using AlibabaCloud::Vpc::Model::ActivateRouterInterfaceRequest;
+
+ActivateRouterInterfaceRequest::ActivateRouterInterfaceRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "ActivateRouterInterface") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void ActivateRouterInterfaceRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+ActivateRouterInterfaceRequest::~ActivateRouterInterfaceRequest() {}
+
+long ActivateRouterInterfaceRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string ActivateRouterInterfaceRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void ActivateRouterInterfaceRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void ActivateRouterInterfaceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string ActivateRouterInterfaceRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-long ActivateRouterInterfaceRequest::getOwnerId()const
-{
-	return ownerId_;
+void ActivateRouterInterfaceRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void ActivateRouterInterfaceRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long ActivateRouterInterfaceRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string ActivateRouterInterfaceRequest::getRouterInterfaceId()const
-{
-	return routerInterfaceId_;
+void ActivateRouterInterfaceRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void ActivateRouterInterfaceRequest::setRouterInterfaceId(const std::string& routerInterfaceId)
-{
-	routerInterfaceId_ = routerInterfaceId;
-	setParameter("RouterInterfaceId", routerInterfaceId);
+std::string ActivateRouterInterfaceRequest::getRouterInterfaceId() const {
+  return routerInterfaceId_;
 }
 
-std::string ActivateRouterInterfaceRequest::getRegionId()const
-{
-	return regionId_;
+void ActivateRouterInterfaceRequest::setRouterInterfaceId(const std::string &routerInterfaceId) {
+  routerInterfaceId_ = routerInterfaceId;
+  setParameter(std::string("RouterInterfaceId"), routerInterfaceId);
 }
 
-void ActivateRouterInterfaceRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string ActivateRouterInterfaceRequest::getRegionId() const {
+  return regionId_;
+}
+
+void ActivateRouterInterfaceRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 

vpc/src/model/ActiveFlowLogRequest.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/vpc/model/ActiveFlowLogRequest.h>
-
-using AlibabaCloud::Vpc::Model::ActiveFlowLogRequest;
-
-ActiveFlowLogRequest::ActiveFlowLogRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "ActiveFlowLog")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-ActiveFlowLogRequest::~ActiveFlowLogRequest()
-{}
-
-long ActiveFlowLogRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/ActiveFlowLogRequest.h>
+
+using AlibabaCloud::Vpc::Model::ActiveFlowLogRequest;
+
+ActiveFlowLogRequest::ActiveFlowLogRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "ActiveFlowLog") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void ActiveFlowLogRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+ActiveFlowLogRequest::~ActiveFlowLogRequest() {}
+
+long ActiveFlowLogRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string ActiveFlowLogRequest::getRegionId()const
-{
-	return regionId_;
+void ActiveFlowLogRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void ActiveFlowLogRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string ActiveFlowLogRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string ActiveFlowLogRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void ActiveFlowLogRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void ActiveFlowLogRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string ActiveFlowLogRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string ActiveFlowLogRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void ActiveFlowLogRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void ActiveFlowLogRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string ActiveFlowLogRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long ActiveFlowLogRequest::getOwnerId()const
-{
-	return ownerId_;
+void ActiveFlowLogRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void ActiveFlowLogRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long ActiveFlowLogRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string ActiveFlowLogRequest::getFlowLogId()const
-{
-	return flowLogId_;
+void ActiveFlowLogRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void ActiveFlowLogRequest::setFlowLogId(const std::string& flowLogId)
-{
-	flowLogId_ = flowLogId;
-	setParameter("FlowLogId", flowLogId);
+std::string ActiveFlowLogRequest::getFlowLogId() const {
+  return flowLogId_;
+}
+
+void ActiveFlowLogRequest::setFlowLogId(const std::string &flowLogId) {
+  flowLogId_ = flowLogId;
+  setParameter(std::string("FlowLogId"), flowLogId);
 }
 

vpc/src/model/AddBgpNetworkRequest.cc

@@ -1,128 +1,117 @@
 /*
  * 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/vpc/model/AddBgpNetworkRequest.h>
-
-using AlibabaCloud::Vpc::Model::AddBgpNetworkRequest;
-
-AddBgpNetworkRequest::AddBgpNetworkRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "AddBgpNetwork")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-AddBgpNetworkRequest::~AddBgpNetworkRequest()
-{}
-
-long AddBgpNetworkRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/AddBgpNetworkRequest.h>
+
+using AlibabaCloud::Vpc::Model::AddBgpNetworkRequest;
+
+AddBgpNetworkRequest::AddBgpNetworkRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "AddBgpNetwork") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void AddBgpNetworkRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+AddBgpNetworkRequest::~AddBgpNetworkRequest() {}
+
+long AddBgpNetworkRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string AddBgpNetworkRequest::getClientToken()const
-{
-	return clientToken_;
+void AddBgpNetworkRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void AddBgpNetworkRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string AddBgpNetworkRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string AddBgpNetworkRequest::getRegionId()const
-{
-	return regionId_;
+void AddBgpNetworkRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void AddBgpNetworkRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string AddBgpNetworkRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string AddBgpNetworkRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void AddBgpNetworkRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void AddBgpNetworkRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string AddBgpNetworkRequest::getIpVersion() const {
+  return ipVersion_;
 }
 
-std::string AddBgpNetworkRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void AddBgpNetworkRequest::setIpVersion(const std::string &ipVersion) {
+  ipVersion_ = ipVersion;
+  setParameter(std::string("IpVersion"), ipVersion);
 }
 
-void AddBgpNetworkRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string AddBgpNetworkRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-long AddBgpNetworkRequest::getOwnerId()const
-{
-	return ownerId_;
+void AddBgpNetworkRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void AddBgpNetworkRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+std::string AddBgpNetworkRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-std::string AddBgpNetworkRequest::getRouterId()const
-{
-	return routerId_;
+void AddBgpNetworkRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void AddBgpNetworkRequest::setRouterId(const std::string& routerId)
-{
-	routerId_ = routerId;
-	setParameter("RouterId", routerId);
+long AddBgpNetworkRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string AddBgpNetworkRequest::getVpcId()const
-{
-	return vpcId_;
+void AddBgpNetworkRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void AddBgpNetworkRequest::setVpcId(const std::string& vpcId)
-{
-	vpcId_ = vpcId;
-	setParameter("VpcId", vpcId);
+std::string AddBgpNetworkRequest::getRouterId() const {
+  return routerId_;
 }
 
-std::string AddBgpNetworkRequest::getDstCidrBlock()const
-{
-	return dstCidrBlock_;
+void AddBgpNetworkRequest::setRouterId(const std::string &routerId) {
+  routerId_ = routerId;
+  setParameter(std::string("RouterId"), routerId);
 }
 
-void AddBgpNetworkRequest::setDstCidrBlock(const std::string& dstCidrBlock)
-{
-	dstCidrBlock_ = dstCidrBlock;
-	setParameter("DstCidrBlock", dstCidrBlock);
+std::string AddBgpNetworkRequest::getVpcId() const {
+  return vpcId_;
+}
+
+void AddBgpNetworkRequest::setVpcId(const std::string &vpcId) {
+  vpcId_ = vpcId;
+  setParameter(std::string("VpcId"), vpcId);
+}
+
+std::string AddBgpNetworkRequest::getDstCidrBlock() const {
+  return dstCidrBlock_;
+}
+
+void AddBgpNetworkRequest::setDstCidrBlock(const std::string &dstCidrBlock) {
+  dstCidrBlock_ = dstCidrBlock;
+  setParameter(std::string("DstCidrBlock"), dstCidrBlock);
 }
 

vpc/src/model/AddCommonBandwidthPackageIpRequest.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/vpc/model/AddCommonBandwidthPackageIpRequest.h>
-
-using AlibabaCloud::Vpc::Model::AddCommonBandwidthPackageIpRequest;
-
-AddCommonBandwidthPackageIpRequest::AddCommonBandwidthPackageIpRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "AddCommonBandwidthPackageIp")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-AddCommonBandwidthPackageIpRequest::~AddCommonBandwidthPackageIpRequest()
-{}
-
-long AddCommonBandwidthPackageIpRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/AddCommonBandwidthPackageIpRequest.h>
+
+using AlibabaCloud::Vpc::Model::AddCommonBandwidthPackageIpRequest;
+
+AddCommonBandwidthPackageIpRequest::AddCommonBandwidthPackageIpRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "AddCommonBandwidthPackageIp") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void AddCommonBandwidthPackageIpRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+AddCommonBandwidthPackageIpRequest::~AddCommonBandwidthPackageIpRequest() {}
+
+long AddCommonBandwidthPackageIpRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string AddCommonBandwidthPackageIpRequest::getClientToken()const
-{
-	return clientToken_;
+void AddCommonBandwidthPackageIpRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void AddCommonBandwidthPackageIpRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string AddCommonBandwidthPackageIpRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string AddCommonBandwidthPackageIpRequest::getRegionId()const
-{
-	return regionId_;
+void AddCommonBandwidthPackageIpRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void AddCommonBandwidthPackageIpRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string AddCommonBandwidthPackageIpRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string AddCommonBandwidthPackageIpRequest::getBandwidthPackageId()const
-{
-	return bandwidthPackageId_;
+void AddCommonBandwidthPackageIpRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void AddCommonBandwidthPackageIpRequest::setBandwidthPackageId(const std::string& bandwidthPackageId)
-{
-	bandwidthPackageId_ = bandwidthPackageId;
-	setParameter("BandwidthPackageId", bandwidthPackageId);
+std::string AddCommonBandwidthPackageIpRequest::getBandwidthPackageId() const {
+  return bandwidthPackageId_;
 }
 
-std::string AddCommonBandwidthPackageIpRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void AddCommonBandwidthPackageIpRequest::setBandwidthPackageId(const std::string &bandwidthPackageId) {
+  bandwidthPackageId_ = bandwidthPackageId;
+  setParameter(std::string("BandwidthPackageId"), bandwidthPackageId);
 }
 
-void AddCommonBandwidthPackageIpRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string AddCommonBandwidthPackageIpRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string AddCommonBandwidthPackageIpRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void AddCommonBandwidthPackageIpRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void AddCommonBandwidthPackageIpRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string AddCommonBandwidthPackageIpRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long AddCommonBandwidthPackageIpRequest::getOwnerId()const
-{
-	return ownerId_;
+void AddCommonBandwidthPackageIpRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void AddCommonBandwidthPackageIpRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long AddCommonBandwidthPackageIpRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string AddCommonBandwidthPackageIpRequest::getIpType()const
-{
-	return ipType_;
+void AddCommonBandwidthPackageIpRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void AddCommonBandwidthPackageIpRequest::setIpType(const std::string& ipType)
-{
-	ipType_ = ipType;
-	setParameter("IpType", ipType);
+std::string AddCommonBandwidthPackageIpRequest::getIpType() const {
+  return ipType_;
 }
 
-std::string AddCommonBandwidthPackageIpRequest::getIpInstanceId()const
-{
-	return ipInstanceId_;
+void AddCommonBandwidthPackageIpRequest::setIpType(const std::string &ipType) {
+  ipType_ = ipType;
+  setParameter(std::string("IpType"), ipType);
 }
 
-void AddCommonBandwidthPackageIpRequest::setIpInstanceId(const std::string& ipInstanceId)
-{
-	ipInstanceId_ = ipInstanceId;
-	setParameter("IpInstanceId", ipInstanceId);
+std::string AddCommonBandwidthPackageIpRequest::getIpInstanceId() const {
+  return ipInstanceId_;
+}
+
+void AddCommonBandwidthPackageIpRequest::setIpInstanceId(const std::string &ipInstanceId) {
+  ipInstanceId_ = ipInstanceId;
+  setParameter(std::string("IpInstanceId"), ipInstanceId);
 }
 

vpc/src/model/AddCommonBandwidthPackageIpsRequest.cc

@@ -1,130 +1,107 @@
 /*
  * 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/vpc/model/AddCommonBandwidthPackageIpsRequest.h>
-
-using AlibabaCloud::Vpc::Model::AddCommonBandwidthPackageIpsRequest;
-
-AddCommonBandwidthPackageIpsRequest::AddCommonBandwidthPackageIpsRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "AddCommonBandwidthPackageIps")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-AddCommonBandwidthPackageIpsRequest::~AddCommonBandwidthPackageIpsRequest()
-{}
-
-long AddCommonBandwidthPackageIpsRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/AddCommonBandwidthPackageIpsRequest.h>
+
+using AlibabaCloud::Vpc::Model::AddCommonBandwidthPackageIpsRequest;
+
+AddCommonBandwidthPackageIpsRequest::AddCommonBandwidthPackageIpsRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "AddCommonBandwidthPackageIps") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void AddCommonBandwidthPackageIpsRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+AddCommonBandwidthPackageIpsRequest::~AddCommonBandwidthPackageIpsRequest() {}
+
+long AddCommonBandwidthPackageIpsRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string AddCommonBandwidthPackageIpsRequest::getClientToken()const
-{
-	return clientToken_;
+void AddCommonBandwidthPackageIpsRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void AddCommonBandwidthPackageIpsRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string AddCommonBandwidthPackageIpsRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::vector<std::string> AddCommonBandwidthPackageIpsRequest::getIpInstanceIds()const
-{
-	return ipInstanceIds_;
+void AddCommonBandwidthPackageIpsRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void AddCommonBandwidthPackageIpsRequest::setIpInstanceIds(const std::vector<std::string>& ipInstanceIds)
-{
-	ipInstanceIds_ = ipInstanceIds;
-	for(int dep1 = 0; dep1!= ipInstanceIds.size(); dep1++) {
-		setParameter("IpInstanceIds."+ std::to_string(dep1), ipInstanceIds.at(dep1));
-	}
+std::vector<std::string> AddCommonBandwidthPackageIpsRequest::getIpInstanceIds() const {
+  return ipInstanceIds_;
 }
 
-std::string AddCommonBandwidthPackageIpsRequest::getRegionId()const
-{
-	return regionId_;
+void AddCommonBandwidthPackageIpsRequest::setIpInstanceIds(const std::vector<std::string> &ipInstanceIds) {
+  ipInstanceIds_ = ipInstanceIds;
 }
 
-void AddCommonBandwidthPackageIpsRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string AddCommonBandwidthPackageIpsRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string AddCommonBandwidthPackageIpsRequest::getBandwidthPackageId()const
-{
-	return bandwidthPackageId_;
+void AddCommonBandwidthPackageIpsRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void AddCommonBandwidthPackageIpsRequest::setBandwidthPackageId(const std::string& bandwidthPackageId)
-{
-	bandwidthPackageId_ = bandwidthPackageId;
-	setParameter("BandwidthPackageId", bandwidthPackageId);
+std::string AddCommonBandwidthPackageIpsRequest::getBandwidthPackageId() const {
+  return bandwidthPackageId_;
 }
 
-std::string AddCommonBandwidthPackageIpsRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void AddCommonBandwidthPackageIpsRequest::setBandwidthPackageId(const std::string &bandwidthPackageId) {
+  bandwidthPackageId_ = bandwidthPackageId;
+  setParameter(std::string("BandwidthPackageId"), bandwidthPackageId);
 }
 
-void AddCommonBandwidthPackageIpsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string AddCommonBandwidthPackageIpsRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string AddCommonBandwidthPackageIpsRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void AddCommonBandwidthPackageIpsRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void AddCommonBandwidthPackageIpsRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string AddCommonBandwidthPackageIpsRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long AddCommonBandwidthPackageIpsRequest::getOwnerId()const
-{
-	return ownerId_;
+void AddCommonBandwidthPackageIpsRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void AddCommonBandwidthPackageIpsRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long AddCommonBandwidthPackageIpsRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string AddCommonBandwidthPackageIpsRequest::getIpType()const
-{
-	return ipType_;
+void AddCommonBandwidthPackageIpsRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void AddCommonBandwidthPackageIpsRequest::setIpType(const std::string& ipType)
-{
-	ipType_ = ipType;
-	setParameter("IpType", ipType);
+std::string AddCommonBandwidthPackageIpsRequest::getIpType() const {
+  return ipType_;
+}
+
+void AddCommonBandwidthPackageIpsRequest::setIpType(const std::string &ipType) {
+  ipType_ = ipType;
+  setParameter(std::string("IpType"), ipType);
 }
 

vpc/src/model/AddGlobalAccelerationInstanceIpRequest.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/vpc/model/AddGlobalAccelerationInstanceIpRequest.h>
-
-using AlibabaCloud::Vpc::Model::AddGlobalAccelerationInstanceIpRequest;
-
-AddGlobalAccelerationInstanceIpRequest::AddGlobalAccelerationInstanceIpRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "AddGlobalAccelerationInstanceIp")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-AddGlobalAccelerationInstanceIpRequest::~AddGlobalAccelerationInstanceIpRequest()
-{}
-
-long AddGlobalAccelerationInstanceIpRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/AddGlobalAccelerationInstanceIpRequest.h>
+
+using AlibabaCloud::Vpc::Model::AddGlobalAccelerationInstanceIpRequest;
+
+AddGlobalAccelerationInstanceIpRequest::AddGlobalAccelerationInstanceIpRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "AddGlobalAccelerationInstanceIp") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void AddGlobalAccelerationInstanceIpRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+AddGlobalAccelerationInstanceIpRequest::~AddGlobalAccelerationInstanceIpRequest() {}
+
+long AddGlobalAccelerationInstanceIpRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string AddGlobalAccelerationInstanceIpRequest::getGlobalAccelerationInstanceId()const
-{
-	return globalAccelerationInstanceId_;
+void AddGlobalAccelerationInstanceIpRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void AddGlobalAccelerationInstanceIpRequest::setGlobalAccelerationInstanceId(const std::string& globalAccelerationInstanceId)
-{
-	globalAccelerationInstanceId_ = globalAccelerationInstanceId;
-	setParameter("GlobalAccelerationInstanceId", globalAccelerationInstanceId);
+std::string AddGlobalAccelerationInstanceIpRequest::getGlobalAccelerationInstanceId() const {
+  return globalAccelerationInstanceId_;
 }
 
-std::string AddGlobalAccelerationInstanceIpRequest::getRegionId()const
-{
-	return regionId_;
+void AddGlobalAccelerationInstanceIpRequest::setGlobalAccelerationInstanceId(const std::string &globalAccelerationInstanceId) {
+  globalAccelerationInstanceId_ = globalAccelerationInstanceId;
+  setParameter(std::string("GlobalAccelerationInstanceId"), globalAccelerationInstanceId);
 }
 
-void AddGlobalAccelerationInstanceIpRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string AddGlobalAccelerationInstanceIpRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string AddGlobalAccelerationInstanceIpRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void AddGlobalAccelerationInstanceIpRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void AddGlobalAccelerationInstanceIpRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string AddGlobalAccelerationInstanceIpRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string AddGlobalAccelerationInstanceIpRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void AddGlobalAccelerationInstanceIpRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void AddGlobalAccelerationInstanceIpRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string AddGlobalAccelerationInstanceIpRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long AddGlobalAccelerationInstanceIpRequest::getOwnerId()const
-{
-	return ownerId_;
+void AddGlobalAccelerationInstanceIpRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void AddGlobalAccelerationInstanceIpRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long AddGlobalAccelerationInstanceIpRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string AddGlobalAccelerationInstanceIpRequest::getIpInstanceId()const
-{
-	return ipInstanceId_;
+void AddGlobalAccelerationInstanceIpRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void AddGlobalAccelerationInstanceIpRequest::setIpInstanceId(const std::string& ipInstanceId)
-{
-	ipInstanceId_ = ipInstanceId;
-	setParameter("IpInstanceId", ipInstanceId);
+std::string AddGlobalAccelerationInstanceIpRequest::getIpInstanceId() const {
+  return ipInstanceId_;
+}
+
+void AddGlobalAccelerationInstanceIpRequest::setIpInstanceId(const std::string &ipInstanceId) {
+  ipInstanceId_ = ipInstanceId;
+  setParameter(std::string("IpInstanceId"), ipInstanceId);
 }
 

vpc/src/model/AddIPv6TranslatorAclListEntryRequest.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/vpc/model/AddIPv6TranslatorAclListEntryRequest.h>
-
-using AlibabaCloud::Vpc::Model::AddIPv6TranslatorAclListEntryRequest;
-
-AddIPv6TranslatorAclListEntryRequest::AddIPv6TranslatorAclListEntryRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "AddIPv6TranslatorAclListEntry")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-AddIPv6TranslatorAclListEntryRequest::~AddIPv6TranslatorAclListEntryRequest()
-{}
-
-long AddIPv6TranslatorAclListEntryRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/AddIPv6TranslatorAclListEntryRequest.h>
+
+using AlibabaCloud::Vpc::Model::AddIPv6TranslatorAclListEntryRequest;
+
+AddIPv6TranslatorAclListEntryRequest::AddIPv6TranslatorAclListEntryRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "AddIPv6TranslatorAclListEntry") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void AddIPv6TranslatorAclListEntryRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+AddIPv6TranslatorAclListEntryRequest::~AddIPv6TranslatorAclListEntryRequest() {}
+
+long AddIPv6TranslatorAclListEntryRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string AddIPv6TranslatorAclListEntryRequest::getRegionId()const
-{
-	return regionId_;
+void AddIPv6TranslatorAclListEntryRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void AddIPv6TranslatorAclListEntryRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string AddIPv6TranslatorAclListEntryRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string AddIPv6TranslatorAclListEntryRequest::getAclId()const
-{
-	return aclId_;
+void AddIPv6TranslatorAclListEntryRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void AddIPv6TranslatorAclListEntryRequest::setAclId(const std::string& aclId)
-{
-	aclId_ = aclId;
-	setParameter("AclId", aclId);
+std::string AddIPv6TranslatorAclListEntryRequest::getAclId() const {
+  return aclId_;
 }
 
-std::string AddIPv6TranslatorAclListEntryRequest::getAclEntryIp()const
-{
-	return aclEntryIp_;
+void AddIPv6TranslatorAclListEntryRequest::setAclId(const std::string &aclId) {
+  aclId_ = aclId;
+  setParameter(std::string("AclId"), aclId);
 }
 
-void AddIPv6TranslatorAclListEntryRequest::setAclEntryIp(const std::string& aclEntryIp)
-{
-	aclEntryIp_ = aclEntryIp;
-	setParameter("AclEntryIp", aclEntryIp);
+std::string AddIPv6TranslatorAclListEntryRequest::getAclEntryIp() const {
+  return aclEntryIp_;
 }
 
-std::string AddIPv6TranslatorAclListEntryRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void AddIPv6TranslatorAclListEntryRequest::setAclEntryIp(const std::string &aclEntryIp) {
+  aclEntryIp_ = aclEntryIp;
+  setParameter(std::string("AclEntryIp"), aclEntryIp);
 }
 
-void AddIPv6TranslatorAclListEntryRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string AddIPv6TranslatorAclListEntryRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string AddIPv6TranslatorAclListEntryRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void AddIPv6TranslatorAclListEntryRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void AddIPv6TranslatorAclListEntryRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string AddIPv6TranslatorAclListEntryRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-std::string AddIPv6TranslatorAclListEntryRequest::getAclEntryComment()const
-{
-	return aclEntryComment_;
+void AddIPv6TranslatorAclListEntryRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void AddIPv6TranslatorAclListEntryRequest::setAclEntryComment(const std::string& aclEntryComment)
-{
-	aclEntryComment_ = aclEntryComment;
-	setParameter("AclEntryComment", aclEntryComment);
+std::string AddIPv6TranslatorAclListEntryRequest::getAclEntryComment() const {
+  return aclEntryComment_;
 }
 
-long AddIPv6TranslatorAclListEntryRequest::getOwnerId()const
-{
-	return ownerId_;
+void AddIPv6TranslatorAclListEntryRequest::setAclEntryComment(const std::string &aclEntryComment) {
+  aclEntryComment_ = aclEntryComment;
+  setParameter(std::string("AclEntryComment"), aclEntryComment);
 }
 
-void AddIPv6TranslatorAclListEntryRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long AddIPv6TranslatorAclListEntryRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void AddIPv6TranslatorAclListEntryRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 

vpc/src/model/AddPublicIpAddressPoolCidrBlockRequest.cc

@@ -0,0 +1,117 @@
+/*
+ * 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/vpc/model/AddPublicIpAddressPoolCidrBlockRequest.h>
+
+using AlibabaCloud::Vpc::Model::AddPublicIpAddressPoolCidrBlockRequest;
+
+AddPublicIpAddressPoolCidrBlockRequest::AddPublicIpAddressPoolCidrBlockRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "AddPublicIpAddressPoolCidrBlock") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+AddPublicIpAddressPoolCidrBlockRequest::~AddPublicIpAddressPoolCidrBlockRequest() {}
+
+int AddPublicIpAddressPoolCidrBlockRequest::getCidrMask() const {
+  return cidrMask_;
+}
+
+void AddPublicIpAddressPoolCidrBlockRequest::setCidrMask(int cidrMask) {
+  cidrMask_ = cidrMask;
+  setParameter(std::string("CidrMask"), std::to_string(cidrMask));
+}
+
+std::string AddPublicIpAddressPoolCidrBlockRequest::getPublicIpAddressPoolId() const {
+  return publicIpAddressPoolId_;
+}
+
+void AddPublicIpAddressPoolCidrBlockRequest::setPublicIpAddressPoolId(const std::string &publicIpAddressPoolId) {
+  publicIpAddressPoolId_ = publicIpAddressPoolId;
+  setParameter(std::string("PublicIpAddressPoolId"), publicIpAddressPoolId);
+}
+
+long AddPublicIpAddressPoolCidrBlockRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void AddPublicIpAddressPoolCidrBlockRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string AddPublicIpAddressPoolCidrBlockRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void AddPublicIpAddressPoolCidrBlockRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string AddPublicIpAddressPoolCidrBlockRequest::getRegionId() const {
+  return regionId_;
+}
+
+void AddPublicIpAddressPoolCidrBlockRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+bool AddPublicIpAddressPoolCidrBlockRequest::getDryRun() const {
+  return dryRun_;
+}
+
+void AddPublicIpAddressPoolCidrBlockRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setParameter(std::string("DryRun"), dryRun ? "true" : "false");
+}
+
+std::string AddPublicIpAddressPoolCidrBlockRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void AddPublicIpAddressPoolCidrBlockRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string AddPublicIpAddressPoolCidrBlockRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void AddPublicIpAddressPoolCidrBlockRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long AddPublicIpAddressPoolCidrBlockRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void AddPublicIpAddressPoolCidrBlockRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string AddPublicIpAddressPoolCidrBlockRequest::getCidrBlock() const {
+  return cidrBlock_;
+}
+
+void AddPublicIpAddressPoolCidrBlockRequest::setCidrBlock(const std::string &cidrBlock) {
+  cidrBlock_ = cidrBlock;
+  setParameter(std::string("CidrBlock"), cidrBlock);
+}
+

vpc/src/model/AddPublicIpAddressPoolCidrBlockResult.cc

@@ -0,0 +1,44 @@
+/*
+ * 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/vpc/model/AddPublicIpAddressPoolCidrBlockResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vpc;
+using namespace AlibabaCloud::Vpc::Model;
+
+AddPublicIpAddressPoolCidrBlockResult::AddPublicIpAddressPoolCidrBlockResult() :
+	ServiceResult()
+{}
+
+AddPublicIpAddressPoolCidrBlockResult::AddPublicIpAddressPoolCidrBlockResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+AddPublicIpAddressPoolCidrBlockResult::~AddPublicIpAddressPoolCidrBlockResult()
+{}
+
+void AddPublicIpAddressPoolCidrBlockResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

vpc/src/model/AddSourcesToTrafficMirrorSessionRequest.cc

@@ -1,130 +1,107 @@
 /*
  * 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/vpc/model/AddSourcesToTrafficMirrorSessionRequest.h>
-
-using AlibabaCloud::Vpc::Model::AddSourcesToTrafficMirrorSessionRequest;
-
-AddSourcesToTrafficMirrorSessionRequest::AddSourcesToTrafficMirrorSessionRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "AddSourcesToTrafficMirrorSession")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-AddSourcesToTrafficMirrorSessionRequest::~AddSourcesToTrafficMirrorSessionRequest()
-{}
-
-long AddSourcesToTrafficMirrorSessionRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/AddSourcesToTrafficMirrorSessionRequest.h>
+
+using AlibabaCloud::Vpc::Model::AddSourcesToTrafficMirrorSessionRequest;
+
+AddSourcesToTrafficMirrorSessionRequest::AddSourcesToTrafficMirrorSessionRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "AddSourcesToTrafficMirrorSession") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void AddSourcesToTrafficMirrorSessionRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+AddSourcesToTrafficMirrorSessionRequest::~AddSourcesToTrafficMirrorSessionRequest() {}
+
+long AddSourcesToTrafficMirrorSessionRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string AddSourcesToTrafficMirrorSessionRequest::getClientToken()const
-{
-	return clientToken_;
+void AddSourcesToTrafficMirrorSessionRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void AddSourcesToTrafficMirrorSessionRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string AddSourcesToTrafficMirrorSessionRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string AddSourcesToTrafficMirrorSessionRequest::getRegionId()const
-{
-	return regionId_;
+void AddSourcesToTrafficMirrorSessionRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void AddSourcesToTrafficMirrorSessionRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string AddSourcesToTrafficMirrorSessionRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::vector<std::string> AddSourcesToTrafficMirrorSessionRequest::getTrafficMirrorSourceIds()const
-{
-	return trafficMirrorSourceIds_;
+void AddSourcesToTrafficMirrorSessionRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void AddSourcesToTrafficMirrorSessionRequest::setTrafficMirrorSourceIds(const std::vector<std::string>& trafficMirrorSourceIds)
-{
-	trafficMirrorSourceIds_ = trafficMirrorSourceIds;
-	for(int dep1 = 0; dep1!= trafficMirrorSourceIds.size(); dep1++) {
-		setParameter("TrafficMirrorSourceIds."+ std::to_string(dep1), trafficMirrorSourceIds.at(dep1));
-	}
+std::vector<std::string> AddSourcesToTrafficMirrorSessionRequest::getTrafficMirrorSourceIds() const {
+  return trafficMirrorSourceIds_;
 }
 
-bool AddSourcesToTrafficMirrorSessionRequest::getDryRun()const
-{
-	return dryRun_;
+void AddSourcesToTrafficMirrorSessionRequest::setTrafficMirrorSourceIds(const std::vector<std::string> &trafficMirrorSourceIds) {
+  trafficMirrorSourceIds_ = trafficMirrorSourceIds;
 }
 
-void AddSourcesToTrafficMirrorSessionRequest::setDryRun(bool dryRun)
-{
-	dryRun_ = dryRun;
-	setParameter("DryRun", dryRun ? "true" : "false");
+bool AddSourcesToTrafficMirrorSessionRequest::getDryRun() const {
+  return dryRun_;
 }
 
-std::string AddSourcesToTrafficMirrorSessionRequest::getTrafficMirrorSessionId()const
-{
-	return trafficMirrorSessionId_;
+void AddSourcesToTrafficMirrorSessionRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setParameter(std::string("DryRun"), dryRun ? "true" : "false");
 }
 
-void AddSourcesToTrafficMirrorSessionRequest::setTrafficMirrorSessionId(const std::string& trafficMirrorSessionId)
-{
-	trafficMirrorSessionId_ = trafficMirrorSessionId;
-	setParameter("TrafficMirrorSessionId", trafficMirrorSessionId);
+std::string AddSourcesToTrafficMirrorSessionRequest::getTrafficMirrorSessionId() const {
+  return trafficMirrorSessionId_;
 }
 
-std::string AddSourcesToTrafficMirrorSessionRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void AddSourcesToTrafficMirrorSessionRequest::setTrafficMirrorSessionId(const std::string &trafficMirrorSessionId) {
+  trafficMirrorSessionId_ = trafficMirrorSessionId;
+  setParameter(std::string("TrafficMirrorSessionId"), trafficMirrorSessionId);
 }
 
-void AddSourcesToTrafficMirrorSessionRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string AddSourcesToTrafficMirrorSessionRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string AddSourcesToTrafficMirrorSessionRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void AddSourcesToTrafficMirrorSessionRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void AddSourcesToTrafficMirrorSessionRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string AddSourcesToTrafficMirrorSessionRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long AddSourcesToTrafficMirrorSessionRequest::getOwnerId()const
-{
-	return ownerId_;
+void AddSourcesToTrafficMirrorSessionRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void AddSourcesToTrafficMirrorSessionRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long AddSourcesToTrafficMirrorSessionRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void AddSourcesToTrafficMirrorSessionRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 

vpc/src/model/AllocateEipAddressProRequest.cc

@@ -1,216 +1,197 @@
 /*
  * 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/vpc/model/AllocateEipAddressProRequest.h>
-
-using AlibabaCloud::Vpc::Model::AllocateEipAddressProRequest;
-
-AllocateEipAddressProRequest::AllocateEipAddressProRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "AllocateEipAddressPro")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-AllocateEipAddressProRequest::~AllocateEipAddressProRequest()
-{}
-
-std::string AllocateEipAddressProRequest::getIpAddress()const
-{
-	return ipAddress_;
+ */
+
+#include <alibabacloud/vpc/model/AllocateEipAddressProRequest.h>
+
+using AlibabaCloud::Vpc::Model::AllocateEipAddressProRequest;
+
+AllocateEipAddressProRequest::AllocateEipAddressProRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "AllocateEipAddressPro") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void AllocateEipAddressProRequest::setIpAddress(const std::string& ipAddress)
-{
-	ipAddress_ = ipAddress;
-	setParameter("IpAddress", ipAddress);
+AllocateEipAddressProRequest::~AllocateEipAddressProRequest() {}
+
+std::string AllocateEipAddressProRequest::getIpAddress() const {
+  return ipAddress_;
 }
 
-long AllocateEipAddressProRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+void AllocateEipAddressProRequest::setIpAddress(const std::string &ipAddress) {
+  ipAddress_ = ipAddress;
+  setParameter(std::string("IpAddress"), ipAddress);
 }
 
-void AllocateEipAddressProRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+long AllocateEipAddressProRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string AllocateEipAddressProRequest::getClientToken()const
-{
-	return clientToken_;
+void AllocateEipAddressProRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void AllocateEipAddressProRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string AllocateEipAddressProRequest::getPublicIpAddressPoolId() const {
+  return publicIpAddressPoolId_;
 }
 
-std::string AllocateEipAddressProRequest::getISP()const
-{
-	return iSP_;
+void AllocateEipAddressProRequest::setPublicIpAddressPoolId(const std::string &publicIpAddressPoolId) {
+  publicIpAddressPoolId_ = publicIpAddressPoolId;
+  setParameter(std::string("PublicIpAddressPoolId"), publicIpAddressPoolId);
 }
 
-void AllocateEipAddressProRequest::setISP(const std::string& iSP)
-{
-	iSP_ = iSP;
-	setParameter("ISP", iSP);
+std::string AllocateEipAddressProRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string AllocateEipAddressProRequest::getResourceGroupId()const
-{
-	return resourceGroupId_;
+void AllocateEipAddressProRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void AllocateEipAddressProRequest::setResourceGroupId(const std::string& resourceGroupId)
-{
-	resourceGroupId_ = resourceGroupId;
-	setParameter("ResourceGroupId", resourceGroupId);
+std::string AllocateEipAddressProRequest::getISP() const {
+  return iSP_;
 }
 
-std::string AllocateEipAddressProRequest::getRegionId()const
-{
-	return regionId_;
+void AllocateEipAddressProRequest::setISP(const std::string &iSP) {
+  iSP_ = iSP;
+  setParameter(std::string("ISP"), iSP);
 }
 
-void AllocateEipAddressProRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string AllocateEipAddressProRequest::getResourceGroupId() const {
+  return resourceGroupId_;
 }
 
-std::string AllocateEipAddressProRequest::getNetmode()const
-{
-	return netmode_;
+void AllocateEipAddressProRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
 }
 
-void AllocateEipAddressProRequest::setNetmode(const std::string& netmode)
-{
-	netmode_ = netmode;
-	setParameter("Netmode", netmode);
+std::string AllocateEipAddressProRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string AllocateEipAddressProRequest::getInstanceChargeType()const
-{
-	return instanceChargeType_;
+void AllocateEipAddressProRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void AllocateEipAddressProRequest::setInstanceChargeType(const std::string& instanceChargeType)
-{
-	instanceChargeType_ = instanceChargeType;
-	setParameter("InstanceChargeType", instanceChargeType);
+std::string AllocateEipAddressProRequest::getNetmode() const {
+  return netmode_;
 }
 
-int AllocateEipAddressProRequest::getPeriod()const
-{
-	return period_;
+void AllocateEipAddressProRequest::setNetmode(const std::string &netmode) {
+  netmode_ = netmode;
+  setParameter(std::string("Netmode"), netmode);
 }
 
-void AllocateEipAddressProRequest::setPeriod(int period)
-{
-	period_ = period;
-	setParameter("Period", std::to_string(period));
+std::string AllocateEipAddressProRequest::getInstanceChargeType() const {
+  return instanceChargeType_;
 }
 
-bool AllocateEipAddressProRequest::getAutoPay()const
-{
-	return autoPay_;
+void AllocateEipAddressProRequest::setInstanceChargeType(const std::string &instanceChargeType) {
+  instanceChargeType_ = instanceChargeType;
+  setParameter(std::string("InstanceChargeType"), instanceChargeType);
 }
 
-void AllocateEipAddressProRequest::setAutoPay(bool autoPay)
-{
-	autoPay_ = autoPay;
-	setParameter("AutoPay", autoPay ? "true" : "false");
+int AllocateEipAddressProRequest::getPeriod() const {
+  return period_;
 }
 
-std::string AllocateEipAddressProRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void AllocateEipAddressProRequest::setPeriod(int period) {
+  period_ = period;
+  setParameter(std::string("Period"), std::to_string(period));
 }
 
-void AllocateEipAddressProRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+bool AllocateEipAddressProRequest::getAutoPay() const {
+  return autoPay_;
 }
 
-std::string AllocateEipAddressProRequest::getBandwidth()const
-{
-	return bandwidth_;
+void AllocateEipAddressProRequest::setAutoPay(bool autoPay) {
+  autoPay_ = autoPay;
+  setParameter(std::string("AutoPay"), autoPay ? "true" : "false");
 }
 
-void AllocateEipAddressProRequest::setBandwidth(const std::string& bandwidth)
-{
-	bandwidth_ = bandwidth;
-	setParameter("Bandwidth", bandwidth);
+std::string AllocateEipAddressProRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string AllocateEipAddressProRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void AllocateEipAddressProRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void AllocateEipAddressProRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string AllocateEipAddressProRequest::getBandwidth() const {
+  return bandwidth_;
 }
 
-long AllocateEipAddressProRequest::getOwnerId()const
-{
-	return ownerId_;
+void AllocateEipAddressProRequest::setBandwidth(const std::string &bandwidth) {
+  bandwidth_ = bandwidth;
+  setParameter(std::string("Bandwidth"), bandwidth);
 }
 
-void AllocateEipAddressProRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+std::string AllocateEipAddressProRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-std::string AllocateEipAddressProRequest::getInstanceId()const
-{
-	return instanceId_;
+void AllocateEipAddressProRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void AllocateEipAddressProRequest::setInstanceId(const std::string& instanceId)
-{
-	instanceId_ = instanceId;
-	setParameter("InstanceId", instanceId);
+long AllocateEipAddressProRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string AllocateEipAddressProRequest::getInternetChargeType()const
-{
-	return internetChargeType_;
+void AllocateEipAddressProRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void AllocateEipAddressProRequest::setInternetChargeType(const std::string& internetChargeType)
-{
-	internetChargeType_ = internetChargeType;
-	setParameter("InternetChargeType", internetChargeType);
+std::string AllocateEipAddressProRequest::getInstanceId() const {
+  return instanceId_;
 }
 
-std::string AllocateEipAddressProRequest::getPricingCycle()const
-{
-	return pricingCycle_;
+void AllocateEipAddressProRequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setParameter(std::string("InstanceId"), instanceId);
 }
 
-void AllocateEipAddressProRequest::setPricingCycle(const std::string& pricingCycle)
-{
-	pricingCycle_ = pricingCycle;
-	setParameter("PricingCycle", pricingCycle);
+std::string AllocateEipAddressProRequest::getInternetChargeType() const {
+  return internetChargeType_;
+}
+
+void AllocateEipAddressProRequest::setInternetChargeType(const std::string &internetChargeType) {
+  internetChargeType_ = internetChargeType;
+  setParameter(std::string("InternetChargeType"), internetChargeType);
+}
+
+std::vector<std::string> AllocateEipAddressProRequest::getSecurityProtectionTypes() const {
+  return securityProtectionTypes_;
+}
+
+void AllocateEipAddressProRequest::setSecurityProtectionTypes(const std::vector<std::string> &securityProtectionTypes) {
+  securityProtectionTypes_ = securityProtectionTypes;
+}
+
+std::string AllocateEipAddressProRequest::getPricingCycle() const {
+  return pricingCycle_;
+}
+
+void AllocateEipAddressProRequest::setPricingCycle(const std::string &pricingCycle) {
+  pricingCycle_ = pricingCycle;
+  setParameter(std::string("PricingCycle"), pricingCycle);
 }
 

vpc/src/model/AllocateEipAddressProResult.cc

@@ -39,14 +39,14 @@ void AllocateEipAddressProResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["AllocationId"].isNull())
-		allocationId_ = value["AllocationId"].asString();
-	if(!value["EipAddress"].isNull())
-		eipAddress_ = value["EipAddress"].asString();
 	if(!value["OrderId"].isNull())
 		orderId_ = std::stol(value["OrderId"].asString());
 	if(!value["ResourceGroupId"].isNull())
 		resourceGroupId_ = value["ResourceGroupId"].asString();
+	if(!value["EipAddress"].isNull())
+		eipAddress_ = value["EipAddress"].asString();
+	if(!value["AllocationId"].isNull())
+		allocationId_ = value["AllocationId"].asString();
 
 }
 

vpc/src/model/AllocateEipAddressRequest.cc

@@ -1,227 +1,206 @@
 /*
  * 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/vpc/model/AllocateEipAddressRequest.h>
-
-using AlibabaCloud::Vpc::Model::AllocateEipAddressRequest;
-
-AllocateEipAddressRequest::AllocateEipAddressRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "AllocateEipAddress")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-AllocateEipAddressRequest::~AllocateEipAddressRequest()
-{}
-
-long AllocateEipAddressRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/AllocateEipAddressRequest.h>
+
+using AlibabaCloud::Vpc::Model::AllocateEipAddressRequest;
+
+AllocateEipAddressRequest::AllocateEipAddressRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "AllocateEipAddress") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void AllocateEipAddressRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+AllocateEipAddressRequest::~AllocateEipAddressRequest() {}
+
+long AllocateEipAddressRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string AllocateEipAddressRequest::getClientToken()const
-{
-	return clientToken_;
+void AllocateEipAddressRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void AllocateEipAddressRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string AllocateEipAddressRequest::getPublicIpAddressPoolId() const {
+  return publicIpAddressPoolId_;
 }
 
-std::string AllocateEipAddressRequest::getISP()const
-{
-	return iSP_;
+void AllocateEipAddressRequest::setPublicIpAddressPoolId(const std::string &publicIpAddressPoolId) {
+  publicIpAddressPoolId_ = publicIpAddressPoolId;
+  setParameter(std::string("PublicIpAddressPoolId"), publicIpAddressPoolId);
 }
 
-void AllocateEipAddressRequest::setISP(const std::string& iSP)
-{
-	iSP_ = iSP;
-	setParameter("ISP", iSP);
+std::string AllocateEipAddressRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string AllocateEipAddressRequest::getDescription()const
-{
-	return description_;
+void AllocateEipAddressRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void AllocateEipAddressRequest::setDescription(const std::string& description)
-{
-	description_ = description;
-	setParameter("Description", description);
+std::string AllocateEipAddressRequest::getISP() const {
+  return iSP_;
 }
 
-std::string AllocateEipAddressRequest::getResourceGroupId()const
-{
-	return resourceGroupId_;
+void AllocateEipAddressRequest::setISP(const std::string &iSP) {
+  iSP_ = iSP;
+  setParameter(std::string("ISP"), iSP);
 }
 
-void AllocateEipAddressRequest::setResourceGroupId(const std::string& resourceGroupId)
-{
-	resourceGroupId_ = resourceGroupId;
-	setParameter("ResourceGroupId", resourceGroupId);
+std::string AllocateEipAddressRequest::getDescription() const {
+  return description_;
 }
 
-std::string AllocateEipAddressRequest::getRegionId()const
-{
-	return regionId_;
+void AllocateEipAddressRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
 }
 
-void AllocateEipAddressRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string AllocateEipAddressRequest::getResourceGroupId() const {
+  return resourceGroupId_;
 }
 
-std::string AllocateEipAddressRequest::getNetmode()const
-{
-	return netmode_;
+void AllocateEipAddressRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
 }
 
-void AllocateEipAddressRequest::setNetmode(const std::string& netmode)
-{
-	netmode_ = netmode;
-	setParameter("Netmode", netmode);
+std::string AllocateEipAddressRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string AllocateEipAddressRequest::getInstanceChargeType()const
-{
-	return instanceChargeType_;
+void AllocateEipAddressRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void AllocateEipAddressRequest::setInstanceChargeType(const std::string& instanceChargeType)
-{
-	instanceChargeType_ = instanceChargeType;
-	setParameter("InstanceChargeType", instanceChargeType);
+std::string AllocateEipAddressRequest::getNetmode() const {
+  return netmode_;
 }
 
-int AllocateEipAddressRequest::getPeriod()const
-{
-	return period_;
+void AllocateEipAddressRequest::setNetmode(const std::string &netmode) {
+  netmode_ = netmode;
+  setParameter(std::string("Netmode"), netmode);
 }
 
-void AllocateEipAddressRequest::setPeriod(int period)
-{
-	period_ = period;
-	setParameter("Period", std::to_string(period));
+std::string AllocateEipAddressRequest::getInstanceChargeType() const {
+  return instanceChargeType_;
 }
 
-bool AllocateEipAddressRequest::getAutoPay()const
-{
-	return autoPay_;
+void AllocateEipAddressRequest::setInstanceChargeType(const std::string &instanceChargeType) {
+  instanceChargeType_ = instanceChargeType;
+  setParameter(std::string("InstanceChargeType"), instanceChargeType);
 }
 
-void AllocateEipAddressRequest::setAutoPay(bool autoPay)
-{
-	autoPay_ = autoPay;
-	setParameter("AutoPay", autoPay ? "true" : "false");
+int AllocateEipAddressRequest::getPeriod() const {
+  return period_;
 }
 
-std::string AllocateEipAddressRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void AllocateEipAddressRequest::setPeriod(int period) {
+  period_ = period;
+  setParameter(std::string("Period"), std::to_string(period));
 }
 
-void AllocateEipAddressRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+bool AllocateEipAddressRequest::getAutoPay() const {
+  return autoPay_;
 }
 
-std::string AllocateEipAddressRequest::getBandwidth()const
-{
-	return bandwidth_;
+void AllocateEipAddressRequest::setAutoPay(bool autoPay) {
+  autoPay_ = autoPay;
+  setParameter(std::string("AutoPay"), autoPay ? "true" : "false");
 }
 
-void AllocateEipAddressRequest::setBandwidth(const std::string& bandwidth)
-{
-	bandwidth_ = bandwidth;
-	setParameter("Bandwidth", bandwidth);
+std::string AllocateEipAddressRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string AllocateEipAddressRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void AllocateEipAddressRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void AllocateEipAddressRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string AllocateEipAddressRequest::getBandwidth() const {
+  return bandwidth_;
 }
 
-long AllocateEipAddressRequest::getOwnerId()const
-{
-	return ownerId_;
+void AllocateEipAddressRequest::setBandwidth(const std::string &bandwidth) {
+  bandwidth_ = bandwidth;
+  setParameter(std::string("Bandwidth"), bandwidth);
 }
 
-void AllocateEipAddressRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+std::string AllocateEipAddressRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long AllocateEipAddressRequest::getActivityId()const
-{
-	return activityId_;
+void AllocateEipAddressRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void AllocateEipAddressRequest::setActivityId(long activityId)
-{
-	activityId_ = activityId;
-	setParameter("ActivityId", std::to_string(activityId));
+long AllocateEipAddressRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string AllocateEipAddressRequest::getInternetChargeType()const
-{
-	return internetChargeType_;
+void AllocateEipAddressRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void AllocateEipAddressRequest::setInternetChargeType(const std::string& internetChargeType)
-{
-	internetChargeType_ = internetChargeType;
-	setParameter("InternetChargeType", internetChargeType);
+long AllocateEipAddressRequest::getActivityId() const {
+  return activityId_;
 }
 
-std::string AllocateEipAddressRequest::getName()const
-{
-	return name_;
+void AllocateEipAddressRequest::setActivityId(long activityId) {
+  activityId_ = activityId;
+  setParameter(std::string("ActivityId"), std::to_string(activityId));
 }
 
-void AllocateEipAddressRequest::setName(const std::string& name)
-{
-	name_ = name;
-	setParameter("Name", name);
+std::string AllocateEipAddressRequest::getInternetChargeType() const {
+  return internetChargeType_;
 }
 
-std::string AllocateEipAddressRequest::getPricingCycle()const
-{
-	return pricingCycle_;
+void AllocateEipAddressRequest::setInternetChargeType(const std::string &internetChargeType) {
+  internetChargeType_ = internetChargeType;
+  setParameter(std::string("InternetChargeType"), internetChargeType);
 }
 
-void AllocateEipAddressRequest::setPricingCycle(const std::string& pricingCycle)
-{
-	pricingCycle_ = pricingCycle;
-	setParameter("PricingCycle", pricingCycle);
+std::string AllocateEipAddressRequest::getName() const {
+  return name_;
+}
+
+void AllocateEipAddressRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
+}
+
+std::vector<std::string> AllocateEipAddressRequest::getSecurityProtectionTypes() const {
+  return securityProtectionTypes_;
+}
+
+void AllocateEipAddressRequest::setSecurityProtectionTypes(const std::vector<std::string> &securityProtectionTypes) {
+  securityProtectionTypes_ = securityProtectionTypes;
+}
+
+std::string AllocateEipAddressRequest::getPricingCycle() const {
+  return pricingCycle_;
+}
+
+void AllocateEipAddressRequest::setPricingCycle(const std::string &pricingCycle) {
+  pricingCycle_ = pricingCycle;
+  setParameter(std::string("PricingCycle"), pricingCycle);
 }
 

vpc/src/model/AllocateEipAddressResult.cc

@@ -39,14 +39,14 @@ void AllocateEipAddressResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["AllocationId"].isNull())
-		allocationId_ = value["AllocationId"].asString();
-	if(!value["EipAddress"].isNull())
-		eipAddress_ = value["EipAddress"].asString();
 	if(!value["OrderId"].isNull())
 		orderId_ = std::stol(value["OrderId"].asString());
 	if(!value["ResourceGroupId"].isNull())
 		resourceGroupId_ = value["ResourceGroupId"].asString();
+	if(!value["EipAddress"].isNull())
+		eipAddress_ = value["EipAddress"].asString();
+	if(!value["AllocationId"].isNull())
+		allocationId_ = value["AllocationId"].asString();
 
 }
 

vpc/src/model/AllocateEipSegmentAddressRequest.cc

@@ -1,161 +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/vpc/model/AllocateEipSegmentAddressRequest.h>
-
-using AlibabaCloud::Vpc::Model::AllocateEipSegmentAddressRequest;
-
-AllocateEipSegmentAddressRequest::AllocateEipSegmentAddressRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "AllocateEipSegmentAddress")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-AllocateEipSegmentAddressRequest::~AllocateEipSegmentAddressRequest()
-{}
-
-long AllocateEipSegmentAddressRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/AllocateEipSegmentAddressRequest.h>
+
+using AlibabaCloud::Vpc::Model::AllocateEipSegmentAddressRequest;
+
+AllocateEipSegmentAddressRequest::AllocateEipSegmentAddressRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "AllocateEipSegmentAddress") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void AllocateEipSegmentAddressRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+AllocateEipSegmentAddressRequest::~AllocateEipSegmentAddressRequest() {}
+
+long AllocateEipSegmentAddressRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string AllocateEipSegmentAddressRequest::getClientToken()const
-{
-	return clientToken_;
+void AllocateEipSegmentAddressRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void AllocateEipSegmentAddressRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string AllocateEipSegmentAddressRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string AllocateEipSegmentAddressRequest::getIsp()const
-{
-	return isp_;
+void AllocateEipSegmentAddressRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void AllocateEipSegmentAddressRequest::setIsp(const std::string& isp)
-{
-	isp_ = isp;
-	setParameter("Isp", isp);
+std::string AllocateEipSegmentAddressRequest::getIsp() const {
+  return isp_;
 }
 
-std::string AllocateEipSegmentAddressRequest::getResourceGroupId()const
-{
-	return resourceGroupId_;
+void AllocateEipSegmentAddressRequest::setIsp(const std::string &isp) {
+  isp_ = isp;
+  setParameter(std::string("Isp"), isp);
 }
 
-void AllocateEipSegmentAddressRequest::setResourceGroupId(const std::string& resourceGroupId)
-{
-	resourceGroupId_ = resourceGroupId;
-	setParameter("ResourceGroupId", resourceGroupId);
+std::string AllocateEipSegmentAddressRequest::getResourceGroupId() const {
+  return resourceGroupId_;
 }
 
-std::string AllocateEipSegmentAddressRequest::getRegionId()const
-{
-	return regionId_;
+void AllocateEipSegmentAddressRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
 }
 
-void AllocateEipSegmentAddressRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string AllocateEipSegmentAddressRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string AllocateEipSegmentAddressRequest::getNetmode()const
-{
-	return netmode_;
+void AllocateEipSegmentAddressRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void AllocateEipSegmentAddressRequest::setNetmode(const std::string& netmode)
-{
-	netmode_ = netmode;
-	setParameter("Netmode", netmode);
+std::string AllocateEipSegmentAddressRequest::getNetmode() const {
+  return netmode_;
 }
 
-std::string AllocateEipSegmentAddressRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void AllocateEipSegmentAddressRequest::setNetmode(const std::string &netmode) {
+  netmode_ = netmode;
+  setParameter(std::string("Netmode"), netmode);
 }
 
-void AllocateEipSegmentAddressRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string AllocateEipSegmentAddressRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string AllocateEipSegmentAddressRequest::getBandwidth()const
-{
-	return bandwidth_;
+void AllocateEipSegmentAddressRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void AllocateEipSegmentAddressRequest::setBandwidth(const std::string& bandwidth)
-{
-	bandwidth_ = bandwidth;
-	setParameter("Bandwidth", bandwidth);
+std::string AllocateEipSegmentAddressRequest::getBandwidth() const {
+  return bandwidth_;
 }
 
-std::string AllocateEipSegmentAddressRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void AllocateEipSegmentAddressRequest::setBandwidth(const std::string &bandwidth) {
+  bandwidth_ = bandwidth;
+  setParameter(std::string("Bandwidth"), bandwidth);
 }
 
-void AllocateEipSegmentAddressRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string AllocateEipSegmentAddressRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-std::string AllocateEipSegmentAddressRequest::getEipMask()const
-{
-	return eipMask_;
+void AllocateEipSegmentAddressRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void AllocateEipSegmentAddressRequest::setEipMask(const std::string& eipMask)
-{
-	eipMask_ = eipMask;
-	setParameter("EipMask", eipMask);
+std::string AllocateEipSegmentAddressRequest::getEipMask() const {
+  return eipMask_;
 }
 
-long AllocateEipSegmentAddressRequest::getOwnerId()const
-{
-	return ownerId_;
+void AllocateEipSegmentAddressRequest::setEipMask(const std::string &eipMask) {
+  eipMask_ = eipMask;
+  setParameter(std::string("EipMask"), eipMask);
 }
 
-void AllocateEipSegmentAddressRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long AllocateEipSegmentAddressRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string AllocateEipSegmentAddressRequest::getInternetChargeType()const
-{
-	return internetChargeType_;
+void AllocateEipSegmentAddressRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void AllocateEipSegmentAddressRequest::setInternetChargeType(const std::string& internetChargeType)
-{
-	internetChargeType_ = internetChargeType;
-	setParameter("InternetChargeType", internetChargeType);
+std::string AllocateEipSegmentAddressRequest::getInternetChargeType() const {
+  return internetChargeType_;
+}
+
+void AllocateEipSegmentAddressRequest::setInternetChargeType(const std::string &internetChargeType) {
+  internetChargeType_ = internetChargeType;
+  setParameter(std::string("InternetChargeType"), internetChargeType);
 }
 

vpc/src/model/AllocateEipSegmentAddressResult.cc

@@ -39,10 +39,10 @@ void AllocateEipSegmentAddressResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["EipSegmentInstanceId"].isNull())
-		eipSegmentInstanceId_ = value["EipSegmentInstanceId"].asString();
 	if(!value["OrderId"].isNull())
 		orderId_ = std::stol(value["OrderId"].asString());
+	if(!value["EipSegmentInstanceId"].isNull())
+		eipSegmentInstanceId_ = value["EipSegmentInstanceId"].asString();
 
 }
 

vpc/src/model/AllocateIpv6InternetBandwidthRequest.cc

@@ -1,139 +1,117 @@
 /*
  * 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/vpc/model/AllocateIpv6InternetBandwidthRequest.h>
-
-using AlibabaCloud::Vpc::Model::AllocateIpv6InternetBandwidthRequest;
-
-AllocateIpv6InternetBandwidthRequest::AllocateIpv6InternetBandwidthRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "AllocateIpv6InternetBandwidth")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-AllocateIpv6InternetBandwidthRequest::~AllocateIpv6InternetBandwidthRequest()
-{}
-
-long AllocateIpv6InternetBandwidthRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/AllocateIpv6InternetBandwidthRequest.h>
+
+using AlibabaCloud::Vpc::Model::AllocateIpv6InternetBandwidthRequest;
+
+AllocateIpv6InternetBandwidthRequest::AllocateIpv6InternetBandwidthRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "AllocateIpv6InternetBandwidth") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void AllocateIpv6InternetBandwidthRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+AllocateIpv6InternetBandwidthRequest::~AllocateIpv6InternetBandwidthRequest() {}
+
+long AllocateIpv6InternetBandwidthRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string AllocateIpv6InternetBandwidthRequest::getClientToken()const
-{
-	return clientToken_;
+void AllocateIpv6InternetBandwidthRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void AllocateIpv6InternetBandwidthRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string AllocateIpv6InternetBandwidthRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string AllocateIpv6InternetBandwidthRequest::getRegionId()const
-{
-	return regionId_;
+void AllocateIpv6InternetBandwidthRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void AllocateIpv6InternetBandwidthRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string AllocateIpv6InternetBandwidthRequest::getRegionId() const {
+  return regionId_;
 }
 
-int AllocateIpv6InternetBandwidthRequest::getBandwidth()const
-{
-	return bandwidth_;
+void AllocateIpv6InternetBandwidthRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void AllocateIpv6InternetBandwidthRequest::setBandwidth(int bandwidth)
-{
-	bandwidth_ = bandwidth;
-	setParameter("Bandwidth", std::to_string(bandwidth));
+int AllocateIpv6InternetBandwidthRequest::getBandwidth() const {
+  return bandwidth_;
 }
 
-std::string AllocateIpv6InternetBandwidthRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void AllocateIpv6InternetBandwidthRequest::setBandwidth(int bandwidth) {
+  bandwidth_ = bandwidth;
+  setParameter(std::string("Bandwidth"), std::to_string(bandwidth));
 }
 
-void AllocateIpv6InternetBandwidthRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string AllocateIpv6InternetBandwidthRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string AllocateIpv6InternetBandwidthRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void AllocateIpv6InternetBandwidthRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void AllocateIpv6InternetBandwidthRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string AllocateIpv6InternetBandwidthRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long AllocateIpv6InternetBandwidthRequest::getOwnerId()const
-{
-	return ownerId_;
+void AllocateIpv6InternetBandwidthRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void AllocateIpv6InternetBandwidthRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long AllocateIpv6InternetBandwidthRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string AllocateIpv6InternetBandwidthRequest::getIpv6AddressId()const
-{
-	return ipv6AddressId_;
+void AllocateIpv6InternetBandwidthRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void AllocateIpv6InternetBandwidthRequest::setIpv6AddressId(const std::string& ipv6AddressId)
-{
-	ipv6AddressId_ = ipv6AddressId;
-	setParameter("Ipv6AddressId", ipv6AddressId);
+std::string AllocateIpv6InternetBandwidthRequest::getIpv6AddressId() const {
+  return ipv6AddressId_;
 }
 
-std::string AllocateIpv6InternetBandwidthRequest::getInternetChargeType()const
-{
-	return internetChargeType_;
+void AllocateIpv6InternetBandwidthRequest::setIpv6AddressId(const std::string &ipv6AddressId) {
+  ipv6AddressId_ = ipv6AddressId;
+  setParameter(std::string("Ipv6AddressId"), ipv6AddressId);
 }
 
-void AllocateIpv6InternetBandwidthRequest::setInternetChargeType(const std::string& internetChargeType)
-{
-	internetChargeType_ = internetChargeType;
-	setParameter("InternetChargeType", internetChargeType);
+std::string AllocateIpv6InternetBandwidthRequest::getInternetChargeType() const {
+  return internetChargeType_;
 }
 
-std::string AllocateIpv6InternetBandwidthRequest::getIpv6GatewayId()const
-{
-	return ipv6GatewayId_;
+void AllocateIpv6InternetBandwidthRequest::setInternetChargeType(const std::string &internetChargeType) {
+  internetChargeType_ = internetChargeType;
+  setParameter(std::string("InternetChargeType"), internetChargeType);
 }
 
-void AllocateIpv6InternetBandwidthRequest::setIpv6GatewayId(const std::string& ipv6GatewayId)
-{
-	ipv6GatewayId_ = ipv6GatewayId;
-	setParameter("Ipv6GatewayId", ipv6GatewayId);
+std::string AllocateIpv6InternetBandwidthRequest::getIpv6GatewayId() const {
+  return ipv6GatewayId_;
+}
+
+void AllocateIpv6InternetBandwidthRequest::setIpv6GatewayId(const std::string &ipv6GatewayId) {
+  ipv6GatewayId_ = ipv6GatewayId;
+  setParameter(std::string("Ipv6GatewayId"), ipv6GatewayId);
 }
 

vpc/src/model/AllocateVpcIpv6CidrRequest.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/vpc/model/AllocateVpcIpv6CidrRequest.h>
+
+using AlibabaCloud::Vpc::Model::AllocateVpcIpv6CidrRequest;
+
+AllocateVpcIpv6CidrRequest::AllocateVpcIpv6CidrRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "AllocateVpcIpv6Cidr") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+AllocateVpcIpv6CidrRequest::~AllocateVpcIpv6CidrRequest() {}
+
+long AllocateVpcIpv6CidrRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void AllocateVpcIpv6CidrRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string AllocateVpcIpv6CidrRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void AllocateVpcIpv6CidrRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string AllocateVpcIpv6CidrRequest::getRegionId() const {
+  return regionId_;
+}
+
+void AllocateVpcIpv6CidrRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string AllocateVpcIpv6CidrRequest::getIpv6Isp() const {
+  return ipv6Isp_;
+}
+
+void AllocateVpcIpv6CidrRequest::setIpv6Isp(const std::string &ipv6Isp) {
+  ipv6Isp_ = ipv6Isp;
+  setParameter(std::string("Ipv6Isp"), ipv6Isp);
+}
+
+std::string AllocateVpcIpv6CidrRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void AllocateVpcIpv6CidrRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string AllocateVpcIpv6CidrRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void AllocateVpcIpv6CidrRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long AllocateVpcIpv6CidrRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void AllocateVpcIpv6CidrRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string AllocateVpcIpv6CidrRequest::getIpv6CidrBlock() const {
+  return ipv6CidrBlock_;
+}
+
+void AllocateVpcIpv6CidrRequest::setIpv6CidrBlock(const std::string &ipv6CidrBlock) {
+  ipv6CidrBlock_ = ipv6CidrBlock;
+  setParameter(std::string("Ipv6CidrBlock"), ipv6CidrBlock);
+}
+
+std::string AllocateVpcIpv6CidrRequest::getAddressPoolType() const {
+  return addressPoolType_;
+}
+
+void AllocateVpcIpv6CidrRequest::setAddressPoolType(const std::string &addressPoolType) {
+  addressPoolType_ = addressPoolType;
+  setParameter(std::string("AddressPoolType"), addressPoolType);
+}
+

vpc/src/model/AllocateVpcIpv6CidrResult.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/vpc/model/AllocateVpcIpv6CidrResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vpc;
+using namespace AlibabaCloud::Vpc::Model;
+
+AllocateVpcIpv6CidrResult::AllocateVpcIpv6CidrResult() :
+	ServiceResult()
+{}
+
+AllocateVpcIpv6CidrResult::AllocateVpcIpv6CidrResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+AllocateVpcIpv6CidrResult::~AllocateVpcIpv6CidrResult()
+{}
+
+void AllocateVpcIpv6CidrResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Ipv6CidrBlock"].isNull())
+		ipv6CidrBlock_ = value["Ipv6CidrBlock"].asString();
+
+}
+
+std::string AllocateVpcIpv6CidrResult::getIpv6CidrBlock()const
+{
+	return ipv6CidrBlock_;
+}
+

vpc/src/model/ApplyPhysicalConnectionLOARequest.cc

@@ -1,191 +1,161 @@
 /*
  * 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/vpc/model/ApplyPhysicalConnectionLOARequest.h>
-
-using AlibabaCloud::Vpc::Model::ApplyPhysicalConnectionLOARequest;
-
-ApplyPhysicalConnectionLOARequest::ApplyPhysicalConnectionLOARequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "ApplyPhysicalConnectionLOA")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-ApplyPhysicalConnectionLOARequest::~ApplyPhysicalConnectionLOARequest()
-{}
-
-long ApplyPhysicalConnectionLOARequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/ApplyPhysicalConnectionLOARequest.h>
+
+using AlibabaCloud::Vpc::Model::ApplyPhysicalConnectionLOARequest;
+
+ApplyPhysicalConnectionLOARequest::ApplyPhysicalConnectionLOARequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "ApplyPhysicalConnectionLOA") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void ApplyPhysicalConnectionLOARequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+ApplyPhysicalConnectionLOARequest::~ApplyPhysicalConnectionLOARequest() {}
+
+long ApplyPhysicalConnectionLOARequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string ApplyPhysicalConnectionLOARequest::getClientToken()const
-{
-	return clientToken_;
+void ApplyPhysicalConnectionLOARequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void ApplyPhysicalConnectionLOARequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string ApplyPhysicalConnectionLOARequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string ApplyPhysicalConnectionLOARequest::getLineType()const
-{
-	return lineType_;
+void ApplyPhysicalConnectionLOARequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void ApplyPhysicalConnectionLOARequest::setLineType(const std::string& lineType)
-{
-	lineType_ = lineType;
-	setParameter("LineType", lineType);
+std::string ApplyPhysicalConnectionLOARequest::getLineType() const {
+  return lineType_;
 }
 
-std::string ApplyPhysicalConnectionLOARequest::getRegionId()const
-{
-	return regionId_;
+void ApplyPhysicalConnectionLOARequest::setLineType(const std::string &lineType) {
+  lineType_ = lineType;
+  setParameter(std::string("LineType"), lineType);
 }
 
-void ApplyPhysicalConnectionLOARequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string ApplyPhysicalConnectionLOARequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string ApplyPhysicalConnectionLOARequest::getSi()const
-{
-	return si_;
+void ApplyPhysicalConnectionLOARequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void ApplyPhysicalConnectionLOARequest::setSi(const std::string& si)
-{
-	si_ = si;
-	setParameter("Si", si);
+std::string ApplyPhysicalConnectionLOARequest::getSi() const {
+  return si_;
 }
 
-std::string ApplyPhysicalConnectionLOARequest::getPeerLocation()const
-{
-	return peerLocation_;
+void ApplyPhysicalConnectionLOARequest::setSi(const std::string &si) {
+  si_ = si;
+  setParameter(std::string("Si"), si);
 }
 
-void ApplyPhysicalConnectionLOARequest::setPeerLocation(const std::string& peerLocation)
-{
-	peerLocation_ = peerLocation;
-	setParameter("PeerLocation", peerLocation);
+std::string ApplyPhysicalConnectionLOARequest::getPeerLocation() const {
+  return peerLocation_;
 }
 
-std::string ApplyPhysicalConnectionLOARequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void ApplyPhysicalConnectionLOARequest::setPeerLocation(const std::string &peerLocation) {
+  peerLocation_ = peerLocation;
+  setParameter(std::string("PeerLocation"), peerLocation);
 }
 
-void ApplyPhysicalConnectionLOARequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string ApplyPhysicalConnectionLOARequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-int ApplyPhysicalConnectionLOARequest::getBandwidth()const
-{
-	return bandwidth_;
+void ApplyPhysicalConnectionLOARequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void ApplyPhysicalConnectionLOARequest::setBandwidth(int bandwidth)
-{
-	bandwidth_ = bandwidth;
-	setParameter("Bandwidth", std::to_string(bandwidth));
+int ApplyPhysicalConnectionLOARequest::getBandwidth() const {
+  return bandwidth_;
 }
 
-std::string ApplyPhysicalConnectionLOARequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void ApplyPhysicalConnectionLOARequest::setBandwidth(int bandwidth) {
+  bandwidth_ = bandwidth;
+  setParameter(std::string("Bandwidth"), std::to_string(bandwidth));
 }
 
-void ApplyPhysicalConnectionLOARequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string ApplyPhysicalConnectionLOARequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-std::string ApplyPhysicalConnectionLOARequest::getConstructionTime()const
-{
-	return constructionTime_;
+void ApplyPhysicalConnectionLOARequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void ApplyPhysicalConnectionLOARequest::setConstructionTime(const std::string& constructionTime)
-{
-	constructionTime_ = constructionTime;
-	setParameter("ConstructionTime", constructionTime);
+std::string ApplyPhysicalConnectionLOARequest::getConstructionTime() const {
+  return constructionTime_;
 }
 
-long ApplyPhysicalConnectionLOARequest::getOwnerId()const
-{
-	return ownerId_;
+void ApplyPhysicalConnectionLOARequest::setConstructionTime(const std::string &constructionTime) {
+  constructionTime_ = constructionTime;
+  setParameter(std::string("ConstructionTime"), constructionTime);
 }
 
-void ApplyPhysicalConnectionLOARequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long ApplyPhysicalConnectionLOARequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string ApplyPhysicalConnectionLOARequest::getInstanceId()const
-{
-	return instanceId_;
+void ApplyPhysicalConnectionLOARequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void ApplyPhysicalConnectionLOARequest::setInstanceId(const std::string& instanceId)
-{
-	instanceId_ = instanceId;
-	setParameter("InstanceId", instanceId);
+std::string ApplyPhysicalConnectionLOARequest::getInstanceId() const {
+  return instanceId_;
 }
 
-std::string ApplyPhysicalConnectionLOARequest::getCompanyName()const
-{
-	return companyName_;
+void ApplyPhysicalConnectionLOARequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setParameter(std::string("InstanceId"), instanceId);
 }
 
-void ApplyPhysicalConnectionLOARequest::setCompanyName(const std::string& companyName)
-{
-	companyName_ = companyName;
-	setParameter("CompanyName", companyName);
+std::string ApplyPhysicalConnectionLOARequest::getCompanyName() const {
+  return companyName_;
 }
 
-std::vector<ApplyPhysicalConnectionLOARequest::PMInfo> ApplyPhysicalConnectionLOARequest::getPMInfo()const
-{
-	return pMInfo_;
+void ApplyPhysicalConnectionLOARequest::setCompanyName(const std::string &companyName) {
+  companyName_ = companyName;
+  setParameter(std::string("CompanyName"), companyName);
 }
 
-void ApplyPhysicalConnectionLOARequest::setPMInfo(const std::vector<PMInfo>& pMInfo)
-{
-	pMInfo_ = pMInfo;
-	for(int dep1 = 0; dep1!= pMInfo.size(); dep1++) {
-		auto pMInfoObj = pMInfo.at(dep1);
-		std::string pMInfoObjStr = "PMInfo." + std::to_string(dep1 + 1);
-		setParameter(pMInfoObjStr + ".PMCertificateNo", pMInfoObj.pMCertificateNo);
-		setParameter(pMInfoObjStr + ".PMName", pMInfoObj.pMName);
-		setParameter(pMInfoObjStr + ".PMCertificateType", pMInfoObj.pMCertificateType);
-		setParameter(pMInfoObjStr + ".PMContactInfo", pMInfoObj.pMContactInfo);
-		setParameter(pMInfoObjStr + ".PMGender", pMInfoObj.pMGender);
-	}
+std::vector<ApplyPhysicalConnectionLOARequest::PMInfo> ApplyPhysicalConnectionLOARequest::getPMInfo() const {
+  return pMInfo_;
+}
+
+void ApplyPhysicalConnectionLOARequest::setPMInfo(const std::vector<ApplyPhysicalConnectionLOARequest::PMInfo> &pMInfo) {
+  pMInfo_ = pMInfo;
+  for(int dep1 = 0; dep1 != pMInfo.size(); dep1++) {
+  auto pMInfoObj = pMInfo.at(dep1);
+  std::string pMInfoObjStr = std::string("PMInfo") + "." + std::to_string(dep1 + 1);
+    setParameter(pMInfoObjStr + ".PMCertificateNo", pMInfoObj.pMCertificateNo);
+    setParameter(pMInfoObjStr + ".PMName", pMInfoObj.pMName);
+    setParameter(pMInfoObjStr + ".PMCertificateType", pMInfoObj.pMCertificateType);
+    setParameter(pMInfoObjStr + ".PMGender", pMInfoObj.pMGender);
+    setParameter(pMInfoObjStr + ".PMContactInfo", pMInfoObj.pMContactInfo);
+  }
 }
 

vpc/src/model/AssociateEipAddressBatchRequest.cc

@@ -0,0 +1,107 @@
+/*
+ * 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/vpc/model/AssociateEipAddressBatchRequest.h>
+
+using AlibabaCloud::Vpc::Model::AssociateEipAddressBatchRequest;
+
+AssociateEipAddressBatchRequest::AssociateEipAddressBatchRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "AssociateEipAddressBatch") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+AssociateEipAddressBatchRequest::~AssociateEipAddressBatchRequest() {}
+
+long AssociateEipAddressBatchRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void AssociateEipAddressBatchRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string AssociateEipAddressBatchRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void AssociateEipAddressBatchRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string AssociateEipAddressBatchRequest::getBindedInstanceType() const {
+  return bindedInstanceType_;
+}
+
+void AssociateEipAddressBatchRequest::setBindedInstanceType(const std::string &bindedInstanceType) {
+  bindedInstanceType_ = bindedInstanceType;
+  setParameter(std::string("BindedInstanceType"), bindedInstanceType);
+}
+
+std::string AssociateEipAddressBatchRequest::getBindedInstanceId() const {
+  return bindedInstanceId_;
+}
+
+void AssociateEipAddressBatchRequest::setBindedInstanceId(const std::string &bindedInstanceId) {
+  bindedInstanceId_ = bindedInstanceId;
+  setParameter(std::string("BindedInstanceId"), bindedInstanceId);
+}
+
+std::string AssociateEipAddressBatchRequest::getMode() const {
+  return mode_;
+}
+
+void AssociateEipAddressBatchRequest::setMode(const std::string &mode) {
+  mode_ = mode;
+  setParameter(std::string("Mode"), mode);
+}
+
+std::string AssociateEipAddressBatchRequest::getRegionId() const {
+  return regionId_;
+}
+
+void AssociateEipAddressBatchRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string AssociateEipAddressBatchRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void AssociateEipAddressBatchRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+long AssociateEipAddressBatchRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void AssociateEipAddressBatchRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::vector<std::string> AssociateEipAddressBatchRequest::getInstanceIds() const {
+  return instanceIds_;
+}
+
+void AssociateEipAddressBatchRequest::setInstanceIds(const std::vector<std::string> &instanceIds) {
+  instanceIds_ = instanceIds;
+}
+

vpc/src/model/AssociateEipAddressBatchResult.cc

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

vpc/src/model/AssociateEipAddressRequest.cc

@@ -1,161 +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/vpc/model/AssociateEipAddressRequest.h>
-
-using AlibabaCloud::Vpc::Model::AssociateEipAddressRequest;
-
-AssociateEipAddressRequest::AssociateEipAddressRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "AssociateEipAddress")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-AssociateEipAddressRequest::~AssociateEipAddressRequest()
-{}
-
-long AssociateEipAddressRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/AssociateEipAddressRequest.h>
+
+using AlibabaCloud::Vpc::Model::AssociateEipAddressRequest;
+
+AssociateEipAddressRequest::AssociateEipAddressRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "AssociateEipAddress") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void AssociateEipAddressRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+AssociateEipAddressRequest::~AssociateEipAddressRequest() {}
+
+long AssociateEipAddressRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string AssociateEipAddressRequest::getClientToken()const
-{
-	return clientToken_;
+void AssociateEipAddressRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void AssociateEipAddressRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string AssociateEipAddressRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string AssociateEipAddressRequest::getAllocationId()const
-{
-	return allocationId_;
+void AssociateEipAddressRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void AssociateEipAddressRequest::setAllocationId(const std::string& allocationId)
-{
-	allocationId_ = allocationId;
-	setParameter("AllocationId", allocationId);
+std::string AssociateEipAddressRequest::getAllocationId() const {
+  return allocationId_;
 }
 
-std::string AssociateEipAddressRequest::getMode()const
-{
-	return mode_;
+void AssociateEipAddressRequest::setAllocationId(const std::string &allocationId) {
+  allocationId_ = allocationId;
+  setParameter(std::string("AllocationId"), allocationId);
 }
 
-void AssociateEipAddressRequest::setMode(const std::string& mode)
-{
-	mode_ = mode;
-	setParameter("Mode", mode);
+std::string AssociateEipAddressRequest::getMode() const {
+  return mode_;
 }
 
-std::string AssociateEipAddressRequest::getRegionId()const
-{
-	return regionId_;
+void AssociateEipAddressRequest::setMode(const std::string &mode) {
+  mode_ = mode;
+  setParameter(std::string("Mode"), mode);
 }
 
-void AssociateEipAddressRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string AssociateEipAddressRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string AssociateEipAddressRequest::getInstanceRegionId()const
-{
-	return instanceRegionId_;
+void AssociateEipAddressRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void AssociateEipAddressRequest::setInstanceRegionId(const std::string& instanceRegionId)
-{
-	instanceRegionId_ = instanceRegionId;
-	setParameter("InstanceRegionId", instanceRegionId);
+std::string AssociateEipAddressRequest::getInstanceRegionId() const {
+  return instanceRegionId_;
 }
 
-std::string AssociateEipAddressRequest::getInstanceType()const
-{
-	return instanceType_;
+void AssociateEipAddressRequest::setInstanceRegionId(const std::string &instanceRegionId) {
+  instanceRegionId_ = instanceRegionId;
+  setParameter(std::string("InstanceRegionId"), instanceRegionId);
 }
 
-void AssociateEipAddressRequest::setInstanceType(const std::string& instanceType)
-{
-	instanceType_ = instanceType;
-	setParameter("InstanceType", instanceType);
+std::string AssociateEipAddressRequest::getInstanceType() const {
+  return instanceType_;
 }
 
-std::string AssociateEipAddressRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void AssociateEipAddressRequest::setInstanceType(const std::string &instanceType) {
+  instanceType_ = instanceType;
+  setParameter(std::string("InstanceType"), instanceType);
 }
 
-void AssociateEipAddressRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+bool AssociateEipAddressRequest::getDryRun() const {
+  return dryRun_;
 }
 
-std::string AssociateEipAddressRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void AssociateEipAddressRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setParameter(std::string("DryRun"), dryRun ? "true" : "false");
 }
 
-void AssociateEipAddressRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string AssociateEipAddressRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-long AssociateEipAddressRequest::getOwnerId()const
-{
-	return ownerId_;
+void AssociateEipAddressRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void AssociateEipAddressRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+std::string AssociateEipAddressRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-std::string AssociateEipAddressRequest::getPrivateIpAddress()const
-{
-	return privateIpAddress_;
+void AssociateEipAddressRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void AssociateEipAddressRequest::setPrivateIpAddress(const std::string& privateIpAddress)
-{
-	privateIpAddress_ = privateIpAddress;
-	setParameter("PrivateIpAddress", privateIpAddress);
+long AssociateEipAddressRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string AssociateEipAddressRequest::getInstanceId()const
-{
-	return instanceId_;
+void AssociateEipAddressRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void AssociateEipAddressRequest::setInstanceId(const std::string& instanceId)
-{
-	instanceId_ = instanceId;
-	setParameter("InstanceId", instanceId);
+std::string AssociateEipAddressRequest::getPrivateIpAddress() const {
+  return privateIpAddress_;
+}
+
+void AssociateEipAddressRequest::setPrivateIpAddress(const std::string &privateIpAddress) {
+  privateIpAddress_ = privateIpAddress;
+  setParameter(std::string("PrivateIpAddress"), privateIpAddress);
+}
+
+std::string AssociateEipAddressRequest::getInstanceId() const {
+  return instanceId_;
+}
+
+void AssociateEipAddressRequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setParameter(std::string("InstanceId"), instanceId);
+}
+
+std::string AssociateEipAddressRequest::getVpcId() const {
+  return vpcId_;
+}
+
+void AssociateEipAddressRequest::setVpcId(const std::string &vpcId) {
+  vpcId_ = vpcId;
+  setParameter(std::string("VpcId"), vpcId);
 }
 

vpc/src/model/AssociateGlobalAccelerationInstanceRequest.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/vpc/model/AssociateGlobalAccelerationInstanceRequest.h>
-
-using AlibabaCloud::Vpc::Model::AssociateGlobalAccelerationInstanceRequest;
-
-AssociateGlobalAccelerationInstanceRequest::AssociateGlobalAccelerationInstanceRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "AssociateGlobalAccelerationInstance")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-AssociateGlobalAccelerationInstanceRequest::~AssociateGlobalAccelerationInstanceRequest()
-{}
-
-long AssociateGlobalAccelerationInstanceRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/AssociateGlobalAccelerationInstanceRequest.h>
+
+using AlibabaCloud::Vpc::Model::AssociateGlobalAccelerationInstanceRequest;
+
+AssociateGlobalAccelerationInstanceRequest::AssociateGlobalAccelerationInstanceRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "AssociateGlobalAccelerationInstance") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void AssociateGlobalAccelerationInstanceRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+AssociateGlobalAccelerationInstanceRequest::~AssociateGlobalAccelerationInstanceRequest() {}
+
+long AssociateGlobalAccelerationInstanceRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string AssociateGlobalAccelerationInstanceRequest::getGlobalAccelerationInstanceId()const
-{
-	return globalAccelerationInstanceId_;
+void AssociateGlobalAccelerationInstanceRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void AssociateGlobalAccelerationInstanceRequest::setGlobalAccelerationInstanceId(const std::string& globalAccelerationInstanceId)
-{
-	globalAccelerationInstanceId_ = globalAccelerationInstanceId;
-	setParameter("GlobalAccelerationInstanceId", globalAccelerationInstanceId);
+std::string AssociateGlobalAccelerationInstanceRequest::getGlobalAccelerationInstanceId() const {
+  return globalAccelerationInstanceId_;
 }
 
-std::string AssociateGlobalAccelerationInstanceRequest::getRegionId()const
-{
-	return regionId_;
+void AssociateGlobalAccelerationInstanceRequest::setGlobalAccelerationInstanceId(const std::string &globalAccelerationInstanceId) {
+  globalAccelerationInstanceId_ = globalAccelerationInstanceId;
+  setParameter(std::string("GlobalAccelerationInstanceId"), globalAccelerationInstanceId);
 }
 
-void AssociateGlobalAccelerationInstanceRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string AssociateGlobalAccelerationInstanceRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string AssociateGlobalAccelerationInstanceRequest::getBackendServerId()const
-{
-	return backendServerId_;
+void AssociateGlobalAccelerationInstanceRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void AssociateGlobalAccelerationInstanceRequest::setBackendServerId(const std::string& backendServerId)
-{
-	backendServerId_ = backendServerId;
-	setParameter("BackendServerId", backendServerId);
+std::string AssociateGlobalAccelerationInstanceRequest::getBackendServerId() const {
+  return backendServerId_;
 }
 
-std::string AssociateGlobalAccelerationInstanceRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void AssociateGlobalAccelerationInstanceRequest::setBackendServerId(const std::string &backendServerId) {
+  backendServerId_ = backendServerId;
+  setParameter(std::string("BackendServerId"), backendServerId);
 }
 
-void AssociateGlobalAccelerationInstanceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string AssociateGlobalAccelerationInstanceRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string AssociateGlobalAccelerationInstanceRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void AssociateGlobalAccelerationInstanceRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void AssociateGlobalAccelerationInstanceRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string AssociateGlobalAccelerationInstanceRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long AssociateGlobalAccelerationInstanceRequest::getOwnerId()const
-{
-	return ownerId_;
+void AssociateGlobalAccelerationInstanceRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void AssociateGlobalAccelerationInstanceRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long AssociateGlobalAccelerationInstanceRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string AssociateGlobalAccelerationInstanceRequest::getBackendServerRegionId()const
-{
-	return backendServerRegionId_;
+void AssociateGlobalAccelerationInstanceRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void AssociateGlobalAccelerationInstanceRequest::setBackendServerRegionId(const std::string& backendServerRegionId)
-{
-	backendServerRegionId_ = backendServerRegionId;
-	setParameter("BackendServerRegionId", backendServerRegionId);
+std::string AssociateGlobalAccelerationInstanceRequest::getBackendServerRegionId() const {
+  return backendServerRegionId_;
 }
 
-std::string AssociateGlobalAccelerationInstanceRequest::getBackendServerType()const
-{
-	return backendServerType_;
+void AssociateGlobalAccelerationInstanceRequest::setBackendServerRegionId(const std::string &backendServerRegionId) {
+  backendServerRegionId_ = backendServerRegionId;
+  setParameter(std::string("BackendServerRegionId"), backendServerRegionId);
 }
 
-void AssociateGlobalAccelerationInstanceRequest::setBackendServerType(const std::string& backendServerType)
-{
-	backendServerType_ = backendServerType;
-	setParameter("BackendServerType", backendServerType);
+std::string AssociateGlobalAccelerationInstanceRequest::getBackendServerType() const {
+  return backendServerType_;
+}
+
+void AssociateGlobalAccelerationInstanceRequest::setBackendServerType(const std::string &backendServerType) {
+  backendServerType_ = backendServerType;
+  setParameter(std::string("BackendServerType"), backendServerType);
 }
 

vpc/src/model/AssociateHaVipRequest.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/vpc/model/AssociateHaVipRequest.h>
-
-using AlibabaCloud::Vpc::Model::AssociateHaVipRequest;
-
-AssociateHaVipRequest::AssociateHaVipRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "AssociateHaVip")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-AssociateHaVipRequest::~AssociateHaVipRequest()
-{}
-
-long AssociateHaVipRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/AssociateHaVipRequest.h>
+
+using AlibabaCloud::Vpc::Model::AssociateHaVipRequest;
+
+AssociateHaVipRequest::AssociateHaVipRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "AssociateHaVip") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void AssociateHaVipRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+AssociateHaVipRequest::~AssociateHaVipRequest() {}
+
+long AssociateHaVipRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string AssociateHaVipRequest::getClientToken()const
-{
-	return clientToken_;
+void AssociateHaVipRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void AssociateHaVipRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string AssociateHaVipRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string AssociateHaVipRequest::getRegionId()const
-{
-	return regionId_;
+void AssociateHaVipRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void AssociateHaVipRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string AssociateHaVipRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string AssociateHaVipRequest::getInstanceType()const
-{
-	return instanceType_;
+void AssociateHaVipRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void AssociateHaVipRequest::setInstanceType(const std::string& instanceType)
-{
-	instanceType_ = instanceType;
-	setParameter("InstanceType", instanceType);
+std::string AssociateHaVipRequest::getInstanceType() const {
+  return instanceType_;
 }
 
-std::string AssociateHaVipRequest::getHaVipId()const
-{
-	return haVipId_;
+void AssociateHaVipRequest::setInstanceType(const std::string &instanceType) {
+  instanceType_ = instanceType;
+  setParameter(std::string("InstanceType"), instanceType);
 }
 
-void AssociateHaVipRequest::setHaVipId(const std::string& haVipId)
-{
-	haVipId_ = haVipId;
-	setParameter("HaVipId", haVipId);
+std::string AssociateHaVipRequest::getHaVipId() const {
+  return haVipId_;
 }
 
-std::string AssociateHaVipRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void AssociateHaVipRequest::setHaVipId(const std::string &haVipId) {
+  haVipId_ = haVipId;
+  setParameter(std::string("HaVipId"), haVipId);
 }
 
-void AssociateHaVipRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string AssociateHaVipRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string AssociateHaVipRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void AssociateHaVipRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void AssociateHaVipRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string AssociateHaVipRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long AssociateHaVipRequest::getOwnerId()const
-{
-	return ownerId_;
+void AssociateHaVipRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void AssociateHaVipRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long AssociateHaVipRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string AssociateHaVipRequest::getInstanceId()const
-{
-	return instanceId_;
+void AssociateHaVipRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void AssociateHaVipRequest::setInstanceId(const std::string& instanceId)
-{
-	instanceId_ = instanceId;
-	setParameter("InstanceId", instanceId);
+std::string AssociateHaVipRequest::getInstanceId() const {
+  return instanceId_;
+}
+
+void AssociateHaVipRequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setParameter(std::string("InstanceId"), instanceId);
 }
 

vpc/src/model/AssociateNetworkAclRequest.cc

@@ -1,111 +1,95 @@
 /*
  * 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/vpc/model/AssociateNetworkAclRequest.h>
-
-using AlibabaCloud::Vpc::Model::AssociateNetworkAclRequest;
-
-AssociateNetworkAclRequest::AssociateNetworkAclRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "AssociateNetworkAcl")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-AssociateNetworkAclRequest::~AssociateNetworkAclRequest()
-{}
-
-long AssociateNetworkAclRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/AssociateNetworkAclRequest.h>
+
+using AlibabaCloud::Vpc::Model::AssociateNetworkAclRequest;
+
+AssociateNetworkAclRequest::AssociateNetworkAclRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "AssociateNetworkAcl") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void AssociateNetworkAclRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+AssociateNetworkAclRequest::~AssociateNetworkAclRequest() {}
+
+long AssociateNetworkAclRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string AssociateNetworkAclRequest::getClientToken()const
-{
-	return clientToken_;
+void AssociateNetworkAclRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void AssociateNetworkAclRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string AssociateNetworkAclRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string AssociateNetworkAclRequest::getRegionId()const
-{
-	return regionId_;
+void AssociateNetworkAclRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void AssociateNetworkAclRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string AssociateNetworkAclRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string AssociateNetworkAclRequest::getNetworkAclId()const
-{
-	return networkAclId_;
+void AssociateNetworkAclRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void AssociateNetworkAclRequest::setNetworkAclId(const std::string& networkAclId)
-{
-	networkAclId_ = networkAclId;
-	setParameter("NetworkAclId", networkAclId);
+std::string AssociateNetworkAclRequest::getNetworkAclId() const {
+  return networkAclId_;
 }
 
-std::vector<AssociateNetworkAclRequest::Resource> AssociateNetworkAclRequest::getResource()const
-{
-	return resource_;
+void AssociateNetworkAclRequest::setNetworkAclId(const std::string &networkAclId) {
+  networkAclId_ = networkAclId;
+  setParameter(std::string("NetworkAclId"), networkAclId);
 }
 
-void AssociateNetworkAclRequest::setResource(const std::vector<Resource>& resource)
-{
-	resource_ = resource;
-	for(int dep1 = 0; dep1!= resource.size(); dep1++) {
-		auto resourceObj = resource.at(dep1);
-		std::string resourceObjStr = "Resource." + std::to_string(dep1 + 1);
-		setParameter(resourceObjStr + ".ResourceType", resourceObj.resourceType);
-		setParameter(resourceObjStr + ".ResourceId", resourceObj.resourceId);
-	}
+std::vector<AssociateNetworkAclRequest::Resource> AssociateNetworkAclRequest::getResource() const {
+  return resource_;
 }
 
-std::string AssociateNetworkAclRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void AssociateNetworkAclRequest::setResource(const std::vector<AssociateNetworkAclRequest::Resource> &resource) {
+  resource_ = resource;
+  for(int dep1 = 0; dep1 != resource.size(); dep1++) {
+  auto resourceObj = resource.at(dep1);
+  std::string resourceObjStr = std::string("Resource") + "." + std::to_string(dep1 + 1);
+    setParameter(resourceObjStr + ".ResourceType", resourceObj.resourceType);
+    setParameter(resourceObjStr + ".ResourceId", resourceObj.resourceId);
+  }
 }
 
-void AssociateNetworkAclRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string AssociateNetworkAclRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-long AssociateNetworkAclRequest::getOwnerId()const
-{
-	return ownerId_;
+void AssociateNetworkAclRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void AssociateNetworkAclRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long AssociateNetworkAclRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void AssociateNetworkAclRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 

vpc/src/model/AssociatePhysicalConnectionToVirtualBorderRouterRequest.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/vpc/model/AssociatePhysicalConnectionToVirtualBorderRouterRequest.h>
-
-using AlibabaCloud::Vpc::Model::AssociatePhysicalConnectionToVirtualBorderRouterRequest;
-
-AssociatePhysicalConnectionToVirtualBorderRouterRequest::AssociatePhysicalConnectionToVirtualBorderRouterRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "AssociatePhysicalConnectionToVirtualBorderRouter")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-AssociatePhysicalConnectionToVirtualBorderRouterRequest::~AssociatePhysicalConnectionToVirtualBorderRouterRequest()
-{}
-
-long AssociatePhysicalConnectionToVirtualBorderRouterRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/AssociatePhysicalConnectionToVirtualBorderRouterRequest.h>
+
+using AlibabaCloud::Vpc::Model::AssociatePhysicalConnectionToVirtualBorderRouterRequest;
+
+AssociatePhysicalConnectionToVirtualBorderRouterRequest::AssociatePhysicalConnectionToVirtualBorderRouterRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "AssociatePhysicalConnectionToVirtualBorderRouter") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+AssociatePhysicalConnectionToVirtualBorderRouterRequest::~AssociatePhysicalConnectionToVirtualBorderRouterRequest() {}
+
+long AssociatePhysicalConnectionToVirtualBorderRouterRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getCircuitCode()const
-{
-	return circuitCode_;
+void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setCircuitCode(const std::string& circuitCode)
-{
-	circuitCode_ = circuitCode;
-	setParameter("CircuitCode", circuitCode);
+std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getCircuitCode() const {
+  return circuitCode_;
 }
 
-std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getVlanId()const
-{
-	return vlanId_;
+void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setCircuitCode(const std::string &circuitCode) {
+  circuitCode_ = circuitCode;
+  setParameter(std::string("CircuitCode"), circuitCode);
 }
 
-void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setVlanId(const std::string& vlanId)
-{
-	vlanId_ = vlanId;
-	setParameter("VlanId", vlanId);
+std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getVlanId() const {
+  return vlanId_;
 }
 
-std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getClientToken()const
-{
-	return clientToken_;
+void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setVlanId(const std::string &vlanId) {
+  vlanId_ = vlanId;
+  setParameter(std::string("VlanId"), vlanId);
 }
 
-void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getEnableIpv6()const
-{
-	return enableIpv6_;
+void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setEnableIpv6(const std::string& enableIpv6)
-{
-	enableIpv6_ = enableIpv6;
-	setParameter("EnableIpv6", enableIpv6);
+std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getEnableIpv6() const {
+  return enableIpv6_;
 }
 
-std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getVbrId()const
-{
-	return vbrId_;
+void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setEnableIpv6(const std::string &enableIpv6) {
+  enableIpv6_ = enableIpv6;
+  setParameter(std::string("EnableIpv6"), enableIpv6);
 }
 
-void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setVbrId(const std::string& vbrId)
-{
-	vbrId_ = vbrId;
-	setParameter("VbrId", vbrId);
+std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getVbrId() const {
+  return vbrId_;
 }
 
-std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getPeerGatewayIp()const
-{
-	return peerGatewayIp_;
+void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setVbrId(const std::string &vbrId) {
+  vbrId_ = vbrId;
+  setParameter(std::string("VbrId"), vbrId);
 }
 
-void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setPeerGatewayIp(const std::string& peerGatewayIp)
-{
-	peerGatewayIp_ = peerGatewayIp;
-	setParameter("PeerGatewayIp", peerGatewayIp);
+std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getPeerGatewayIp() const {
+  return peerGatewayIp_;
 }
 
-std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getPeerIpv6GatewayIp()const
-{
-	return peerIpv6GatewayIp_;
+void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setPeerGatewayIp(const std::string &peerGatewayIp) {
+  peerGatewayIp_ = peerGatewayIp;
+  setParameter(std::string("PeerGatewayIp"), peerGatewayIp);
 }
 
-void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setPeerIpv6GatewayIp(const std::string& peerIpv6GatewayIp)
-{
-	peerIpv6GatewayIp_ = peerIpv6GatewayIp;
-	setParameter("PeerIpv6GatewayIp", peerIpv6GatewayIp);
+std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getPeerIpv6GatewayIp() const {
+  return peerIpv6GatewayIp_;
 }
 
-std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getPeeringSubnetMask()const
-{
-	return peeringSubnetMask_;
+void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setPeerIpv6GatewayIp(const std::string &peerIpv6GatewayIp) {
+  peerIpv6GatewayIp_ = peerIpv6GatewayIp;
+  setParameter(std::string("PeerIpv6GatewayIp"), peerIpv6GatewayIp);
 }
 
-void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setPeeringSubnetMask(const std::string& peeringSubnetMask)
-{
-	peeringSubnetMask_ = peeringSubnetMask;
-	setParameter("PeeringSubnetMask", peeringSubnetMask);
+std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getPeeringSubnetMask() const {
+  return peeringSubnetMask_;
 }
 
-std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getRegionId()const
-{
-	return regionId_;
+void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setPeeringSubnetMask(const std::string &peeringSubnetMask) {
+  peeringSubnetMask_ = peeringSubnetMask;
+  setParameter(std::string("PeeringSubnetMask"), peeringSubnetMask);
 }
 
-void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getLocalGatewayIp()const
-{
-	return localGatewayIp_;
+void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setLocalGatewayIp(const std::string& localGatewayIp)
-{
-	localGatewayIp_ = localGatewayIp;
-	setParameter("LocalGatewayIp", localGatewayIp);
+std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getLocalGatewayIp() const {
+  return localGatewayIp_;
 }
 
-std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getPeeringIpv6SubnetMask()const
-{
-	return peeringIpv6SubnetMask_;
+void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setLocalGatewayIp(const std::string &localGatewayIp) {
+  localGatewayIp_ = localGatewayIp;
+  setParameter(std::string("LocalGatewayIp"), localGatewayIp);
 }
 
-void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setPeeringIpv6SubnetMask(const std::string& peeringIpv6SubnetMask)
-{
-	peeringIpv6SubnetMask_ = peeringIpv6SubnetMask;
-	setParameter("PeeringIpv6SubnetMask", peeringIpv6SubnetMask);
+std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getPeeringIpv6SubnetMask() const {
+  return peeringIpv6SubnetMask_;
 }
 
-std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setPeeringIpv6SubnetMask(const std::string &peeringIpv6SubnetMask) {
+  peeringIpv6SubnetMask_ = peeringIpv6SubnetMask;
+  setParameter(std::string("PeeringIpv6SubnetMask"), peeringIpv6SubnetMask);
 }
 
-void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long AssociatePhysicalConnectionToVirtualBorderRouterRequest::getOwnerId()const
-{
-	return ownerId_;
+void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long AssociatePhysicalConnectionToVirtualBorderRouterRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getPhysicalConnectionId()const
-{
-	return physicalConnectionId_;
+void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setPhysicalConnectionId(const std::string& physicalConnectionId)
-{
-	physicalConnectionId_ = physicalConnectionId;
-	setParameter("PhysicalConnectionId", physicalConnectionId);
+std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getPhysicalConnectionId() const {
+  return physicalConnectionId_;
 }
 
-std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getLocalIpv6GatewayIp()const
-{
-	return localIpv6GatewayIp_;
+void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setPhysicalConnectionId(const std::string &physicalConnectionId) {
+  physicalConnectionId_ = physicalConnectionId;
+  setParameter(std::string("PhysicalConnectionId"), physicalConnectionId);
 }
 
-void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setLocalIpv6GatewayIp(const std::string& localIpv6GatewayIp)
-{
-	localIpv6GatewayIp_ = localIpv6GatewayIp;
-	setParameter("LocalIpv6GatewayIp", localIpv6GatewayIp);
+std::string AssociatePhysicalConnectionToVirtualBorderRouterRequest::getLocalIpv6GatewayIp() const {
+  return localIpv6GatewayIp_;
+}
+
+void AssociatePhysicalConnectionToVirtualBorderRouterRequest::setLocalIpv6GatewayIp(const std::string &localIpv6GatewayIp) {
+  localIpv6GatewayIp_ = localIpv6GatewayIp;
+  setParameter(std::string("LocalIpv6GatewayIp"), localIpv6GatewayIp);
 }
 

vpc/src/model/AssociateRouteTableRequest.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/vpc/model/AssociateRouteTableRequest.h>
-
-using AlibabaCloud::Vpc::Model::AssociateRouteTableRequest;
-
-AssociateRouteTableRequest::AssociateRouteTableRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "AssociateRouteTable")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-AssociateRouteTableRequest::~AssociateRouteTableRequest()
-{}
-
-long AssociateRouteTableRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/AssociateRouteTableRequest.h>
+
+using AlibabaCloud::Vpc::Model::AssociateRouteTableRequest;
+
+AssociateRouteTableRequest::AssociateRouteTableRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "AssociateRouteTable") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void AssociateRouteTableRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+AssociateRouteTableRequest::~AssociateRouteTableRequest() {}
+
+long AssociateRouteTableRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string AssociateRouteTableRequest::getClientToken()const
-{
-	return clientToken_;
+void AssociateRouteTableRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void AssociateRouteTableRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string AssociateRouteTableRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string AssociateRouteTableRequest::getRegionId()const
-{
-	return regionId_;
+void AssociateRouteTableRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void AssociateRouteTableRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string AssociateRouteTableRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string AssociateRouteTableRequest::getRouteTableId()const
-{
-	return routeTableId_;
+void AssociateRouteTableRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void AssociateRouteTableRequest::setRouteTableId(const std::string& routeTableId)
-{
-	routeTableId_ = routeTableId;
-	setParameter("RouteTableId", routeTableId);
+std::string AssociateRouteTableRequest::getRouteTableId() const {
+  return routeTableId_;
 }
 
-std::string AssociateRouteTableRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void AssociateRouteTableRequest::setRouteTableId(const std::string &routeTableId) {
+  routeTableId_ = routeTableId;
+  setParameter(std::string("RouteTableId"), routeTableId);
 }
 
-void AssociateRouteTableRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string AssociateRouteTableRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string AssociateRouteTableRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void AssociateRouteTableRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void AssociateRouteTableRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string AssociateRouteTableRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long AssociateRouteTableRequest::getOwnerId()const
-{
-	return ownerId_;
+void AssociateRouteTableRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void AssociateRouteTableRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long AssociateRouteTableRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string AssociateRouteTableRequest::getVSwitchId()const
-{
-	return vSwitchId_;
+void AssociateRouteTableRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void AssociateRouteTableRequest::setVSwitchId(const std::string& vSwitchId)
-{
-	vSwitchId_ = vSwitchId;
-	setParameter("VSwitchId", vSwitchId);
+std::string AssociateRouteTableRequest::getVSwitchId() const {
+  return vSwitchId_;
+}
+
+void AssociateRouteTableRequest::setVSwitchId(const std::string &vSwitchId) {
+  vSwitchId_ = vSwitchId;
+  setParameter(std::string("VSwitchId"), vSwitchId);
 }
 

vpc/src/model/AssociateRouteTableWithGatewayRequest.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/vpc/model/AssociateRouteTableWithGatewayRequest.h>
+
+using AlibabaCloud::Vpc::Model::AssociateRouteTableWithGatewayRequest;
+
+AssociateRouteTableWithGatewayRequest::AssociateRouteTableWithGatewayRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "AssociateRouteTableWithGateway") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+AssociateRouteTableWithGatewayRequest::~AssociateRouteTableWithGatewayRequest() {}
+
+long AssociateRouteTableWithGatewayRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void AssociateRouteTableWithGatewayRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string AssociateRouteTableWithGatewayRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void AssociateRouteTableWithGatewayRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string AssociateRouteTableWithGatewayRequest::getRegionId() const {
+  return regionId_;
+}
+
+void AssociateRouteTableWithGatewayRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string AssociateRouteTableWithGatewayRequest::getGatewayId() const {
+  return gatewayId_;
+}
+
+void AssociateRouteTableWithGatewayRequest::setGatewayId(const std::string &gatewayId) {
+  gatewayId_ = gatewayId;
+  setParameter(std::string("GatewayId"), gatewayId);
+}
+
+std::string AssociateRouteTableWithGatewayRequest::getRouteTableId() const {
+  return routeTableId_;
+}
+
+void AssociateRouteTableWithGatewayRequest::setRouteTableId(const std::string &routeTableId) {
+  routeTableId_ = routeTableId;
+  setParameter(std::string("RouteTableId"), routeTableId);
+}
+
+bool AssociateRouteTableWithGatewayRequest::getDryRun() const {
+  return dryRun_;
+}
+
+void AssociateRouteTableWithGatewayRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setParameter(std::string("DryRun"), dryRun ? "true" : "false");
+}
+
+std::string AssociateRouteTableWithGatewayRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void AssociateRouteTableWithGatewayRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string AssociateRouteTableWithGatewayRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void AssociateRouteTableWithGatewayRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long AssociateRouteTableWithGatewayRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void AssociateRouteTableWithGatewayRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+

vpc/src/model/AssociateRouteTableWithGatewayResult.cc

@@ -0,0 +1,44 @@
+/*
+ * 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/vpc/model/AssociateRouteTableWithGatewayResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vpc;
+using namespace AlibabaCloud::Vpc::Model;
+
+AssociateRouteTableWithGatewayResult::AssociateRouteTableWithGatewayResult() :
+	ServiceResult()
+{}
+
+AssociateRouteTableWithGatewayResult::AssociateRouteTableWithGatewayResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+AssociateRouteTableWithGatewayResult::~AssociateRouteTableWithGatewayResult()
+{}
+
+void AssociateRouteTableWithGatewayResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

vpc/src/model/AssociateRouteTablesWithVpcGatewayEndpointRequest.cc

@@ -0,0 +1,107 @@
+/*
+ * 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/vpc/model/AssociateRouteTablesWithVpcGatewayEndpointRequest.h>
+
+using AlibabaCloud::Vpc::Model::AssociateRouteTablesWithVpcGatewayEndpointRequest;
+
+AssociateRouteTablesWithVpcGatewayEndpointRequest::AssociateRouteTablesWithVpcGatewayEndpointRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "AssociateRouteTablesWithVpcGatewayEndpoint") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+AssociateRouteTablesWithVpcGatewayEndpointRequest::~AssociateRouteTablesWithVpcGatewayEndpointRequest() {}
+
+long AssociateRouteTablesWithVpcGatewayEndpointRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void AssociateRouteTablesWithVpcGatewayEndpointRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+bool AssociateRouteTablesWithVpcGatewayEndpointRequest::getDryRun() const {
+  return dryRun_;
+}
+
+void AssociateRouteTablesWithVpcGatewayEndpointRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setParameter(std::string("DryRun"), dryRun ? "true" : "false");
+}
+
+std::string AssociateRouteTablesWithVpcGatewayEndpointRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void AssociateRouteTablesWithVpcGatewayEndpointRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string AssociateRouteTablesWithVpcGatewayEndpointRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void AssociateRouteTablesWithVpcGatewayEndpointRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string AssociateRouteTablesWithVpcGatewayEndpointRequest::getEndpointId() const {
+  return endpointId_;
+}
+
+void AssociateRouteTablesWithVpcGatewayEndpointRequest::setEndpointId(const std::string &endpointId) {
+  endpointId_ = endpointId;
+  setParameter(std::string("EndpointId"), endpointId);
+}
+
+std::string AssociateRouteTablesWithVpcGatewayEndpointRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void AssociateRouteTablesWithVpcGatewayEndpointRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long AssociateRouteTablesWithVpcGatewayEndpointRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void AssociateRouteTablesWithVpcGatewayEndpointRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string AssociateRouteTablesWithVpcGatewayEndpointRequest::getRegionId() const {
+  return regionId_;
+}
+
+void AssociateRouteTablesWithVpcGatewayEndpointRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::vector<std::string> AssociateRouteTablesWithVpcGatewayEndpointRequest::getRouteTableIds() const {
+  return routeTableIds_;
+}
+
+void AssociateRouteTablesWithVpcGatewayEndpointRequest::setRouteTableIds(const std::vector<std::string> &routeTableIds) {
+  routeTableIds_ = routeTableIds;
+}
+

vpc/src/model/AssociateRouteTablesWithVpcGatewayEndpointResult.cc

@@ -0,0 +1,44 @@
+/*
+ * 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/vpc/model/AssociateRouteTablesWithVpcGatewayEndpointResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vpc;
+using namespace AlibabaCloud::Vpc::Model;
+
+AssociateRouteTablesWithVpcGatewayEndpointResult::AssociateRouteTablesWithVpcGatewayEndpointResult() :
+	ServiceResult()
+{}
+
+AssociateRouteTablesWithVpcGatewayEndpointResult::AssociateRouteTablesWithVpcGatewayEndpointResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+AssociateRouteTablesWithVpcGatewayEndpointResult::~AssociateRouteTablesWithVpcGatewayEndpointResult()
+{}
+
+void AssociateRouteTablesWithVpcGatewayEndpointResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

vpc/src/model/AssociateVpcCidrBlockRequest.cc

@@ -1,150 +1,126 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
-
-#include <alibabacloud/vpc/model/AssociateVpcCidrBlockRequest.h>
-
-using AlibabaCloud::Vpc::Model::AssociateVpcCidrBlockRequest;
-
-AssociateVpcCidrBlockRequest::AssociateVpcCidrBlockRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "AssociateVpcCidrBlock")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-AssociateVpcCidrBlockRequest::~AssociateVpcCidrBlockRequest()
-{}
-
-long AssociateVpcCidrBlockRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/AssociateVpcCidrBlockRequest.h>
+
+using AlibabaCloud::Vpc::Model::AssociateVpcCidrBlockRequest;
+
+AssociateVpcCidrBlockRequest::AssociateVpcCidrBlockRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "AssociateVpcCidrBlock") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void AssociateVpcCidrBlockRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+AssociateVpcCidrBlockRequest::~AssociateVpcCidrBlockRequest() {}
+
+long AssociateVpcCidrBlockRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string AssociateVpcCidrBlockRequest::getIPv6CidrType()const
-{
-	return iPv6CidrType_;
+void AssociateVpcCidrBlockRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void AssociateVpcCidrBlockRequest::setIPv6CidrType(const std::string& iPv6CidrType)
-{
-	iPv6CidrType_ = iPv6CidrType;
-	setParameter("IPv6CidrType", iPv6CidrType);
+std::string AssociateVpcCidrBlockRequest::getIPv6CidrType() const {
+  return iPv6CidrType_;
 }
 
-std::string AssociateVpcCidrBlockRequest::getRegionId()const
-{
-	return regionId_;
+void AssociateVpcCidrBlockRequest::setIPv6CidrType(const std::string &iPv6CidrType) {
+  iPv6CidrType_ = iPv6CidrType;
+  setParameter(std::string("IPv6CidrType"), iPv6CidrType);
 }
 
-void AssociateVpcCidrBlockRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string AssociateVpcCidrBlockRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string AssociateVpcCidrBlockRequest::getIpv6Isp()const
-{
-	return ipv6Isp_;
+void AssociateVpcCidrBlockRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void AssociateVpcCidrBlockRequest::setIpv6Isp(const std::string& ipv6Isp)
-{
-	ipv6Isp_ = ipv6Isp;
-	setParameter("Ipv6Isp", ipv6Isp);
+std::string AssociateVpcCidrBlockRequest::getIpv6Isp() const {
+  return ipv6Isp_;
 }
 
-std::string AssociateVpcCidrBlockRequest::getIpVersion()const
-{
-	return ipVersion_;
+void AssociateVpcCidrBlockRequest::setIpv6Isp(const std::string &ipv6Isp) {
+  ipv6Isp_ = ipv6Isp;
+  setParameter(std::string("Ipv6Isp"), ipv6Isp);
 }
 
-void AssociateVpcCidrBlockRequest::setIpVersion(const std::string& ipVersion)
-{
-	ipVersion_ = ipVersion;
-	setParameter("IpVersion", ipVersion);
+std::string AssociateVpcCidrBlockRequest::getIpVersion() const {
+  return ipVersion_;
 }
 
-std::string AssociateVpcCidrBlockRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void AssociateVpcCidrBlockRequest::setIpVersion(const std::string &ipVersion) {
+  ipVersion_ = ipVersion;
+  setParameter(std::string("IpVersion"), ipVersion);
 }
 
-void AssociateVpcCidrBlockRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string AssociateVpcCidrBlockRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string AssociateVpcCidrBlockRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void AssociateVpcCidrBlockRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void AssociateVpcCidrBlockRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string AssociateVpcCidrBlockRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long AssociateVpcCidrBlockRequest::getOwnerId()const
-{
-	return ownerId_;
+void AssociateVpcCidrBlockRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void AssociateVpcCidrBlockRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long AssociateVpcCidrBlockRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string AssociateVpcCidrBlockRequest::getIPv6CidrBlock()const
-{
-	return iPv6CidrBlock_;
+void AssociateVpcCidrBlockRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void AssociateVpcCidrBlockRequest::setIPv6CidrBlock(const std::string& iPv6CidrBlock)
-{
-	iPv6CidrBlock_ = iPv6CidrBlock;
-	setParameter("IPv6CidrBlock", iPv6CidrBlock);
+std::string AssociateVpcCidrBlockRequest::getIPv6CidrBlock() const {
+  return iPv6CidrBlock_;
 }
 
-std::string AssociateVpcCidrBlockRequest::getSecondaryCidrBlock()const
-{
-	return secondaryCidrBlock_;
+void AssociateVpcCidrBlockRequest::setIPv6CidrBlock(const std::string &iPv6CidrBlock) {
+  iPv6CidrBlock_ = iPv6CidrBlock;
+  setParameter(std::string("IPv6CidrBlock"), iPv6CidrBlock);
 }
 
-void AssociateVpcCidrBlockRequest::setSecondaryCidrBlock(const std::string& secondaryCidrBlock)
-{
-	secondaryCidrBlock_ = secondaryCidrBlock;
-	setParameter("SecondaryCidrBlock", secondaryCidrBlock);
+std::string AssociateVpcCidrBlockRequest::getSecondaryCidrBlock() const {
+  return secondaryCidrBlock_;
 }
 
-std::string AssociateVpcCidrBlockRequest::getVpcId()const
-{
-	return vpcId_;
+void AssociateVpcCidrBlockRequest::setSecondaryCidrBlock(const std::string &secondaryCidrBlock) {
+  secondaryCidrBlock_ = secondaryCidrBlock;
+  setParameter(std::string("SecondaryCidrBlock"), secondaryCidrBlock);
 }
 
-void AssociateVpcCidrBlockRequest::setVpcId(const std::string& vpcId)
-{
-	vpcId_ = vpcId;
-	setParameter("VpcId", vpcId);
+std::string AssociateVpcCidrBlockRequest::getVpcId() const {
+  return vpcId_;
+}
+
+void AssociateVpcCidrBlockRequest::setVpcId(const std::string &vpcId) {
+  vpcId_ = vpcId;
+  setParameter(std::string("VpcId"), vpcId);
 }
 

vpc/src/model/AssociateVpnGatewayWithCertificateRequest.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/vpc/model/AssociateVpnGatewayWithCertificateRequest.h>
-
-using AlibabaCloud::Vpc::Model::AssociateVpnGatewayWithCertificateRequest;
-
-AssociateVpnGatewayWithCertificateRequest::AssociateVpnGatewayWithCertificateRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "AssociateVpnGatewayWithCertificate")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-AssociateVpnGatewayWithCertificateRequest::~AssociateVpnGatewayWithCertificateRequest()
-{}
-
-long AssociateVpnGatewayWithCertificateRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/AssociateVpnGatewayWithCertificateRequest.h>
+
+using AlibabaCloud::Vpc::Model::AssociateVpnGatewayWithCertificateRequest;
+
+AssociateVpnGatewayWithCertificateRequest::AssociateVpnGatewayWithCertificateRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "AssociateVpnGatewayWithCertificate") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void AssociateVpnGatewayWithCertificateRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+AssociateVpnGatewayWithCertificateRequest::~AssociateVpnGatewayWithCertificateRequest() {}
+
+long AssociateVpnGatewayWithCertificateRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-bool AssociateVpnGatewayWithCertificateRequest::getDryRun()const
-{
-	return dryRun_;
+void AssociateVpnGatewayWithCertificateRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void AssociateVpnGatewayWithCertificateRequest::setDryRun(bool dryRun)
-{
-	dryRun_ = dryRun;
-	setParameter("DryRun", dryRun ? "true" : "false");
+bool AssociateVpnGatewayWithCertificateRequest::getDryRun() const {
+  return dryRun_;
 }
 
-std::string AssociateVpnGatewayWithCertificateRequest::getClientToken()const
-{
-	return clientToken_;
+void AssociateVpnGatewayWithCertificateRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setParameter(std::string("DryRun"), dryRun ? "true" : "false");
 }
 
-void AssociateVpnGatewayWithCertificateRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string AssociateVpnGatewayWithCertificateRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string AssociateVpnGatewayWithCertificateRequest::getCertificateId()const
-{
-	return certificateId_;
+void AssociateVpnGatewayWithCertificateRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void AssociateVpnGatewayWithCertificateRequest::setCertificateId(const std::string& certificateId)
-{
-	certificateId_ = certificateId;
-	setParameter("CertificateId", certificateId);
+std::string AssociateVpnGatewayWithCertificateRequest::getCertificateId() const {
+  return certificateId_;
 }
 
-std::string AssociateVpnGatewayWithCertificateRequest::getVpnGatewayId()const
-{
-	return vpnGatewayId_;
+void AssociateVpnGatewayWithCertificateRequest::setCertificateId(const std::string &certificateId) {
+  certificateId_ = certificateId;
+  setParameter(std::string("CertificateId"), certificateId);
 }
 
-void AssociateVpnGatewayWithCertificateRequest::setVpnGatewayId(const std::string& vpnGatewayId)
-{
-	vpnGatewayId_ = vpnGatewayId;
-	setParameter("VpnGatewayId", vpnGatewayId);
+std::string AssociateVpnGatewayWithCertificateRequest::getVpnGatewayId() const {
+  return vpnGatewayId_;
 }
 
-std::string AssociateVpnGatewayWithCertificateRequest::getCallerBid()const
-{
-	return callerBid_;
+void AssociateVpnGatewayWithCertificateRequest::setVpnGatewayId(const std::string &vpnGatewayId) {
+  vpnGatewayId_ = vpnGatewayId;
+  setParameter(std::string("VpnGatewayId"), vpnGatewayId);
 }
 
-void AssociateVpnGatewayWithCertificateRequest::setCallerBid(const std::string& callerBid)
-{
-	callerBid_ = callerBid;
-	setParameter("CallerBid", callerBid);
+std::string AssociateVpnGatewayWithCertificateRequest::getCallerBid() const {
+  return callerBid_;
 }
 
-std::string AssociateVpnGatewayWithCertificateRequest::getCertificateType()const
-{
-	return certificateType_;
+void AssociateVpnGatewayWithCertificateRequest::setCallerBid(const std::string &callerBid) {
+  callerBid_ = callerBid;
+  setParameter(std::string("callerBid"), callerBid);
 }
 
-void AssociateVpnGatewayWithCertificateRequest::setCertificateType(const std::string& certificateType)
-{
-	certificateType_ = certificateType;
-	setParameter("CertificateType", certificateType);
+std::string AssociateVpnGatewayWithCertificateRequest::getCertificateType() const {
+  return certificateType_;
 }
 
-std::string AssociateVpnGatewayWithCertificateRequest::getRegionId()const
-{
-	return regionId_;
+void AssociateVpnGatewayWithCertificateRequest::setCertificateType(const std::string &certificateType) {
+  certificateType_ = certificateType;
+  setParameter(std::string("CertificateType"), certificateType);
 }
 
-void AssociateVpnGatewayWithCertificateRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string AssociateVpnGatewayWithCertificateRequest::getRegionId() const {
+  return regionId_;
+}
+
+void AssociateVpnGatewayWithCertificateRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 

vpc/src/model/AttachDhcpOptionsSetToVpcRequest.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/vpc/model/AttachDhcpOptionsSetToVpcRequest.h>
-
-using AlibabaCloud::Vpc::Model::AttachDhcpOptionsSetToVpcRequest;
-
-AttachDhcpOptionsSetToVpcRequest::AttachDhcpOptionsSetToVpcRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "AttachDhcpOptionsSetToVpc")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-AttachDhcpOptionsSetToVpcRequest::~AttachDhcpOptionsSetToVpcRequest()
-{}
-
-long AttachDhcpOptionsSetToVpcRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/AttachDhcpOptionsSetToVpcRequest.h>
+
+using AlibabaCloud::Vpc::Model::AttachDhcpOptionsSetToVpcRequest;
+
+AttachDhcpOptionsSetToVpcRequest::AttachDhcpOptionsSetToVpcRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "AttachDhcpOptionsSetToVpc") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void AttachDhcpOptionsSetToVpcRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+AttachDhcpOptionsSetToVpcRequest::~AttachDhcpOptionsSetToVpcRequest() {}
+
+long AttachDhcpOptionsSetToVpcRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string AttachDhcpOptionsSetToVpcRequest::getClientToken()const
-{
-	return clientToken_;
+void AttachDhcpOptionsSetToVpcRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void AttachDhcpOptionsSetToVpcRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string AttachDhcpOptionsSetToVpcRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string AttachDhcpOptionsSetToVpcRequest::getRegionId()const
-{
-	return regionId_;
+void AttachDhcpOptionsSetToVpcRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void AttachDhcpOptionsSetToVpcRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string AttachDhcpOptionsSetToVpcRequest::getRegionId() const {
+  return regionId_;
 }
 
-bool AttachDhcpOptionsSetToVpcRequest::getDryRun()const
-{
-	return dryRun_;
+void AttachDhcpOptionsSetToVpcRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void AttachDhcpOptionsSetToVpcRequest::setDryRun(bool dryRun)
-{
-	dryRun_ = dryRun;
-	setParameter("DryRun", dryRun ? "true" : "false");
+bool AttachDhcpOptionsSetToVpcRequest::getDryRun() const {
+  return dryRun_;
 }
 
-std::string AttachDhcpOptionsSetToVpcRequest::getDhcpOptionsSetId()const
-{
-	return dhcpOptionsSetId_;
+void AttachDhcpOptionsSetToVpcRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setParameter(std::string("DryRun"), dryRun ? "true" : "false");
 }
 
-void AttachDhcpOptionsSetToVpcRequest::setDhcpOptionsSetId(const std::string& dhcpOptionsSetId)
-{
-	dhcpOptionsSetId_ = dhcpOptionsSetId;
-	setParameter("DhcpOptionsSetId", dhcpOptionsSetId);
+std::string AttachDhcpOptionsSetToVpcRequest::getDhcpOptionsSetId() const {
+  return dhcpOptionsSetId_;
 }
 
-std::string AttachDhcpOptionsSetToVpcRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void AttachDhcpOptionsSetToVpcRequest::setDhcpOptionsSetId(const std::string &dhcpOptionsSetId) {
+  dhcpOptionsSetId_ = dhcpOptionsSetId;
+  setParameter(std::string("DhcpOptionsSetId"), dhcpOptionsSetId);
 }
 
-void AttachDhcpOptionsSetToVpcRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string AttachDhcpOptionsSetToVpcRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string AttachDhcpOptionsSetToVpcRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void AttachDhcpOptionsSetToVpcRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void AttachDhcpOptionsSetToVpcRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string AttachDhcpOptionsSetToVpcRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long AttachDhcpOptionsSetToVpcRequest::getOwnerId()const
-{
-	return ownerId_;
+void AttachDhcpOptionsSetToVpcRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void AttachDhcpOptionsSetToVpcRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long AttachDhcpOptionsSetToVpcRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string AttachDhcpOptionsSetToVpcRequest::getVpcId()const
-{
-	return vpcId_;
+void AttachDhcpOptionsSetToVpcRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void AttachDhcpOptionsSetToVpcRequest::setVpcId(const std::string& vpcId)
-{
-	vpcId_ = vpcId;
-	setParameter("VpcId", vpcId);
+std::string AttachDhcpOptionsSetToVpcRequest::getVpcId() const {
+  return vpcId_;
+}
+
+void AttachDhcpOptionsSetToVpcRequest::setVpcId(const std::string &vpcId) {
+  vpcId_ = vpcId;
+  setParameter(std::string("VpcId"), vpcId);
 }
 

vpc/src/model/AttachVbrToVpconnRequest.cc

@@ -0,0 +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/vpc/model/AttachVbrToVpconnRequest.h>
+
+using AlibabaCloud::Vpc::Model::AttachVbrToVpconnRequest;
+
+AttachVbrToVpconnRequest::AttachVbrToVpconnRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "AttachVbrToVpconn") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+AttachVbrToVpconnRequest::~AttachVbrToVpconnRequest() {}
+
+bool AttachVbrToVpconnRequest::getDryRun() const {
+  return dryRun_;
+}
+
+void AttachVbrToVpconnRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setParameter(std::string("DryRun"), dryRun ? "true" : "false");
+}
+
+std::string AttachVbrToVpconnRequest::getVpconnId() const {
+  return vpconnId_;
+}
+
+void AttachVbrToVpconnRequest::setVpconnId(const std::string &vpconnId) {
+  vpconnId_ = vpconnId;
+  setParameter(std::string("VpconnId"), vpconnId);
+}
+
+std::string AttachVbrToVpconnRequest::getVbrId() const {
+  return vbrId_;
+}
+
+void AttachVbrToVpconnRequest::setVbrId(const std::string &vbrId) {
+  vbrId_ = vbrId;
+  setParameter(std::string("VbrId"), vbrId);
+}
+
+std::string AttachVbrToVpconnRequest::getToken() const {
+  return token_;
+}
+
+void AttachVbrToVpconnRequest::setToken(const std::string &token) {
+  token_ = token;
+  setParameter(std::string("Token"), token);
+}
+
+std::string AttachVbrToVpconnRequest::getRegionId() const {
+  return regionId_;
+}
+
+void AttachVbrToVpconnRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+

vpc/src/model/AttachVbrToVpconnResult.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/vpc/model/AttachVbrToVpconnResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vpc;
+using namespace AlibabaCloud::Vpc::Model;
+
+AttachVbrToVpconnResult::AttachVbrToVpconnResult() :
+	ServiceResult()
+{}
+
+AttachVbrToVpconnResult::AttachVbrToVpconnResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+AttachVbrToVpconnResult::~AttachVbrToVpconnResult()
+{}
+
+void AttachVbrToVpconnResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["VirtualPhysicalConnection"].isNull())
+		virtualPhysicalConnection_ = value["VirtualPhysicalConnection"].asString();
+
+}
+
+std::string AttachVbrToVpconnResult::getVirtualPhysicalConnection()const
+{
+	return virtualPhysicalConnection_;
+}
+

vpc/src/model/CancelCommonBandwidthPackageIpBandwidthRequest.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/vpc/model/CancelCommonBandwidthPackageIpBandwidthRequest.h>
-
-using AlibabaCloud::Vpc::Model::CancelCommonBandwidthPackageIpBandwidthRequest;
-
-CancelCommonBandwidthPackageIpBandwidthRequest::CancelCommonBandwidthPackageIpBandwidthRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "CancelCommonBandwidthPackageIpBandwidth")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CancelCommonBandwidthPackageIpBandwidthRequest::~CancelCommonBandwidthPackageIpBandwidthRequest()
-{}
-
-long CancelCommonBandwidthPackageIpBandwidthRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/CancelCommonBandwidthPackageIpBandwidthRequest.h>
+
+using AlibabaCloud::Vpc::Model::CancelCommonBandwidthPackageIpBandwidthRequest;
+
+CancelCommonBandwidthPackageIpBandwidthRequest::CancelCommonBandwidthPackageIpBandwidthRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CancelCommonBandwidthPackageIpBandwidth") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CancelCommonBandwidthPackageIpBandwidthRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+CancelCommonBandwidthPackageIpBandwidthRequest::~CancelCommonBandwidthPackageIpBandwidthRequest() {}
+
+long CancelCommonBandwidthPackageIpBandwidthRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string CancelCommonBandwidthPackageIpBandwidthRequest::getRegionId()const
-{
-	return regionId_;
+void CancelCommonBandwidthPackageIpBandwidthRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void CancelCommonBandwidthPackageIpBandwidthRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string CancelCommonBandwidthPackageIpBandwidthRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string CancelCommonBandwidthPackageIpBandwidthRequest::getBandwidthPackageId()const
-{
-	return bandwidthPackageId_;
+void CancelCommonBandwidthPackageIpBandwidthRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void CancelCommonBandwidthPackageIpBandwidthRequest::setBandwidthPackageId(const std::string& bandwidthPackageId)
-{
-	bandwidthPackageId_ = bandwidthPackageId;
-	setParameter("BandwidthPackageId", bandwidthPackageId);
+std::string CancelCommonBandwidthPackageIpBandwidthRequest::getBandwidthPackageId() const {
+  return bandwidthPackageId_;
 }
 
-std::string CancelCommonBandwidthPackageIpBandwidthRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void CancelCommonBandwidthPackageIpBandwidthRequest::setBandwidthPackageId(const std::string &bandwidthPackageId) {
+  bandwidthPackageId_ = bandwidthPackageId;
+  setParameter(std::string("BandwidthPackageId"), bandwidthPackageId);
 }
 
-void CancelCommonBandwidthPackageIpBandwidthRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string CancelCommonBandwidthPackageIpBandwidthRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string CancelCommonBandwidthPackageIpBandwidthRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void CancelCommonBandwidthPackageIpBandwidthRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void CancelCommonBandwidthPackageIpBandwidthRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string CancelCommonBandwidthPackageIpBandwidthRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-std::string CancelCommonBandwidthPackageIpBandwidthRequest::getEipId()const
-{
-	return eipId_;
+void CancelCommonBandwidthPackageIpBandwidthRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void CancelCommonBandwidthPackageIpBandwidthRequest::setEipId(const std::string& eipId)
-{
-	eipId_ = eipId;
-	setParameter("EipId", eipId);
+std::string CancelCommonBandwidthPackageIpBandwidthRequest::getEipId() const {
+  return eipId_;
 }
 
-long CancelCommonBandwidthPackageIpBandwidthRequest::getOwnerId()const
-{
-	return ownerId_;
+void CancelCommonBandwidthPackageIpBandwidthRequest::setEipId(const std::string &eipId) {
+  eipId_ = eipId;
+  setParameter(std::string("EipId"), eipId);
 }
 
-void CancelCommonBandwidthPackageIpBandwidthRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long CancelCommonBandwidthPackageIpBandwidthRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CancelCommonBandwidthPackageIpBandwidthRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 

vpc/src/model/CancelExpressCloudConnectionRequest.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/vpc/model/CancelExpressCloudConnectionRequest.h>
-
-using AlibabaCloud::Vpc::Model::CancelExpressCloudConnectionRequest;
-
-CancelExpressCloudConnectionRequest::CancelExpressCloudConnectionRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "CancelExpressCloudConnection")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CancelExpressCloudConnectionRequest::~CancelExpressCloudConnectionRequest()
-{}
-
-long CancelExpressCloudConnectionRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
-}
-
-void CancelExpressCloudConnectionRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
-}
-
-std::string CancelExpressCloudConnectionRequest::getRegionId()const
-{
-	return regionId_;
-}
-
-void CancelExpressCloudConnectionRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
-}
-
-std::string CancelExpressCloudConnectionRequest::getEccId()const
-{
-	return eccId_;
-}
-
-void CancelExpressCloudConnectionRequest::setEccId(const std::string& eccId)
-{
-	eccId_ = eccId;
-	setParameter("EccId", eccId);
-}
-
-std::string CancelExpressCloudConnectionRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
-}
-
-void CancelExpressCloudConnectionRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
-}
-
-std::string CancelExpressCloudConnectionRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
-}
-
-void CancelExpressCloudConnectionRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
-}
-
-long CancelExpressCloudConnectionRequest::getOwnerId()const
-{
-	return ownerId_;
-}
-
-void CancelExpressCloudConnectionRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
-}
-

vpc/src/model/CancelPhysicalConnectionRequest.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/vpc/model/CancelPhysicalConnectionRequest.h>
-
-using AlibabaCloud::Vpc::Model::CancelPhysicalConnectionRequest;
-
-CancelPhysicalConnectionRequest::CancelPhysicalConnectionRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "CancelPhysicalConnection")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CancelPhysicalConnectionRequest::~CancelPhysicalConnectionRequest()
-{}
-
-long CancelPhysicalConnectionRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/CancelPhysicalConnectionRequest.h>
+
+using AlibabaCloud::Vpc::Model::CancelPhysicalConnectionRequest;
+
+CancelPhysicalConnectionRequest::CancelPhysicalConnectionRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CancelPhysicalConnection") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CancelPhysicalConnectionRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+CancelPhysicalConnectionRequest::~CancelPhysicalConnectionRequest() {}
+
+long CancelPhysicalConnectionRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string CancelPhysicalConnectionRequest::getClientToken()const
-{
-	return clientToken_;
+void CancelPhysicalConnectionRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void CancelPhysicalConnectionRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string CancelPhysicalConnectionRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string CancelPhysicalConnectionRequest::getRegionId()const
-{
-	return regionId_;
+void CancelPhysicalConnectionRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void CancelPhysicalConnectionRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string CancelPhysicalConnectionRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string CancelPhysicalConnectionRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void CancelPhysicalConnectionRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void CancelPhysicalConnectionRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string CancelPhysicalConnectionRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string CancelPhysicalConnectionRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void CancelPhysicalConnectionRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void CancelPhysicalConnectionRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string CancelPhysicalConnectionRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long CancelPhysicalConnectionRequest::getOwnerId()const
-{
-	return ownerId_;
+void CancelPhysicalConnectionRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void CancelPhysicalConnectionRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long CancelPhysicalConnectionRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string CancelPhysicalConnectionRequest::getPhysicalConnectionId()const
-{
-	return physicalConnectionId_;
+void CancelPhysicalConnectionRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void CancelPhysicalConnectionRequest::setPhysicalConnectionId(const std::string& physicalConnectionId)
-{
-	physicalConnectionId_ = physicalConnectionId;
-	setParameter("PhysicalConnectionId", physicalConnectionId);
+std::string CancelPhysicalConnectionRequest::getPhysicalConnectionId() const {
+  return physicalConnectionId_;
+}
+
+void CancelPhysicalConnectionRequest::setPhysicalConnectionId(const std::string &physicalConnectionId) {
+  physicalConnectionId_ = physicalConnectionId;
+  setParameter(std::string("PhysicalConnectionId"), physicalConnectionId);
 }
 

vpc/src/model/ChangeResourceGroupRequest.cc

@@ -0,0 +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/vpc/model/ChangeResourceGroupRequest.h>
+
+using AlibabaCloud::Vpc::Model::ChangeResourceGroupRequest;
+
+ChangeResourceGroupRequest::ChangeResourceGroupRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "ChangeResourceGroup") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ChangeResourceGroupRequest::~ChangeResourceGroupRequest() {}
+
+std::string ChangeResourceGroupRequest::getResourceId() const {
+  return resourceId_;
+}
+
+void ChangeResourceGroupRequest::setResourceId(const std::string &resourceId) {
+  resourceId_ = resourceId;
+  setParameter(std::string("ResourceId"), resourceId);
+}
+
+std::string ChangeResourceGroupRequest::getResourceType() const {
+  return resourceType_;
+}
+
+void ChangeResourceGroupRequest::setResourceType(const std::string &resourceType) {
+  resourceType_ = resourceType;
+  setParameter(std::string("ResourceType"), resourceType);
+}
+
+std::string ChangeResourceGroupRequest::getNewResourceGroupId() const {
+  return newResourceGroupId_;
+}
+
+void ChangeResourceGroupRequest::setNewResourceGroupId(const std::string &newResourceGroupId) {
+  newResourceGroupId_ = newResourceGroupId;
+  setParameter(std::string("NewResourceGroupId"), newResourceGroupId);
+}
+
+std::string ChangeResourceGroupRequest::getRegionId() const {
+  return regionId_;
+}
+
+void ChangeResourceGroupRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+

vpc/src/model/ChangeResourceGroupResult.cc

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

vpc/src/model/CheckCanAllocateVpcPrivateIpAddressRequest.cc

@@ -0,0 +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/vpc/model/CheckCanAllocateVpcPrivateIpAddressRequest.h>
+
+using AlibabaCloud::Vpc::Model::CheckCanAllocateVpcPrivateIpAddressRequest;
+
+CheckCanAllocateVpcPrivateIpAddressRequest::CheckCanAllocateVpcPrivateIpAddressRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CheckCanAllocateVpcPrivateIpAddress") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CheckCanAllocateVpcPrivateIpAddressRequest::~CheckCanAllocateVpcPrivateIpAddressRequest() {}
+
+long CheckCanAllocateVpcPrivateIpAddressRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void CheckCanAllocateVpcPrivateIpAddressRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string CheckCanAllocateVpcPrivateIpAddressRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CheckCanAllocateVpcPrivateIpAddressRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string CheckCanAllocateVpcPrivateIpAddressRequest::getIpVersion() const {
+  return ipVersion_;
+}
+
+void CheckCanAllocateVpcPrivateIpAddressRequest::setIpVersion(const std::string &ipVersion) {
+  ipVersion_ = ipVersion;
+  setParameter(std::string("IpVersion"), ipVersion);
+}
+
+std::string CheckCanAllocateVpcPrivateIpAddressRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void CheckCanAllocateVpcPrivateIpAddressRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string CheckCanAllocateVpcPrivateIpAddressRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void CheckCanAllocateVpcPrivateIpAddressRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long CheckCanAllocateVpcPrivateIpAddressRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CheckCanAllocateVpcPrivateIpAddressRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string CheckCanAllocateVpcPrivateIpAddressRequest::getVSwitchId() const {
+  return vSwitchId_;
+}
+
+void CheckCanAllocateVpcPrivateIpAddressRequest::setVSwitchId(const std::string &vSwitchId) {
+  vSwitchId_ = vSwitchId;
+  setParameter(std::string("VSwitchId"), vSwitchId);
+}
+
+std::string CheckCanAllocateVpcPrivateIpAddressRequest::getPrivateIpAddress() const {
+  return privateIpAddress_;
+}
+
+void CheckCanAllocateVpcPrivateIpAddressRequest::setPrivateIpAddress(const std::string &privateIpAddress) {
+  privateIpAddress_ = privateIpAddress;
+  setParameter(std::string("PrivateIpAddress"), privateIpAddress);
+}
+

vpc/src/model/CheckCanAllocateVpcPrivateIpAddressResult.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/vpc/model/CheckCanAllocateVpcPrivateIpAddressResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vpc;
+using namespace AlibabaCloud::Vpc::Model;
+
+CheckCanAllocateVpcPrivateIpAddressResult::CheckCanAllocateVpcPrivateIpAddressResult() :
+	ServiceResult()
+{}
+
+CheckCanAllocateVpcPrivateIpAddressResult::CheckCanAllocateVpcPrivateIpAddressResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CheckCanAllocateVpcPrivateIpAddressResult::~CheckCanAllocateVpcPrivateIpAddressResult()
+{}
+
+void CheckCanAllocateVpcPrivateIpAddressResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["CanAllocate"].isNull())
+		canAllocate_ = value["CanAllocate"].asString() == "true";
+
+}
+
+bool CheckCanAllocateVpcPrivateIpAddressResult::getCanAllocate()const
+{
+	return canAllocate_;
+}
+

vpc/src/model/CheckVpnBgpEnabledRequest.cc

@@ -0,0 +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/vpc/model/CheckVpnBgpEnabledRequest.h>
+
+using AlibabaCloud::Vpc::Model::CheckVpnBgpEnabledRequest;
+
+CheckVpnBgpEnabledRequest::CheckVpnBgpEnabledRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CheckVpnBgpEnabled") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CheckVpnBgpEnabledRequest::~CheckVpnBgpEnabledRequest() {}
+
+long CheckVpnBgpEnabledRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void CheckVpnBgpEnabledRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string CheckVpnBgpEnabledRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void CheckVpnBgpEnabledRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string CheckVpnBgpEnabledRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CheckVpnBgpEnabledRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string CheckVpnBgpEnabledRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void CheckVpnBgpEnabledRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string CheckVpnBgpEnabledRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void CheckVpnBgpEnabledRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+

vpc/src/model/CheckVpnBgpEnabledResult.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/vpc/model/CheckVpnBgpEnabledResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vpc;
+using namespace AlibabaCloud::Vpc::Model;
+
+CheckVpnBgpEnabledResult::CheckVpnBgpEnabledResult() :
+	ServiceResult()
+{}
+
+CheckVpnBgpEnabledResult::CheckVpnBgpEnabledResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CheckVpnBgpEnabledResult::~CheckVpnBgpEnabledResult()
+{}
+
+void CheckVpnBgpEnabledResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["BgpEnabled"].isNull())
+		bgpEnabled_ = value["BgpEnabled"].asString() == "true";
+
+}
+
+bool CheckVpnBgpEnabledResult::getBgpEnabled()const
+{
+	return bgpEnabled_;
+}
+

vpc/src/model/CompletePhysicalConnectionLOARequest.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/vpc/model/CompletePhysicalConnectionLOARequest.h>
-
-using AlibabaCloud::Vpc::Model::CompletePhysicalConnectionLOARequest;
-
-CompletePhysicalConnectionLOARequest::CompletePhysicalConnectionLOARequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "CompletePhysicalConnectionLOA")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CompletePhysicalConnectionLOARequest::~CompletePhysicalConnectionLOARequest()
-{}
-
-std::string CompletePhysicalConnectionLOARequest::getLineCode()const
-{
-	return lineCode_;
+ */
+
+#include <alibabacloud/vpc/model/CompletePhysicalConnectionLOARequest.h>
+
+using AlibabaCloud::Vpc::Model::CompletePhysicalConnectionLOARequest;
+
+CompletePhysicalConnectionLOARequest::CompletePhysicalConnectionLOARequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CompletePhysicalConnectionLOA") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CompletePhysicalConnectionLOARequest::setLineCode(const std::string& lineCode)
-{
-	lineCode_ = lineCode;
-	setParameter("LineCode", lineCode);
+CompletePhysicalConnectionLOARequest::~CompletePhysicalConnectionLOARequest() {}
+
+std::string CompletePhysicalConnectionLOARequest::getLineCode() const {
+  return lineCode_;
 }
 
-long CompletePhysicalConnectionLOARequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+void CompletePhysicalConnectionLOARequest::setLineCode(const std::string &lineCode) {
+  lineCode_ = lineCode;
+  setParameter(std::string("LineCode"), lineCode);
 }
 
-void CompletePhysicalConnectionLOARequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+long CompletePhysicalConnectionLOARequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string CompletePhysicalConnectionLOARequest::getClientToken()const
-{
-	return clientToken_;
+void CompletePhysicalConnectionLOARequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void CompletePhysicalConnectionLOARequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string CompletePhysicalConnectionLOARequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string CompletePhysicalConnectionLOARequest::getRegionId()const
-{
-	return regionId_;
+void CompletePhysicalConnectionLOARequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void CompletePhysicalConnectionLOARequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string CompletePhysicalConnectionLOARequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string CompletePhysicalConnectionLOARequest::getLineLabel()const
-{
-	return lineLabel_;
+void CompletePhysicalConnectionLOARequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void CompletePhysicalConnectionLOARequest::setLineLabel(const std::string& lineLabel)
-{
-	lineLabel_ = lineLabel;
-	setParameter("LineLabel", lineLabel);
+std::string CompletePhysicalConnectionLOARequest::getLineLabel() const {
+  return lineLabel_;
 }
 
-std::string CompletePhysicalConnectionLOARequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void CompletePhysicalConnectionLOARequest::setLineLabel(const std::string &lineLabel) {
+  lineLabel_ = lineLabel;
+  setParameter(std::string("LineLabel"), lineLabel);
 }
 
-void CompletePhysicalConnectionLOARequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string CompletePhysicalConnectionLOARequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string CompletePhysicalConnectionLOARequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void CompletePhysicalConnectionLOARequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void CompletePhysicalConnectionLOARequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string CompletePhysicalConnectionLOARequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long CompletePhysicalConnectionLOARequest::getOwnerId()const
-{
-	return ownerId_;
+void CompletePhysicalConnectionLOARequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void CompletePhysicalConnectionLOARequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long CompletePhysicalConnectionLOARequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string CompletePhysicalConnectionLOARequest::getInstanceId()const
-{
-	return instanceId_;
+void CompletePhysicalConnectionLOARequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void CompletePhysicalConnectionLOARequest::setInstanceId(const std::string& instanceId)
-{
-	instanceId_ = instanceId;
-	setParameter("InstanceId", instanceId);
+std::string CompletePhysicalConnectionLOARequest::getInstanceId() const {
+  return instanceId_;
+}
+
+void CompletePhysicalConnectionLOARequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setParameter(std::string("InstanceId"), instanceId);
 }
 

vpc/src/model/ConfirmPhysicalConnectionRequest.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/vpc/model/ConfirmPhysicalConnectionRequest.h>
-
-using AlibabaCloud::Vpc::Model::ConfirmPhysicalConnectionRequest;
-
-ConfirmPhysicalConnectionRequest::ConfirmPhysicalConnectionRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "ConfirmPhysicalConnection")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-ConfirmPhysicalConnectionRequest::~ConfirmPhysicalConnectionRequest()
-{}
-
-long ConfirmPhysicalConnectionRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/ConfirmPhysicalConnectionRequest.h>
+
+using AlibabaCloud::Vpc::Model::ConfirmPhysicalConnectionRequest;
+
+ConfirmPhysicalConnectionRequest::ConfirmPhysicalConnectionRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "ConfirmPhysicalConnection") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void ConfirmPhysicalConnectionRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+ConfirmPhysicalConnectionRequest::~ConfirmPhysicalConnectionRequest() {}
+
+long ConfirmPhysicalConnectionRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string ConfirmPhysicalConnectionRequest::getClientToken()const
-{
-	return clientToken_;
+void ConfirmPhysicalConnectionRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void ConfirmPhysicalConnectionRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string ConfirmPhysicalConnectionRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string ConfirmPhysicalConnectionRequest::getRegionId()const
-{
-	return regionId_;
+void ConfirmPhysicalConnectionRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void ConfirmPhysicalConnectionRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string ConfirmPhysicalConnectionRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string ConfirmPhysicalConnectionRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void ConfirmPhysicalConnectionRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void ConfirmPhysicalConnectionRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string ConfirmPhysicalConnectionRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string ConfirmPhysicalConnectionRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void ConfirmPhysicalConnectionRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void ConfirmPhysicalConnectionRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string ConfirmPhysicalConnectionRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long ConfirmPhysicalConnectionRequest::getOwnerId()const
-{
-	return ownerId_;
+void ConfirmPhysicalConnectionRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void ConfirmPhysicalConnectionRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long ConfirmPhysicalConnectionRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string ConfirmPhysicalConnectionRequest::getPhysicalConnectionId()const
-{
-	return physicalConnectionId_;
+void ConfirmPhysicalConnectionRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void ConfirmPhysicalConnectionRequest::setPhysicalConnectionId(const std::string& physicalConnectionId)
-{
-	physicalConnectionId_ = physicalConnectionId;
-	setParameter("PhysicalConnectionId", physicalConnectionId);
+std::string ConfirmPhysicalConnectionRequest::getPhysicalConnectionId() const {
+  return physicalConnectionId_;
+}
+
+void ConfirmPhysicalConnectionRequest::setPhysicalConnectionId(const std::string &physicalConnectionId) {
+  physicalConnectionId_ = physicalConnectionId;
+  setParameter(std::string("PhysicalConnectionId"), physicalConnectionId);
 }
 

vpc/src/model/ConnectRouterInterfaceRequest.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/vpc/model/ConnectRouterInterfaceRequest.h>
-
-using AlibabaCloud::Vpc::Model::ConnectRouterInterfaceRequest;
-
-ConnectRouterInterfaceRequest::ConnectRouterInterfaceRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "ConnectRouterInterface")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-ConnectRouterInterfaceRequest::~ConnectRouterInterfaceRequest()
-{}
-
-long ConnectRouterInterfaceRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/ConnectRouterInterfaceRequest.h>
+
+using AlibabaCloud::Vpc::Model::ConnectRouterInterfaceRequest;
+
+ConnectRouterInterfaceRequest::ConnectRouterInterfaceRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "ConnectRouterInterface") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void ConnectRouterInterfaceRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+ConnectRouterInterfaceRequest::~ConnectRouterInterfaceRequest() {}
+
+long ConnectRouterInterfaceRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string ConnectRouterInterfaceRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void ConnectRouterInterfaceRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void ConnectRouterInterfaceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string ConnectRouterInterfaceRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-long ConnectRouterInterfaceRequest::getOwnerId()const
-{
-	return ownerId_;
+void ConnectRouterInterfaceRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void ConnectRouterInterfaceRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long ConnectRouterInterfaceRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string ConnectRouterInterfaceRequest::getRouterInterfaceId()const
-{
-	return routerInterfaceId_;
+void ConnectRouterInterfaceRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void ConnectRouterInterfaceRequest::setRouterInterfaceId(const std::string& routerInterfaceId)
-{
-	routerInterfaceId_ = routerInterfaceId;
-	setParameter("RouterInterfaceId", routerInterfaceId);
+std::string ConnectRouterInterfaceRequest::getRouterInterfaceId() const {
+  return routerInterfaceId_;
 }
 
-std::string ConnectRouterInterfaceRequest::getRegionId()const
-{
-	return regionId_;
+void ConnectRouterInterfaceRequest::setRouterInterfaceId(const std::string &routerInterfaceId) {
+  routerInterfaceId_ = routerInterfaceId;
+  setParameter(std::string("RouterInterfaceId"), routerInterfaceId);
 }
 
-void ConnectRouterInterfaceRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string ConnectRouterInterfaceRequest::getRegionId() const {
+  return regionId_;
+}
+
+void ConnectRouterInterfaceRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 

vpc/src/model/ConvertBandwidthPackageRequest.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/vpc/model/ConvertBandwidthPackageRequest.h>
-
-using AlibabaCloud::Vpc::Model::ConvertBandwidthPackageRequest;
-
-ConvertBandwidthPackageRequest::ConvertBandwidthPackageRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "ConvertBandwidthPackage")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-ConvertBandwidthPackageRequest::~ConvertBandwidthPackageRequest()
-{}
-
-long ConvertBandwidthPackageRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/ConvertBandwidthPackageRequest.h>
+
+using AlibabaCloud::Vpc::Model::ConvertBandwidthPackageRequest;
+
+ConvertBandwidthPackageRequest::ConvertBandwidthPackageRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "ConvertBandwidthPackage") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void ConvertBandwidthPackageRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+ConvertBandwidthPackageRequest::~ConvertBandwidthPackageRequest() {}
+
+long ConvertBandwidthPackageRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string ConvertBandwidthPackageRequest::getClientToken()const
-{
-	return clientToken_;
+void ConvertBandwidthPackageRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void ConvertBandwidthPackageRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string ConvertBandwidthPackageRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string ConvertBandwidthPackageRequest::getRegionId()const
-{
-	return regionId_;
+void ConvertBandwidthPackageRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void ConvertBandwidthPackageRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string ConvertBandwidthPackageRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string ConvertBandwidthPackageRequest::getBandwidthPackageId()const
-{
-	return bandwidthPackageId_;
+void ConvertBandwidthPackageRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void ConvertBandwidthPackageRequest::setBandwidthPackageId(const std::string& bandwidthPackageId)
-{
-	bandwidthPackageId_ = bandwidthPackageId;
-	setParameter("BandwidthPackageId", bandwidthPackageId);
+std::string ConvertBandwidthPackageRequest::getBandwidthPackageId() const {
+  return bandwidthPackageId_;
 }
 
-std::string ConvertBandwidthPackageRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void ConvertBandwidthPackageRequest::setBandwidthPackageId(const std::string &bandwidthPackageId) {
+  bandwidthPackageId_ = bandwidthPackageId;
+  setParameter(std::string("BandwidthPackageId"), bandwidthPackageId);
 }
 
-void ConvertBandwidthPackageRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string ConvertBandwidthPackageRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-long ConvertBandwidthPackageRequest::getOwnerId()const
-{
-	return ownerId_;
+void ConvertBandwidthPackageRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void ConvertBandwidthPackageRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long ConvertBandwidthPackageRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void ConvertBandwidthPackageRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 

vpc/src/model/CopyNetworkAclEntriesRequest.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/vpc/model/CopyNetworkAclEntriesRequest.h>
-
-using AlibabaCloud::Vpc::Model::CopyNetworkAclEntriesRequest;
-
-CopyNetworkAclEntriesRequest::CopyNetworkAclEntriesRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "CopyNetworkAclEntries")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CopyNetworkAclEntriesRequest::~CopyNetworkAclEntriesRequest()
-{}
-
-long CopyNetworkAclEntriesRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/CopyNetworkAclEntriesRequest.h>
+
+using AlibabaCloud::Vpc::Model::CopyNetworkAclEntriesRequest;
+
+CopyNetworkAclEntriesRequest::CopyNetworkAclEntriesRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CopyNetworkAclEntries") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CopyNetworkAclEntriesRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+CopyNetworkAclEntriesRequest::~CopyNetworkAclEntriesRequest() {}
+
+long CopyNetworkAclEntriesRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string CopyNetworkAclEntriesRequest::getClientToken()const
-{
-	return clientToken_;
+void CopyNetworkAclEntriesRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void CopyNetworkAclEntriesRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string CopyNetworkAclEntriesRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string CopyNetworkAclEntriesRequest::getRegionId()const
-{
-	return regionId_;
+void CopyNetworkAclEntriesRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void CopyNetworkAclEntriesRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string CopyNetworkAclEntriesRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string CopyNetworkAclEntriesRequest::getNetworkAclId()const
-{
-	return networkAclId_;
+void CopyNetworkAclEntriesRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void CopyNetworkAclEntriesRequest::setNetworkAclId(const std::string& networkAclId)
-{
-	networkAclId_ = networkAclId;
-	setParameter("NetworkAclId", networkAclId);
+std::string CopyNetworkAclEntriesRequest::getNetworkAclId() const {
+  return networkAclId_;
 }
 
-std::string CopyNetworkAclEntriesRequest::getSourceNetworkAclId()const
-{
-	return sourceNetworkAclId_;
+void CopyNetworkAclEntriesRequest::setNetworkAclId(const std::string &networkAclId) {
+  networkAclId_ = networkAclId;
+  setParameter(std::string("NetworkAclId"), networkAclId);
 }
 
-void CopyNetworkAclEntriesRequest::setSourceNetworkAclId(const std::string& sourceNetworkAclId)
-{
-	sourceNetworkAclId_ = sourceNetworkAclId;
-	setParameter("SourceNetworkAclId", sourceNetworkAclId);
+std::string CopyNetworkAclEntriesRequest::getSourceNetworkAclId() const {
+  return sourceNetworkAclId_;
 }
 
-std::string CopyNetworkAclEntriesRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void CopyNetworkAclEntriesRequest::setSourceNetworkAclId(const std::string &sourceNetworkAclId) {
+  sourceNetworkAclId_ = sourceNetworkAclId;
+  setParameter(std::string("SourceNetworkAclId"), sourceNetworkAclId);
 }
 
-void CopyNetworkAclEntriesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string CopyNetworkAclEntriesRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-long CopyNetworkAclEntriesRequest::getOwnerId()const
-{
-	return ownerId_;
+void CopyNetworkAclEntriesRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void CopyNetworkAclEntriesRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long CopyNetworkAclEntriesRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CopyNetworkAclEntriesRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 

vpc/src/model/CreateBgpGroupRequest.cc

@@ -1,183 +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/vpc/model/CreateBgpGroupRequest.h>
-
-using AlibabaCloud::Vpc::Model::CreateBgpGroupRequest;
-
-CreateBgpGroupRequest::CreateBgpGroupRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "CreateBgpGroup")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateBgpGroupRequest::~CreateBgpGroupRequest()
-{}
-
-std::string CreateBgpGroupRequest::getAuthKey()const
-{
-	return authKey_;
+ */
+
+#include <alibabacloud/vpc/model/CreateBgpGroupRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreateBgpGroupRequest;
+
+CreateBgpGroupRequest::CreateBgpGroupRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CreateBgpGroup") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CreateBgpGroupRequest::setAuthKey(const std::string& authKey)
-{
-	authKey_ = authKey;
-	setParameter("AuthKey", authKey);
+CreateBgpGroupRequest::~CreateBgpGroupRequest() {}
+
+std::string CreateBgpGroupRequest::getAuthKey() const {
+  return authKey_;
 }
 
-long CreateBgpGroupRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+void CreateBgpGroupRequest::setAuthKey(const std::string &authKey) {
+  authKey_ = authKey;
+  setParameter(std::string("AuthKey"), authKey);
 }
 
-void CreateBgpGroupRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+long CreateBgpGroupRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string CreateBgpGroupRequest::getClientToken()const
-{
-	return clientToken_;
+void CreateBgpGroupRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void CreateBgpGroupRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string CreateBgpGroupRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string CreateBgpGroupRequest::getDescription()const
-{
-	return description_;
+void CreateBgpGroupRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void CreateBgpGroupRequest::setDescription(const std::string& description)
-{
-	description_ = description;
-	setParameter("Description", description);
+std::string CreateBgpGroupRequest::getDescription() const {
+  return description_;
 }
 
-long CreateBgpGroupRequest::getPeerAsn()const
-{
-	return peerAsn_;
+void CreateBgpGroupRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
 }
 
-void CreateBgpGroupRequest::setPeerAsn(long peerAsn)
-{
-	peerAsn_ = peerAsn;
-	setParameter("PeerAsn", std::to_string(peerAsn));
+long CreateBgpGroupRequest::getPeerAsn() const {
+  return peerAsn_;
 }
 
-bool CreateBgpGroupRequest::getIsFakeAsn()const
-{
-	return isFakeAsn_;
+void CreateBgpGroupRequest::setPeerAsn(long peerAsn) {
+  peerAsn_ = peerAsn;
+  setParameter(std::string("PeerAsn"), std::to_string(peerAsn));
 }
 
-void CreateBgpGroupRequest::setIsFakeAsn(bool isFakeAsn)
-{
-	isFakeAsn_ = isFakeAsn;
-	setParameter("IsFakeAsn", isFakeAsn ? "true" : "false");
+bool CreateBgpGroupRequest::getIsFakeAsn() const {
+  return isFakeAsn_;
 }
 
-std::string CreateBgpGroupRequest::getRegionId()const
-{
-	return regionId_;
+void CreateBgpGroupRequest::setIsFakeAsn(bool isFakeAsn) {
+  isFakeAsn_ = isFakeAsn;
+  setParameter(std::string("IsFakeAsn"), isFakeAsn ? "true" : "false");
 }
 
-void CreateBgpGroupRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string CreateBgpGroupRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string CreateBgpGroupRequest::getIpVersion()const
-{
-	return ipVersion_;
+void CreateBgpGroupRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void CreateBgpGroupRequest::setIpVersion(const std::string& ipVersion)
-{
-	ipVersion_ = ipVersion;
-	setParameter("IpVersion", ipVersion);
+std::string CreateBgpGroupRequest::getIpVersion() const {
+  return ipVersion_;
 }
 
-std::string CreateBgpGroupRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void CreateBgpGroupRequest::setIpVersion(const std::string &ipVersion) {
+  ipVersion_ = ipVersion;
+  setParameter(std::string("IpVersion"), ipVersion);
 }
 
-void CreateBgpGroupRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string CreateBgpGroupRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string CreateBgpGroupRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void CreateBgpGroupRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void CreateBgpGroupRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string CreateBgpGroupRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long CreateBgpGroupRequest::getOwnerId()const
-{
-	return ownerId_;
+void CreateBgpGroupRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void CreateBgpGroupRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+int CreateBgpGroupRequest::getRouteQuota() const {
+  return routeQuota_;
 }
 
-std::string CreateBgpGroupRequest::getRouterId()const
-{
-	return routerId_;
+void CreateBgpGroupRequest::setRouteQuota(int routeQuota) {
+  routeQuota_ = routeQuota;
+  setParameter(std::string("RouteQuota"), std::to_string(routeQuota));
 }
 
-void CreateBgpGroupRequest::setRouterId(const std::string& routerId)
-{
-	routerId_ = routerId;
-	setParameter("RouterId", routerId);
+long CreateBgpGroupRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string CreateBgpGroupRequest::getName()const
-{
-	return name_;
+void CreateBgpGroupRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void CreateBgpGroupRequest::setName(const std::string& name)
-{
-	name_ = name;
-	setParameter("Name", name);
+int CreateBgpGroupRequest::getRouteUsageAlarmThreshold() const {
+  return routeUsageAlarmThreshold_;
 }
 
-long CreateBgpGroupRequest::getLocalAsn()const
-{
-	return localAsn_;
+void CreateBgpGroupRequest::setRouteUsageAlarmThreshold(int routeUsageAlarmThreshold) {
+  routeUsageAlarmThreshold_ = routeUsageAlarmThreshold;
+  setParameter(std::string("RouteUsageAlarmThreshold"), std::to_string(routeUsageAlarmThreshold));
 }
 
-void CreateBgpGroupRequest::setLocalAsn(long localAsn)
-{
-	localAsn_ = localAsn;
-	setParameter("LocalAsn", std::to_string(localAsn));
+std::string CreateBgpGroupRequest::getRouterId() const {
+  return routerId_;
+}
+
+void CreateBgpGroupRequest::setRouterId(const std::string &routerId) {
+  routerId_ = routerId;
+  setParameter(std::string("RouterId"), routerId);
+}
+
+std::string CreateBgpGroupRequest::getName() const {
+  return name_;
+}
+
+void CreateBgpGroupRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
+}
+
+long CreateBgpGroupRequest::getLocalAsn() const {
+  return localAsn_;
+}
+
+void CreateBgpGroupRequest::setLocalAsn(long localAsn) {
+  localAsn_ = localAsn;
+  setParameter(std::string("LocalAsn"), std::to_string(localAsn));
 }
 

vpc/src/model/CreateBgpPeerRequest.cc

@@ -1,150 +1,126 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
-
-#include <alibabacloud/vpc/model/CreateBgpPeerRequest.h>
-
-using AlibabaCloud::Vpc::Model::CreateBgpPeerRequest;
-
-CreateBgpPeerRequest::CreateBgpPeerRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "CreateBgpPeer")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateBgpPeerRequest::~CreateBgpPeerRequest()
-{}
-
-long CreateBgpPeerRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/CreateBgpPeerRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreateBgpPeerRequest;
+
+CreateBgpPeerRequest::CreateBgpPeerRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CreateBgpPeer") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CreateBgpPeerRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+CreateBgpPeerRequest::~CreateBgpPeerRequest() {}
+
+long CreateBgpPeerRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string CreateBgpPeerRequest::getClientToken()const
-{
-	return clientToken_;
+void CreateBgpPeerRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void CreateBgpPeerRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string CreateBgpPeerRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string CreateBgpPeerRequest::getBgpGroupId()const
-{
-	return bgpGroupId_;
+void CreateBgpPeerRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void CreateBgpPeerRequest::setBgpGroupId(const std::string& bgpGroupId)
-{
-	bgpGroupId_ = bgpGroupId;
-	setParameter("BgpGroupId", bgpGroupId);
+std::string CreateBgpPeerRequest::getBgpGroupId() const {
+  return bgpGroupId_;
 }
 
-std::string CreateBgpPeerRequest::getPeerIpAddress()const
-{
-	return peerIpAddress_;
+void CreateBgpPeerRequest::setBgpGroupId(const std::string &bgpGroupId) {
+  bgpGroupId_ = bgpGroupId;
+  setParameter(std::string("BgpGroupId"), bgpGroupId);
 }
 
-void CreateBgpPeerRequest::setPeerIpAddress(const std::string& peerIpAddress)
-{
-	peerIpAddress_ = peerIpAddress;
-	setParameter("PeerIpAddress", peerIpAddress);
+std::string CreateBgpPeerRequest::getPeerIpAddress() const {
+  return peerIpAddress_;
 }
 
-int CreateBgpPeerRequest::getBfdMultiHop()const
-{
-	return bfdMultiHop_;
+void CreateBgpPeerRequest::setPeerIpAddress(const std::string &peerIpAddress) {
+  peerIpAddress_ = peerIpAddress;
+  setParameter(std::string("PeerIpAddress"), peerIpAddress);
 }
 
-void CreateBgpPeerRequest::setBfdMultiHop(int bfdMultiHop)
-{
-	bfdMultiHop_ = bfdMultiHop;
-	setParameter("BfdMultiHop", std::to_string(bfdMultiHop));
+int CreateBgpPeerRequest::getBfdMultiHop() const {
+  return bfdMultiHop_;
 }
 
-std::string CreateBgpPeerRequest::getRegionId()const
-{
-	return regionId_;
+void CreateBgpPeerRequest::setBfdMultiHop(int bfdMultiHop) {
+  bfdMultiHop_ = bfdMultiHop;
+  setParameter(std::string("BfdMultiHop"), std::to_string(bfdMultiHop));
 }
 
-void CreateBgpPeerRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string CreateBgpPeerRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string CreateBgpPeerRequest::getIpVersion()const
-{
-	return ipVersion_;
+void CreateBgpPeerRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void CreateBgpPeerRequest::setIpVersion(const std::string& ipVersion)
-{
-	ipVersion_ = ipVersion;
-	setParameter("IpVersion", ipVersion);
+std::string CreateBgpPeerRequest::getIpVersion() const {
+  return ipVersion_;
 }
 
-bool CreateBgpPeerRequest::getEnableBfd()const
-{
-	return enableBfd_;
+void CreateBgpPeerRequest::setIpVersion(const std::string &ipVersion) {
+  ipVersion_ = ipVersion;
+  setParameter(std::string("IpVersion"), ipVersion);
 }
 
-void CreateBgpPeerRequest::setEnableBfd(bool enableBfd)
-{
-	enableBfd_ = enableBfd;
-	setParameter("EnableBfd", enableBfd ? "true" : "false");
+bool CreateBgpPeerRequest::getEnableBfd() const {
+  return enableBfd_;
 }
 
-std::string CreateBgpPeerRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void CreateBgpPeerRequest::setEnableBfd(bool enableBfd) {
+  enableBfd_ = enableBfd;
+  setParameter(std::string("EnableBfd"), enableBfd ? "true" : "false");
 }
 
-void CreateBgpPeerRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string CreateBgpPeerRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string CreateBgpPeerRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void CreateBgpPeerRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void CreateBgpPeerRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string CreateBgpPeerRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long CreateBgpPeerRequest::getOwnerId()const
-{
-	return ownerId_;
+void CreateBgpPeerRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void CreateBgpPeerRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long CreateBgpPeerRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CreateBgpPeerRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 

vpc/src/model/CreateCommonBandwidthPackageRequest.cc

@@ -1,183 +1,161 @@
 /*
  * 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/vpc/model/CreateCommonBandwidthPackageRequest.h>
-
-using AlibabaCloud::Vpc::Model::CreateCommonBandwidthPackageRequest;
-
-CreateCommonBandwidthPackageRequest::CreateCommonBandwidthPackageRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "CreateCommonBandwidthPackage")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateCommonBandwidthPackageRequest::~CreateCommonBandwidthPackageRequest()
-{}
-
-long CreateCommonBandwidthPackageRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/CreateCommonBandwidthPackageRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreateCommonBandwidthPackageRequest;
+
+CreateCommonBandwidthPackageRequest::CreateCommonBandwidthPackageRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CreateCommonBandwidthPackage") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CreateCommonBandwidthPackageRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+CreateCommonBandwidthPackageRequest::~CreateCommonBandwidthPackageRequest() {}
+
+long CreateCommonBandwidthPackageRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string CreateCommonBandwidthPackageRequest::getClientToken()const
-{
-	return clientToken_;
+void CreateCommonBandwidthPackageRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void CreateCommonBandwidthPackageRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string CreateCommonBandwidthPackageRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string CreateCommonBandwidthPackageRequest::getISP()const
-{
-	return iSP_;
+void CreateCommonBandwidthPackageRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void CreateCommonBandwidthPackageRequest::setISP(const std::string& iSP)
-{
-	iSP_ = iSP;
-	setParameter("ISP", iSP);
+std::string CreateCommonBandwidthPackageRequest::getISP() const {
+  return iSP_;
 }
 
-std::string CreateCommonBandwidthPackageRequest::getDescription()const
-{
-	return description_;
+void CreateCommonBandwidthPackageRequest::setISP(const std::string &iSP) {
+  iSP_ = iSP;
+  setParameter(std::string("ISP"), iSP);
 }
 
-void CreateCommonBandwidthPackageRequest::setDescription(const std::string& description)
-{
-	description_ = description;
-	setParameter("Description", description);
+std::string CreateCommonBandwidthPackageRequest::getDescription() const {
+  return description_;
 }
 
-std::string CreateCommonBandwidthPackageRequest::getResourceGroupId()const
-{
-	return resourceGroupId_;
+void CreateCommonBandwidthPackageRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
 }
 
-void CreateCommonBandwidthPackageRequest::setResourceGroupId(const std::string& resourceGroupId)
-{
-	resourceGroupId_ = resourceGroupId;
-	setParameter("ResourceGroupId", resourceGroupId);
+std::string CreateCommonBandwidthPackageRequest::getResourceGroupId() const {
+  return resourceGroupId_;
 }
 
-std::string CreateCommonBandwidthPackageRequest::getRegionId()const
-{
-	return regionId_;
+void CreateCommonBandwidthPackageRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
 }
 
-void CreateCommonBandwidthPackageRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string CreateCommonBandwidthPackageRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string CreateCommonBandwidthPackageRequest::getZone()const
-{
-	return zone_;
+void CreateCommonBandwidthPackageRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void CreateCommonBandwidthPackageRequest::setZone(const std::string& zone)
-{
-	zone_ = zone;
-	setParameter("Zone", zone);
+std::string CreateCommonBandwidthPackageRequest::getZone() const {
+  return zone_;
 }
 
-std::string CreateCommonBandwidthPackageRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void CreateCommonBandwidthPackageRequest::setZone(const std::string &zone) {
+  zone_ = zone;
+  setParameter(std::string("Zone"), zone);
 }
 
-void CreateCommonBandwidthPackageRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string CreateCommonBandwidthPackageRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-int CreateCommonBandwidthPackageRequest::getBandwidth()const
-{
-	return bandwidth_;
+void CreateCommonBandwidthPackageRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void CreateCommonBandwidthPackageRequest::setBandwidth(int bandwidth)
-{
-	bandwidth_ = bandwidth;
-	setParameter("Bandwidth", std::to_string(bandwidth));
+int CreateCommonBandwidthPackageRequest::getBandwidth() const {
+  return bandwidth_;
 }
 
-std::string CreateCommonBandwidthPackageRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void CreateCommonBandwidthPackageRequest::setBandwidth(int bandwidth) {
+  bandwidth_ = bandwidth;
+  setParameter(std::string("Bandwidth"), std::to_string(bandwidth));
 }
 
-void CreateCommonBandwidthPackageRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string CreateCommonBandwidthPackageRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long CreateCommonBandwidthPackageRequest::getOwnerId()const
-{
-	return ownerId_;
+void CreateCommonBandwidthPackageRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void CreateCommonBandwidthPackageRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long CreateCommonBandwidthPackageRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string CreateCommonBandwidthPackageRequest::getInternetChargeType()const
-{
-	return internetChargeType_;
+void CreateCommonBandwidthPackageRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void CreateCommonBandwidthPackageRequest::setInternetChargeType(const std::string& internetChargeType)
-{
-	internetChargeType_ = internetChargeType;
-	setParameter("InternetChargeType", internetChargeType);
+std::string CreateCommonBandwidthPackageRequest::getInternetChargeType() const {
+  return internetChargeType_;
 }
 
-std::string CreateCommonBandwidthPackageRequest::getName()const
-{
-	return name_;
+void CreateCommonBandwidthPackageRequest::setInternetChargeType(const std::string &internetChargeType) {
+  internetChargeType_ = internetChargeType;
+  setParameter(std::string("InternetChargeType"), internetChargeType);
 }
 
-void CreateCommonBandwidthPackageRequest::setName(const std::string& name)
-{
-	name_ = name;
-	setParameter("Name", name);
+std::string CreateCommonBandwidthPackageRequest::getName() const {
+  return name_;
 }
 
-int CreateCommonBandwidthPackageRequest::getRatio()const
-{
-	return ratio_;
+void CreateCommonBandwidthPackageRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
 }
 
-void CreateCommonBandwidthPackageRequest::setRatio(int ratio)
-{
-	ratio_ = ratio;
-	setParameter("Ratio", std::to_string(ratio));
+std::vector<std::string> CreateCommonBandwidthPackageRequest::getSecurityProtectionTypes() const {
+  return securityProtectionTypes_;
+}
+
+void CreateCommonBandwidthPackageRequest::setSecurityProtectionTypes(const std::vector<std::string> &securityProtectionTypes) {
+  securityProtectionTypes_ = securityProtectionTypes;
+}
+
+int CreateCommonBandwidthPackageRequest::getRatio() const {
+  return ratio_;
+}
+
+void CreateCommonBandwidthPackageRequest::setRatio(int ratio) {
+  ratio_ = ratio;
+  setParameter(std::string("Ratio"), std::to_string(ratio));
 }
 

vpc/src/model/CreateCustomerGatewayRequest.cc

@@ -1,139 +1,140 @@
 /*
  * 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/vpc/model/CreateCustomerGatewayRequest.h>
-
-using AlibabaCloud::Vpc::Model::CreateCustomerGatewayRequest;
-
-CreateCustomerGatewayRequest::CreateCustomerGatewayRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "CreateCustomerGateway")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateCustomerGatewayRequest::~CreateCustomerGatewayRequest()
-{}
-
-std::string CreateCustomerGatewayRequest::getIpAddress()const
-{
-	return ipAddress_;
+ */
+
+#include <alibabacloud/vpc/model/CreateCustomerGatewayRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreateCustomerGatewayRequest;
+
+CreateCustomerGatewayRequest::CreateCustomerGatewayRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CreateCustomerGateway") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CreateCustomerGatewayRequest::setIpAddress(const std::string& ipAddress)
-{
-	ipAddress_ = ipAddress;
-	setParameter("IpAddress", ipAddress);
+CreateCustomerGatewayRequest::~CreateCustomerGatewayRequest() {}
+
+std::string CreateCustomerGatewayRequest::getIpAddress() const {
+  return ipAddress_;
 }
 
-long CreateCustomerGatewayRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+void CreateCustomerGatewayRequest::setIpAddress(const std::string &ipAddress) {
+  ipAddress_ = ipAddress;
+  setParameter(std::string("IpAddress"), ipAddress);
 }
 
-void CreateCustomerGatewayRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+std::string CreateCustomerGatewayRequest::getAuthKey() const {
+  return authKey_;
 }
 
-std::string CreateCustomerGatewayRequest::getClientToken()const
-{
-	return clientToken_;
+void CreateCustomerGatewayRequest::setAuthKey(const std::string &authKey) {
+  authKey_ = authKey;
+  setParameter(std::string("AuthKey"), authKey);
 }
 
-void CreateCustomerGatewayRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+long CreateCustomerGatewayRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string CreateCustomerGatewayRequest::getDescription()const
-{
-	return description_;
+void CreateCustomerGatewayRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void CreateCustomerGatewayRequest::setDescription(const std::string& description)
-{
-	description_ = description;
-	setParameter("Description", description);
+std::string CreateCustomerGatewayRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string CreateCustomerGatewayRequest::getRegionId()const
-{
-	return regionId_;
+void CreateCustomerGatewayRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void CreateCustomerGatewayRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string CreateCustomerGatewayRequest::getDescription() const {
+  return description_;
 }
 
-std::string CreateCustomerGatewayRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void CreateCustomerGatewayRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
 }
 
-void CreateCustomerGatewayRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string CreateCustomerGatewayRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string CreateCustomerGatewayRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void CreateCustomerGatewayRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void CreateCustomerGatewayRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string CreateCustomerGatewayRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-long CreateCustomerGatewayRequest::getOwnerId()const
-{
-	return ownerId_;
+void CreateCustomerGatewayRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void CreateCustomerGatewayRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+std::string CreateCustomerGatewayRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-std::string CreateCustomerGatewayRequest::getName()const
-{
-	return name_;
+void CreateCustomerGatewayRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void CreateCustomerGatewayRequest::setName(const std::string& name)
-{
-	name_ = name;
-	setParameter("Name", name);
+long CreateCustomerGatewayRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string CreateCustomerGatewayRequest::getAsn()const
-{
-	return asn_;
+void CreateCustomerGatewayRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void CreateCustomerGatewayRequest::setAsn(const std::string& asn)
-{
-	asn_ = asn;
-	setParameter("Asn", asn);
+std::vector<CreateCustomerGatewayRequest::Tags> CreateCustomerGatewayRequest::getTags() const {
+  return tags_;
+}
+
+void CreateCustomerGatewayRequest::setTags(const std::vector<CreateCustomerGatewayRequest::Tags> &tags) {
+  tags_ = tags;
+  for(int dep1 = 0; dep1 != tags.size(); dep1++) {
+  auto tagsObj = tags.at(dep1);
+  std::string tagsObjStr = std::string("Tags") + "." + std::to_string(dep1 + 1);
+    setParameter(tagsObjStr + ".Value", tagsObj.value);
+    setParameter(tagsObjStr + ".Key", tagsObj.key);
+  }
+}
+
+std::string CreateCustomerGatewayRequest::getName() const {
+  return name_;
+}
+
+void CreateCustomerGatewayRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
+}
+
+std::string CreateCustomerGatewayRequest::getAsn() const {
+  return asn_;
+}
+
+void CreateCustomerGatewayRequest::setAsn(const std::string &asn) {
+  asn_ = asn;
+  setParameter(std::string("Asn"), asn);
 }
 

vpc/src/model/CreateCustomerGatewayResult.cc

@@ -39,16 +39,16 @@ void CreateCustomerGatewayResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["CustomerGatewayId"].isNull())
-		customerGatewayId_ = value["CustomerGatewayId"].asString();
 	if(!value["IpAddress"].isNull())
 		ipAddress_ = value["IpAddress"].asString();
-	if(!value["Name"].isNull())
-		name_ = value["Name"].asString();
 	if(!value["Description"].isNull())
 		description_ = value["Description"].asString();
+	if(!value["CustomerGatewayId"].isNull())
+		customerGatewayId_ = value["CustomerGatewayId"].asString();
 	if(!value["CreateTime"].isNull())
 		createTime_ = std::stol(value["CreateTime"].asString());
+	if(!value["Name"].isNull())
+		name_ = value["Name"].asString();
 
 }
 

vpc/src/model/CreateDhcpOptionsSetRequest.cc

@@ -1,172 +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/vpc/model/CreateDhcpOptionsSetRequest.h>
-
-using AlibabaCloud::Vpc::Model::CreateDhcpOptionsSetRequest;
-
-CreateDhcpOptionsSetRequest::CreateDhcpOptionsSetRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "CreateDhcpOptionsSet")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateDhcpOptionsSetRequest::~CreateDhcpOptionsSetRequest()
-{}
-
-std::string CreateDhcpOptionsSetRequest::getBootFileName()const
-{
-	return bootFileName_;
+ */
+
+#include <alibabacloud/vpc/model/CreateDhcpOptionsSetRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreateDhcpOptionsSetRequest;
+
+CreateDhcpOptionsSetRequest::CreateDhcpOptionsSetRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CreateDhcpOptionsSet") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CreateDhcpOptionsSetRequest::setBootFileName(const std::string& bootFileName)
-{
-	bootFileName_ = bootFileName;
-	setParameter("BootFileName", bootFileName);
+CreateDhcpOptionsSetRequest::~CreateDhcpOptionsSetRequest() {}
+
+std::string CreateDhcpOptionsSetRequest::getBootFileName() const {
+  return bootFileName_;
 }
 
-long CreateDhcpOptionsSetRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+void CreateDhcpOptionsSetRequest::setBootFileName(const std::string &bootFileName) {
+  bootFileName_ = bootFileName;
+  setParameter(std::string("BootFileName"), bootFileName);
 }
 
-void CreateDhcpOptionsSetRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+long CreateDhcpOptionsSetRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string CreateDhcpOptionsSetRequest::getClientToken()const
-{
-	return clientToken_;
+void CreateDhcpOptionsSetRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void CreateDhcpOptionsSetRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string CreateDhcpOptionsSetRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string CreateDhcpOptionsSetRequest::getTFTPServerName()const
-{
-	return tFTPServerName_;
+void CreateDhcpOptionsSetRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void CreateDhcpOptionsSetRequest::setTFTPServerName(const std::string& tFTPServerName)
-{
-	tFTPServerName_ = tFTPServerName;
-	setParameter("TFTPServerName", tFTPServerName);
+std::string CreateDhcpOptionsSetRequest::getTFTPServerName() const {
+  return tFTPServerName_;
 }
 
-std::string CreateDhcpOptionsSetRequest::getRegionId()const
-{
-	return regionId_;
+void CreateDhcpOptionsSetRequest::setTFTPServerName(const std::string &tFTPServerName) {
+  tFTPServerName_ = tFTPServerName;
+  setParameter(std::string("TFTPServerName"), tFTPServerName);
 }
 
-void CreateDhcpOptionsSetRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string CreateDhcpOptionsSetRequest::getLeaseTime() const {
+  return leaseTime_;
 }
 
-std::string CreateDhcpOptionsSetRequest::getDomainNameServers()const
-{
-	return domainNameServers_;
+void CreateDhcpOptionsSetRequest::setLeaseTime(const std::string &leaseTime) {
+  leaseTime_ = leaseTime;
+  setParameter(std::string("LeaseTime"), leaseTime);
 }
 
-void CreateDhcpOptionsSetRequest::setDomainNameServers(const std::string& domainNameServers)
-{
-	domainNameServers_ = domainNameServers;
-	setParameter("DomainNameServers", domainNameServers);
+std::string CreateDhcpOptionsSetRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string CreateDhcpOptionsSetRequest::getDhcpOptionsSetDescription()const
-{
-	return dhcpOptionsSetDescription_;
+void CreateDhcpOptionsSetRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void CreateDhcpOptionsSetRequest::setDhcpOptionsSetDescription(const std::string& dhcpOptionsSetDescription)
-{
-	dhcpOptionsSetDescription_ = dhcpOptionsSetDescription;
-	setParameter("DhcpOptionsSetDescription", dhcpOptionsSetDescription);
+std::string CreateDhcpOptionsSetRequest::getDomainNameServers() const {
+  return domainNameServers_;
 }
 
-bool CreateDhcpOptionsSetRequest::getDryRun()const
-{
-	return dryRun_;
+void CreateDhcpOptionsSetRequest::setDomainNameServers(const std::string &domainNameServers) {
+  domainNameServers_ = domainNameServers;
+  setParameter(std::string("DomainNameServers"), domainNameServers);
 }
 
-void CreateDhcpOptionsSetRequest::setDryRun(bool dryRun)
-{
-	dryRun_ = dryRun;
-	setParameter("DryRun", dryRun ? "true" : "false");
+std::string CreateDhcpOptionsSetRequest::getDhcpOptionsSetDescription() const {
+  return dhcpOptionsSetDescription_;
 }
 
-std::string CreateDhcpOptionsSetRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void CreateDhcpOptionsSetRequest::setDhcpOptionsSetDescription(const std::string &dhcpOptionsSetDescription) {
+  dhcpOptionsSetDescription_ = dhcpOptionsSetDescription;
+  setParameter(std::string("DhcpOptionsSetDescription"), dhcpOptionsSetDescription);
 }
 
-void CreateDhcpOptionsSetRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+bool CreateDhcpOptionsSetRequest::getDryRun() const {
+  return dryRun_;
 }
 
-std::string CreateDhcpOptionsSetRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void CreateDhcpOptionsSetRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setParameter(std::string("DryRun"), dryRun ? "true" : "false");
 }
 
-void CreateDhcpOptionsSetRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string CreateDhcpOptionsSetRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string CreateDhcpOptionsSetRequest::getDomainName()const
-{
-	return domainName_;
+void CreateDhcpOptionsSetRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void CreateDhcpOptionsSetRequest::setDomainName(const std::string& domainName)
-{
-	domainName_ = domainName;
-	setParameter("DomainName", domainName);
+std::string CreateDhcpOptionsSetRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long CreateDhcpOptionsSetRequest::getOwnerId()const
-{
-	return ownerId_;
+void CreateDhcpOptionsSetRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void CreateDhcpOptionsSetRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+std::string CreateDhcpOptionsSetRequest::getDomainName() const {
+  return domainName_;
 }
 
-std::string CreateDhcpOptionsSetRequest::getDhcpOptionsSetName()const
-{
-	return dhcpOptionsSetName_;
+void CreateDhcpOptionsSetRequest::setDomainName(const std::string &domainName) {
+  domainName_ = domainName;
+  setParameter(std::string("DomainName"), domainName);
 }
 
-void CreateDhcpOptionsSetRequest::setDhcpOptionsSetName(const std::string& dhcpOptionsSetName)
-{
-	dhcpOptionsSetName_ = dhcpOptionsSetName;
-	setParameter("DhcpOptionsSetName", dhcpOptionsSetName);
+long CreateDhcpOptionsSetRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CreateDhcpOptionsSetRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string CreateDhcpOptionsSetRequest::getDhcpOptionsSetName() const {
+  return dhcpOptionsSetName_;
+}
+
+void CreateDhcpOptionsSetRequest::setDhcpOptionsSetName(const std::string &dhcpOptionsSetName) {
+  dhcpOptionsSetName_ = dhcpOptionsSetName;
+  setParameter(std::string("DhcpOptionsSetName"), dhcpOptionsSetName);
+}
+
+std::string CreateDhcpOptionsSetRequest::getIpv6LeaseTime() const {
+  return ipv6LeaseTime_;
+}
+
+void CreateDhcpOptionsSetRequest::setIpv6LeaseTime(const std::string &ipv6LeaseTime) {
+  ipv6LeaseTime_ = ipv6LeaseTime;
+  setParameter(std::string("Ipv6LeaseTime"), ipv6LeaseTime);
 }
 

vpc/src/model/CreateExpressCloudConnectionRequest.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/vpc/model/CreateExpressCloudConnectionRequest.h>
-
-using AlibabaCloud::Vpc::Model::CreateExpressCloudConnectionRequest;
-
-CreateExpressCloudConnectionRequest::CreateExpressCloudConnectionRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "CreateExpressCloudConnection")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateExpressCloudConnectionRequest::~CreateExpressCloudConnectionRequest()
-{}
-
-long CreateExpressCloudConnectionRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/CreateExpressCloudConnectionRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreateExpressCloudConnectionRequest;
+
+CreateExpressCloudConnectionRequest::CreateExpressCloudConnectionRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CreateExpressCloudConnection") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CreateExpressCloudConnectionRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+CreateExpressCloudConnectionRequest::~CreateExpressCloudConnectionRequest() {}
+
+long CreateExpressCloudConnectionRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string CreateExpressCloudConnectionRequest::getPortType()const
-{
-	return portType_;
+void CreateExpressCloudConnectionRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void CreateExpressCloudConnectionRequest::setPortType(const std::string& portType)
-{
-	portType_ = portType;
-	setParameter("PortType", portType);
+std::string CreateExpressCloudConnectionRequest::getPortType() const {
+  return portType_;
 }
 
-std::string CreateExpressCloudConnectionRequest::getDescription()const
-{
-	return description_;
+void CreateExpressCloudConnectionRequest::setPortType(const std::string &portType) {
+  portType_ = portType;
+  setParameter(std::string("PortType"), portType);
 }
 
-void CreateExpressCloudConnectionRequest::setDescription(const std::string& description)
-{
-	description_ = description;
-	setParameter("Description", description);
+std::string CreateExpressCloudConnectionRequest::getDescription() const {
+  return description_;
 }
 
-std::string CreateExpressCloudConnectionRequest::getRedundantEccId()const
-{
-	return redundantEccId_;
+void CreateExpressCloudConnectionRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
 }
 
-void CreateExpressCloudConnectionRequest::setRedundantEccId(const std::string& redundantEccId)
-{
-	redundantEccId_ = redundantEccId;
-	setParameter("RedundantEccId", redundantEccId);
+std::string CreateExpressCloudConnectionRequest::getRedundantEccId() const {
+  return redundantEccId_;
 }
 
-std::string CreateExpressCloudConnectionRequest::getRegionId()const
-{
-	return regionId_;
+void CreateExpressCloudConnectionRequest::setRedundantEccId(const std::string &redundantEccId) {
+  redundantEccId_ = redundantEccId;
+  setParameter(std::string("RedundantEccId"), redundantEccId);
 }
 
-void CreateExpressCloudConnectionRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string CreateExpressCloudConnectionRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string CreateExpressCloudConnectionRequest::getPeerLocation()const
-{
-	return peerLocation_;
+void CreateExpressCloudConnectionRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void CreateExpressCloudConnectionRequest::setPeerLocation(const std::string& peerLocation)
-{
-	peerLocation_ = peerLocation;
-	setParameter("PeerLocation", peerLocation);
+std::string CreateExpressCloudConnectionRequest::getPeerLocation() const {
+  return peerLocation_;
 }
 
-std::string CreateExpressCloudConnectionRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void CreateExpressCloudConnectionRequest::setPeerLocation(const std::string &peerLocation) {
+  peerLocation_ = peerLocation;
+  setParameter(std::string("PeerLocation"), peerLocation);
 }
 
-void CreateExpressCloudConnectionRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string CreateExpressCloudConnectionRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-int CreateExpressCloudConnectionRequest::getBandwidth()const
-{
-	return bandwidth_;
+void CreateExpressCloudConnectionRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void CreateExpressCloudConnectionRequest::setBandwidth(int bandwidth)
-{
-	bandwidth_ = bandwidth;
-	setParameter("Bandwidth", std::to_string(bandwidth));
+int CreateExpressCloudConnectionRequest::getBandwidth() const {
+  return bandwidth_;
 }
 
-std::string CreateExpressCloudConnectionRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void CreateExpressCloudConnectionRequest::setBandwidth(int bandwidth) {
+  bandwidth_ = bandwidth;
+  setParameter(std::string("Bandwidth"), std::to_string(bandwidth));
 }
 
-void CreateExpressCloudConnectionRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string CreateExpressCloudConnectionRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-std::string CreateExpressCloudConnectionRequest::getPeerCity()const
-{
-	return peerCity_;
+void CreateExpressCloudConnectionRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void CreateExpressCloudConnectionRequest::setPeerCity(const std::string& peerCity)
-{
-	peerCity_ = peerCity;
-	setParameter("PeerCity", peerCity);
+std::string CreateExpressCloudConnectionRequest::getPeerCity() const {
+  return peerCity_;
 }
 
-std::string CreateExpressCloudConnectionRequest::getIDCardNo()const
-{
-	return iDCardNo_;
+void CreateExpressCloudConnectionRequest::setPeerCity(const std::string &peerCity) {
+  peerCity_ = peerCity;
+  setParameter(std::string("PeerCity"), peerCity);
 }
 
-void CreateExpressCloudConnectionRequest::setIDCardNo(const std::string& iDCardNo)
-{
-	iDCardNo_ = iDCardNo;
-	setParameter("IDCardNo", iDCardNo);
+std::string CreateExpressCloudConnectionRequest::getIDCardNo() const {
+  return iDCardNo_;
 }
 
-long CreateExpressCloudConnectionRequest::getOwnerId()const
-{
-	return ownerId_;
+void CreateExpressCloudConnectionRequest::setIDCardNo(const std::string &iDCardNo) {
+  iDCardNo_ = iDCardNo;
+  setParameter(std::string("IDCardNo"), iDCardNo);
 }
 
-void CreateExpressCloudConnectionRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long CreateExpressCloudConnectionRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string CreateExpressCloudConnectionRequest::getContactMail()const
-{
-	return contactMail_;
+void CreateExpressCloudConnectionRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void CreateExpressCloudConnectionRequest::setContactMail(const std::string& contactMail)
-{
-	contactMail_ = contactMail;
-	setParameter("ContactMail", contactMail);
+std::string CreateExpressCloudConnectionRequest::getContactMail() const {
+  return contactMail_;
 }
 
-std::string CreateExpressCloudConnectionRequest::getContactTel()const
-{
-	return contactTel_;
+void CreateExpressCloudConnectionRequest::setContactMail(const std::string &contactMail) {
+  contactMail_ = contactMail;
+  setParameter(std::string("ContactMail"), contactMail);
 }
 
-void CreateExpressCloudConnectionRequest::setContactTel(const std::string& contactTel)
-{
-	contactTel_ = contactTel;
-	setParameter("ContactTel", contactTel);
+std::string CreateExpressCloudConnectionRequest::getContactTel() const {
+  return contactTel_;
 }
 
-std::string CreateExpressCloudConnectionRequest::getIdcSP()const
-{
-	return idcSP_;
+void CreateExpressCloudConnectionRequest::setContactTel(const std::string &contactTel) {
+  contactTel_ = contactTel;
+  setParameter(std::string("ContactTel"), contactTel);
 }
 
-void CreateExpressCloudConnectionRequest::setIdcSP(const std::string& idcSP)
-{
-	idcSP_ = idcSP;
-	setParameter("IdcSP", idcSP);
+std::string CreateExpressCloudConnectionRequest::getIdcSP() const {
+  return idcSP_;
 }
 
-std::string CreateExpressCloudConnectionRequest::getName()const
-{
-	return name_;
+void CreateExpressCloudConnectionRequest::setIdcSP(const std::string &idcSP) {
+  idcSP_ = idcSP;
+  setParameter(std::string("IdcSP"), idcSP);
 }
 
-void CreateExpressCloudConnectionRequest::setName(const std::string& name)
-{
-	name_ = name;
-	setParameter("Name", name);
+std::string CreateExpressCloudConnectionRequest::getName() const {
+  return name_;
+}
+
+void CreateExpressCloudConnectionRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
 }
 

vpc/src/model/CreateFlowLogRequest.cc

@@ -1,161 +1,152 @@
 /*
  * 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/vpc/model/CreateFlowLogRequest.h>
-
-using AlibabaCloud::Vpc::Model::CreateFlowLogRequest;
-
-CreateFlowLogRequest::CreateFlowLogRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "CreateFlowLog")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateFlowLogRequest::~CreateFlowLogRequest()
-{}
-
-long CreateFlowLogRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/CreateFlowLogRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreateFlowLogRequest;
+
+CreateFlowLogRequest::CreateFlowLogRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CreateFlowLog") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CreateFlowLogRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+CreateFlowLogRequest::~CreateFlowLogRequest() {}
+
+long CreateFlowLogRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string CreateFlowLogRequest::getDescription()const
-{
-	return description_;
+void CreateFlowLogRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void CreateFlowLogRequest::setDescription(const std::string& description)
-{
-	description_ = description;
-	setParameter("Description", description);
+std::string CreateFlowLogRequest::getDescription() const {
+  return description_;
 }
 
-std::string CreateFlowLogRequest::getRegionId()const
-{
-	return regionId_;
+void CreateFlowLogRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
 }
 
-void CreateFlowLogRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string CreateFlowLogRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string CreateFlowLogRequest::getResourceId()const
-{
-	return resourceId_;
+void CreateFlowLogRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void CreateFlowLogRequest::setResourceId(const std::string& resourceId)
-{
-	resourceId_ = resourceId;
-	setParameter("ResourceId", resourceId);
+std::string CreateFlowLogRequest::getResourceId() const {
+  return resourceId_;
 }
 
-std::string CreateFlowLogRequest::getProjectName()const
-{
-	return projectName_;
+void CreateFlowLogRequest::setResourceId(const std::string &resourceId) {
+  resourceId_ = resourceId;
+  setParameter(std::string("ResourceId"), resourceId);
 }
 
-void CreateFlowLogRequest::setProjectName(const std::string& projectName)
-{
-	projectName_ = projectName;
-	setParameter("ProjectName", projectName);
+std::string CreateFlowLogRequest::getProjectName() const {
+  return projectName_;
 }
 
-std::string CreateFlowLogRequest::getLogStoreName()const
-{
-	return logStoreName_;
+void CreateFlowLogRequest::setProjectName(const std::string &projectName) {
+  projectName_ = projectName;
+  setParameter(std::string("ProjectName"), projectName);
 }
 
-void CreateFlowLogRequest::setLogStoreName(const std::string& logStoreName)
-{
-	logStoreName_ = logStoreName;
-	setParameter("LogStoreName", logStoreName);
+std::string CreateFlowLogRequest::getLogStoreName() const {
+  return logStoreName_;
 }
 
-std::string CreateFlowLogRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void CreateFlowLogRequest::setLogStoreName(const std::string &logStoreName) {
+  logStoreName_ = logStoreName;
+  setParameter(std::string("LogStoreName"), logStoreName);
 }
 
-void CreateFlowLogRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string CreateFlowLogRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string CreateFlowLogRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void CreateFlowLogRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void CreateFlowLogRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string CreateFlowLogRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long CreateFlowLogRequest::getOwnerId()const
-{
-	return ownerId_;
+void CreateFlowLogRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void CreateFlowLogRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+std::vector<std::string> CreateFlowLogRequest::getTrafficPath() const {
+  return trafficPath_;
 }
 
-std::string CreateFlowLogRequest::getResourceType()const
-{
-	return resourceType_;
+void CreateFlowLogRequest::setTrafficPath(const std::vector<std::string> &trafficPath) {
+  trafficPath_ = trafficPath;
 }
 
-void CreateFlowLogRequest::setResourceType(const std::string& resourceType)
-{
-	resourceType_ = resourceType;
-	setParameter("ResourceType", resourceType);
+int CreateFlowLogRequest::getAggregationInterval() const {
+  return aggregationInterval_;
 }
 
-std::string CreateFlowLogRequest::getTrafficType()const
-{
-	return trafficType_;
+void CreateFlowLogRequest::setAggregationInterval(int aggregationInterval) {
+  aggregationInterval_ = aggregationInterval;
+  setParameter(std::string("AggregationInterval"), std::to_string(aggregationInterval));
 }
 
-void CreateFlowLogRequest::setTrafficType(const std::string& trafficType)
-{
-	trafficType_ = trafficType;
-	setParameter("TrafficType", trafficType);
+long CreateFlowLogRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string CreateFlowLogRequest::getFlowLogName()const
-{
-	return flowLogName_;
+void CreateFlowLogRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void CreateFlowLogRequest::setFlowLogName(const std::string& flowLogName)
-{
-	flowLogName_ = flowLogName;
-	setParameter("FlowLogName", flowLogName);
+std::string CreateFlowLogRequest::getResourceType() const {
+  return resourceType_;
+}
+
+void CreateFlowLogRequest::setResourceType(const std::string &resourceType) {
+  resourceType_ = resourceType;
+  setParameter(std::string("ResourceType"), resourceType);
+}
+
+std::string CreateFlowLogRequest::getTrafficType() const {
+  return trafficType_;
+}
+
+void CreateFlowLogRequest::setTrafficType(const std::string &trafficType) {
+  trafficType_ = trafficType;
+  setParameter(std::string("TrafficType"), trafficType);
+}
+
+std::string CreateFlowLogRequest::getFlowLogName() const {
+  return flowLogName_;
+}
+
+void CreateFlowLogRequest::setFlowLogName(const std::string &flowLogName) {
+  flowLogName_ = flowLogName;
+  setParameter(std::string("FlowLogName"), flowLogName);
 }
 

vpc/src/model/CreateForwardEntryRequest.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/vpc/model/CreateForwardEntryRequest.h>
-
-using AlibabaCloud::Vpc::Model::CreateForwardEntryRequest;
-
-CreateForwardEntryRequest::CreateForwardEntryRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "CreateForwardEntry")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateForwardEntryRequest::~CreateForwardEntryRequest()
-{}
-
-long CreateForwardEntryRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/CreateForwardEntryRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreateForwardEntryRequest;
+
+CreateForwardEntryRequest::CreateForwardEntryRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CreateForwardEntry") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CreateForwardEntryRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+CreateForwardEntryRequest::~CreateForwardEntryRequest() {}
+
+long CreateForwardEntryRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string CreateForwardEntryRequest::getClientToken()const
-{
-	return clientToken_;
+void CreateForwardEntryRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void CreateForwardEntryRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string CreateForwardEntryRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string CreateForwardEntryRequest::getForwardTableId()const
-{
-	return forwardTableId_;
+void CreateForwardEntryRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void CreateForwardEntryRequest::setForwardTableId(const std::string& forwardTableId)
-{
-	forwardTableId_ = forwardTableId;
-	setParameter("ForwardTableId", forwardTableId);
+std::string CreateForwardEntryRequest::getForwardTableId() const {
+  return forwardTableId_;
 }
 
-std::string CreateForwardEntryRequest::getInternalIp()const
-{
-	return internalIp_;
+void CreateForwardEntryRequest::setForwardTableId(const std::string &forwardTableId) {
+  forwardTableId_ = forwardTableId;
+  setParameter(std::string("ForwardTableId"), forwardTableId);
 }
 
-void CreateForwardEntryRequest::setInternalIp(const std::string& internalIp)
-{
-	internalIp_ = internalIp;
-	setParameter("InternalIp", internalIp);
+std::string CreateForwardEntryRequest::getInternalIp() const {
+  return internalIp_;
 }
 
-std::string CreateForwardEntryRequest::getRegionId()const
-{
-	return regionId_;
+void CreateForwardEntryRequest::setInternalIp(const std::string &internalIp) {
+  internalIp_ = internalIp;
+  setParameter(std::string("InternalIp"), internalIp);
 }
 
-void CreateForwardEntryRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string CreateForwardEntryRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string CreateForwardEntryRequest::getExternalIp()const
-{
-	return externalIp_;
+void CreateForwardEntryRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void CreateForwardEntryRequest::setExternalIp(const std::string& externalIp)
-{
-	externalIp_ = externalIp;
-	setParameter("ExternalIp", externalIp);
+std::string CreateForwardEntryRequest::getExternalIp() const {
+  return externalIp_;
 }
 
-std::string CreateForwardEntryRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void CreateForwardEntryRequest::setExternalIp(const std::string &externalIp) {
+  externalIp_ = externalIp;
+  setParameter(std::string("ExternalIp"), externalIp);
 }
 
-void CreateForwardEntryRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string CreateForwardEntryRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string CreateForwardEntryRequest::getIpProtocol()const
-{
-	return ipProtocol_;
+void CreateForwardEntryRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void CreateForwardEntryRequest::setIpProtocol(const std::string& ipProtocol)
-{
-	ipProtocol_ = ipProtocol;
-	setParameter("IpProtocol", ipProtocol);
+std::string CreateForwardEntryRequest::getIpProtocol() const {
+  return ipProtocol_;
 }
 
-std::string CreateForwardEntryRequest::getForwardEntryName()const
-{
-	return forwardEntryName_;
+void CreateForwardEntryRequest::setIpProtocol(const std::string &ipProtocol) {
+  ipProtocol_ = ipProtocol;
+  setParameter(std::string("IpProtocol"), ipProtocol);
 }
 
-void CreateForwardEntryRequest::setForwardEntryName(const std::string& forwardEntryName)
-{
-	forwardEntryName_ = forwardEntryName;
-	setParameter("ForwardEntryName", forwardEntryName);
+std::string CreateForwardEntryRequest::getForwardEntryName() const {
+  return forwardEntryName_;
 }
 
-std::string CreateForwardEntryRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void CreateForwardEntryRequest::setForwardEntryName(const std::string &forwardEntryName) {
+  forwardEntryName_ = forwardEntryName;
+  setParameter(std::string("ForwardEntryName"), forwardEntryName);
 }
 
-void CreateForwardEntryRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string CreateForwardEntryRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long CreateForwardEntryRequest::getOwnerId()const
-{
-	return ownerId_;
+void CreateForwardEntryRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void CreateForwardEntryRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long CreateForwardEntryRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string CreateForwardEntryRequest::getInternalPort()const
-{
-	return internalPort_;
+void CreateForwardEntryRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void CreateForwardEntryRequest::setInternalPort(const std::string& internalPort)
-{
-	internalPort_ = internalPort;
-	setParameter("InternalPort", internalPort);
+std::string CreateForwardEntryRequest::getInternalPort() const {
+  return internalPort_;
 }
 
-bool CreateForwardEntryRequest::getPortBreak()const
-{
-	return portBreak_;
+void CreateForwardEntryRequest::setInternalPort(const std::string &internalPort) {
+  internalPort_ = internalPort;
+  setParameter(std::string("InternalPort"), internalPort);
 }
 
-void CreateForwardEntryRequest::setPortBreak(bool portBreak)
-{
-	portBreak_ = portBreak;
-	setParameter("PortBreak", portBreak ? "true" : "false");
+bool CreateForwardEntryRequest::getPortBreak() const {
+  return portBreak_;
 }
 
-std::string CreateForwardEntryRequest::getExternalPort()const
-{
-	return externalPort_;
+void CreateForwardEntryRequest::setPortBreak(bool portBreak) {
+  portBreak_ = portBreak;
+  setParameter(std::string("PortBreak"), portBreak ? "true" : "false");
 }
 
-void CreateForwardEntryRequest::setExternalPort(const std::string& externalPort)
-{
-	externalPort_ = externalPort;
-	setParameter("ExternalPort", externalPort);
+std::string CreateForwardEntryRequest::getExternalPort() const {
+  return externalPort_;
+}
+
+void CreateForwardEntryRequest::setExternalPort(const std::string &externalPort) {
+  externalPort_ = externalPort;
+  setParameter(std::string("ExternalPort"), externalPort);
 }
 

vpc/src/model/CreateFullNatEntryRequest.cc

@@ -0,0 +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/vpc/model/CreateFullNatEntryRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreateFullNatEntryRequest;
+
+CreateFullNatEntryRequest::CreateFullNatEntryRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CreateFullNatEntry") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateFullNatEntryRequest::~CreateFullNatEntryRequest() {}
+
+std::string CreateFullNatEntryRequest::getFullNatEntryDescription() const {
+  return fullNatEntryDescription_;
+}
+
+void CreateFullNatEntryRequest::setFullNatEntryDescription(const std::string &fullNatEntryDescription) {
+  fullNatEntryDescription_ = fullNatEntryDescription;
+  setParameter(std::string("FullNatEntryDescription"), fullNatEntryDescription);
+}
+
+long CreateFullNatEntryRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void CreateFullNatEntryRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string CreateFullNatEntryRequest::getAccessIp() const {
+  return accessIp_;
+}
+
+void CreateFullNatEntryRequest::setAccessIp(const std::string &accessIp) {
+  accessIp_ = accessIp;
+  setParameter(std::string("AccessIp"), accessIp);
+}
+
+std::string CreateFullNatEntryRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void CreateFullNatEntryRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string CreateFullNatEntryRequest::getNatIpPort() const {
+  return natIpPort_;
+}
+
+void CreateFullNatEntryRequest::setNatIpPort(const std::string &natIpPort) {
+  natIpPort_ = natIpPort;
+  setParameter(std::string("NatIpPort"), natIpPort);
+}
+
+std::string CreateFullNatEntryRequest::getFullNatTableId() const {
+  return fullNatTableId_;
+}
+
+void CreateFullNatEntryRequest::setFullNatTableId(const std::string &fullNatTableId) {
+  fullNatTableId_ = fullNatTableId;
+  setParameter(std::string("FullNatTableId"), fullNatTableId);
+}
+
+std::string CreateFullNatEntryRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateFullNatEntryRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string CreateFullNatEntryRequest::getAccessPort() const {
+  return accessPort_;
+}
+
+void CreateFullNatEntryRequest::setAccessPort(const std::string &accessPort) {
+  accessPort_ = accessPort;
+  setParameter(std::string("AccessPort"), accessPort);
+}
+
+bool CreateFullNatEntryRequest::getDryRun() const {
+  return dryRun_;
+}
+
+void CreateFullNatEntryRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setParameter(std::string("DryRun"), dryRun ? "true" : "false");
+}
+
+std::string CreateFullNatEntryRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void CreateFullNatEntryRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string CreateFullNatEntryRequest::getIpProtocol() const {
+  return ipProtocol_;
+}
+
+void CreateFullNatEntryRequest::setIpProtocol(const std::string &ipProtocol) {
+  ipProtocol_ = ipProtocol;
+  setParameter(std::string("IpProtocol"), ipProtocol);
+}
+
+std::string CreateFullNatEntryRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void CreateFullNatEntryRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long CreateFullNatEntryRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CreateFullNatEntryRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string CreateFullNatEntryRequest::getFullNatEntryName() const {
+  return fullNatEntryName_;
+}
+
+void CreateFullNatEntryRequest::setFullNatEntryName(const std::string &fullNatEntryName) {
+  fullNatEntryName_ = fullNatEntryName;
+  setParameter(std::string("FullNatEntryName"), fullNatEntryName);
+}
+
+std::string CreateFullNatEntryRequest::getNatIp() const {
+  return natIp_;
+}
+
+void CreateFullNatEntryRequest::setNatIp(const std::string &natIp) {
+  natIp_ = natIp;
+  setParameter(std::string("NatIp"), natIp);
+}
+
+std::string CreateFullNatEntryRequest::getNetworkInterfaceId() const {
+  return networkInterfaceId_;
+}
+
+void CreateFullNatEntryRequest::setNetworkInterfaceId(const std::string &networkInterfaceId) {
+  networkInterfaceId_ = networkInterfaceId;
+  setParameter(std::string("NetworkInterfaceId"), networkInterfaceId);
+}
+

vpc/src/model/CreateFullNatEntryResult.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/vpc/model/CreateFullNatEntryResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vpc;
+using namespace AlibabaCloud::Vpc::Model;
+
+CreateFullNatEntryResult::CreateFullNatEntryResult() :
+	ServiceResult()
+{}
+
+CreateFullNatEntryResult::CreateFullNatEntryResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateFullNatEntryResult::~CreateFullNatEntryResult()
+{}
+
+void CreateFullNatEntryResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["FullNatEntryId"].isNull())
+		fullNatEntryId_ = value["FullNatEntryId"].asString();
+
+}
+
+std::string CreateFullNatEntryResult::getFullNatEntryId()const
+{
+	return fullNatEntryId_;
+}
+

vpc/src/model/CreateGlobalAccelerationInstanceRequest.cc

@@ -1,150 +1,126 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
-
-#include <alibabacloud/vpc/model/CreateGlobalAccelerationInstanceRequest.h>
-
-using AlibabaCloud::Vpc::Model::CreateGlobalAccelerationInstanceRequest;
-
-CreateGlobalAccelerationInstanceRequest::CreateGlobalAccelerationInstanceRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "CreateGlobalAccelerationInstance")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateGlobalAccelerationInstanceRequest::~CreateGlobalAccelerationInstanceRequest()
-{}
-
-long CreateGlobalAccelerationInstanceRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/CreateGlobalAccelerationInstanceRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreateGlobalAccelerationInstanceRequest;
+
+CreateGlobalAccelerationInstanceRequest::CreateGlobalAccelerationInstanceRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CreateGlobalAccelerationInstance") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CreateGlobalAccelerationInstanceRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+CreateGlobalAccelerationInstanceRequest::~CreateGlobalAccelerationInstanceRequest() {}
+
+long CreateGlobalAccelerationInstanceRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string CreateGlobalAccelerationInstanceRequest::getBandwidthType()const
-{
-	return bandwidthType_;
+void CreateGlobalAccelerationInstanceRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void CreateGlobalAccelerationInstanceRequest::setBandwidthType(const std::string& bandwidthType)
-{
-	bandwidthType_ = bandwidthType;
-	setParameter("BandwidthType", bandwidthType);
+std::string CreateGlobalAccelerationInstanceRequest::getBandwidthType() const {
+  return bandwidthType_;
 }
 
-std::string CreateGlobalAccelerationInstanceRequest::getClientToken()const
-{
-	return clientToken_;
+void CreateGlobalAccelerationInstanceRequest::setBandwidthType(const std::string &bandwidthType) {
+  bandwidthType_ = bandwidthType;
+  setParameter(std::string("BandwidthType"), bandwidthType);
 }
 
-void CreateGlobalAccelerationInstanceRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string CreateGlobalAccelerationInstanceRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string CreateGlobalAccelerationInstanceRequest::getDescription()const
-{
-	return description_;
+void CreateGlobalAccelerationInstanceRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void CreateGlobalAccelerationInstanceRequest::setDescription(const std::string& description)
-{
-	description_ = description;
-	setParameter("Description", description);
+std::string CreateGlobalAccelerationInstanceRequest::getDescription() const {
+  return description_;
 }
 
-std::string CreateGlobalAccelerationInstanceRequest::getRegionId()const
-{
-	return regionId_;
+void CreateGlobalAccelerationInstanceRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
 }
 
-void CreateGlobalAccelerationInstanceRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string CreateGlobalAccelerationInstanceRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string CreateGlobalAccelerationInstanceRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void CreateGlobalAccelerationInstanceRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void CreateGlobalAccelerationInstanceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string CreateGlobalAccelerationInstanceRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string CreateGlobalAccelerationInstanceRequest::getServiceLocation()const
-{
-	return serviceLocation_;
+void CreateGlobalAccelerationInstanceRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void CreateGlobalAccelerationInstanceRequest::setServiceLocation(const std::string& serviceLocation)
-{
-	serviceLocation_ = serviceLocation;
-	setParameter("ServiceLocation", serviceLocation);
+std::string CreateGlobalAccelerationInstanceRequest::getServiceLocation() const {
+  return serviceLocation_;
 }
 
-std::string CreateGlobalAccelerationInstanceRequest::getBandwidth()const
-{
-	return bandwidth_;
+void CreateGlobalAccelerationInstanceRequest::setServiceLocation(const std::string &serviceLocation) {
+  serviceLocation_ = serviceLocation;
+  setParameter(std::string("ServiceLocation"), serviceLocation);
 }
 
-void CreateGlobalAccelerationInstanceRequest::setBandwidth(const std::string& bandwidth)
-{
-	bandwidth_ = bandwidth;
-	setParameter("Bandwidth", bandwidth);
+std::string CreateGlobalAccelerationInstanceRequest::getBandwidth() const {
+  return bandwidth_;
 }
 
-std::string CreateGlobalAccelerationInstanceRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void CreateGlobalAccelerationInstanceRequest::setBandwidth(const std::string &bandwidth) {
+  bandwidth_ = bandwidth;
+  setParameter(std::string("Bandwidth"), bandwidth);
 }
 
-void CreateGlobalAccelerationInstanceRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string CreateGlobalAccelerationInstanceRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long CreateGlobalAccelerationInstanceRequest::getOwnerId()const
-{
-	return ownerId_;
+void CreateGlobalAccelerationInstanceRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void CreateGlobalAccelerationInstanceRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long CreateGlobalAccelerationInstanceRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string CreateGlobalAccelerationInstanceRequest::getName()const
-{
-	return name_;
+void CreateGlobalAccelerationInstanceRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void CreateGlobalAccelerationInstanceRequest::setName(const std::string& name)
-{
-	name_ = name;
-	setParameter("Name", name);
+std::string CreateGlobalAccelerationInstanceRequest::getName() const {
+  return name_;
+}
+
+void CreateGlobalAccelerationInstanceRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
 }
 

vpc/src/model/CreateHaVipRequest.cc

@@ -1,139 +1,117 @@
 /*
  * 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/vpc/model/CreateHaVipRequest.h>
-
-using AlibabaCloud::Vpc::Model::CreateHaVipRequest;
-
-CreateHaVipRequest::CreateHaVipRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "CreateHaVip")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateHaVipRequest::~CreateHaVipRequest()
-{}
-
-std::string CreateHaVipRequest::getIpAddress()const
-{
-	return ipAddress_;
+ */
+
+#include <alibabacloud/vpc/model/CreateHaVipRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreateHaVipRequest;
+
+CreateHaVipRequest::CreateHaVipRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CreateHaVip") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CreateHaVipRequest::setIpAddress(const std::string& ipAddress)
-{
-	ipAddress_ = ipAddress;
-	setParameter("IpAddress", ipAddress);
+CreateHaVipRequest::~CreateHaVipRequest() {}
+
+std::string CreateHaVipRequest::getIpAddress() const {
+  return ipAddress_;
 }
 
-long CreateHaVipRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+void CreateHaVipRequest::setIpAddress(const std::string &ipAddress) {
+  ipAddress_ = ipAddress;
+  setParameter(std::string("IpAddress"), ipAddress);
 }
 
-void CreateHaVipRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+long CreateHaVipRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string CreateHaVipRequest::getClientToken()const
-{
-	return clientToken_;
+void CreateHaVipRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void CreateHaVipRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string CreateHaVipRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string CreateHaVipRequest::getDescription()const
-{
-	return description_;
+void CreateHaVipRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void CreateHaVipRequest::setDescription(const std::string& description)
-{
-	description_ = description;
-	setParameter("Description", description);
+std::string CreateHaVipRequest::getDescription() const {
+  return description_;
 }
 
-std::string CreateHaVipRequest::getRegionId()const
-{
-	return regionId_;
+void CreateHaVipRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
 }
 
-void CreateHaVipRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string CreateHaVipRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string CreateHaVipRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void CreateHaVipRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void CreateHaVipRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string CreateHaVipRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string CreateHaVipRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void CreateHaVipRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void CreateHaVipRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string CreateHaVipRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long CreateHaVipRequest::getOwnerId()const
-{
-	return ownerId_;
+void CreateHaVipRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void CreateHaVipRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long CreateHaVipRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string CreateHaVipRequest::getVSwitchId()const
-{
-	return vSwitchId_;
+void CreateHaVipRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void CreateHaVipRequest::setVSwitchId(const std::string& vSwitchId)
-{
-	vSwitchId_ = vSwitchId;
-	setParameter("VSwitchId", vSwitchId);
+std::string CreateHaVipRequest::getVSwitchId() const {
+  return vSwitchId_;
 }
 
-std::string CreateHaVipRequest::getName()const
-{
-	return name_;
+void CreateHaVipRequest::setVSwitchId(const std::string &vSwitchId) {
+  vSwitchId_ = vSwitchId;
+  setParameter(std::string("VSwitchId"), vSwitchId);
 }
 
-void CreateHaVipRequest::setName(const std::string& name)
-{
-	name_ = name;
-	setParameter("Name", name);
+std::string CreateHaVipRequest::getName() const {
+  return name_;
+}
+
+void CreateHaVipRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
 }
 

vpc/src/model/CreateHaVipResult.cc

@@ -39,10 +39,10 @@ void CreateHaVipResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["HaVipId"].isNull())
-		haVipId_ = value["HaVipId"].asString();
 	if(!value["IpAddress"].isNull())
 		ipAddress_ = value["IpAddress"].asString();
+	if(!value["HaVipId"].isNull())
+		haVipId_ = value["HaVipId"].asString();
 
 }
 

vpc/src/model/CreateIPv6TranslatorAclListRequest.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/vpc/model/CreateIPv6TranslatorAclListRequest.h>
-
-using AlibabaCloud::Vpc::Model::CreateIPv6TranslatorAclListRequest;
-
-CreateIPv6TranslatorAclListRequest::CreateIPv6TranslatorAclListRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "CreateIPv6TranslatorAclList")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateIPv6TranslatorAclListRequest::~CreateIPv6TranslatorAclListRequest()
-{}
-
-long CreateIPv6TranslatorAclListRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/CreateIPv6TranslatorAclListRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreateIPv6TranslatorAclListRequest;
+
+CreateIPv6TranslatorAclListRequest::CreateIPv6TranslatorAclListRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CreateIPv6TranslatorAclList") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CreateIPv6TranslatorAclListRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+CreateIPv6TranslatorAclListRequest::~CreateIPv6TranslatorAclListRequest() {}
+
+long CreateIPv6TranslatorAclListRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string CreateIPv6TranslatorAclListRequest::getAclName()const
-{
-	return aclName_;
+void CreateIPv6TranslatorAclListRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void CreateIPv6TranslatorAclListRequest::setAclName(const std::string& aclName)
-{
-	aclName_ = aclName;
-	setParameter("AclName", aclName);
+std::string CreateIPv6TranslatorAclListRequest::getAclName() const {
+  return aclName_;
 }
 
-std::string CreateIPv6TranslatorAclListRequest::getClientToken()const
-{
-	return clientToken_;
+void CreateIPv6TranslatorAclListRequest::setAclName(const std::string &aclName) {
+  aclName_ = aclName;
+  setParameter(std::string("AclName"), aclName);
 }
 
-void CreateIPv6TranslatorAclListRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string CreateIPv6TranslatorAclListRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string CreateIPv6TranslatorAclListRequest::getRegionId()const
-{
-	return regionId_;
+void CreateIPv6TranslatorAclListRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void CreateIPv6TranslatorAclListRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string CreateIPv6TranslatorAclListRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string CreateIPv6TranslatorAclListRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void CreateIPv6TranslatorAclListRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void CreateIPv6TranslatorAclListRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string CreateIPv6TranslatorAclListRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string CreateIPv6TranslatorAclListRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void CreateIPv6TranslatorAclListRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void CreateIPv6TranslatorAclListRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string CreateIPv6TranslatorAclListRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long CreateIPv6TranslatorAclListRequest::getOwnerId()const
-{
-	return ownerId_;
+void CreateIPv6TranslatorAclListRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void CreateIPv6TranslatorAclListRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long CreateIPv6TranslatorAclListRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CreateIPv6TranslatorAclListRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 

vpc/src/model/CreateIPv6TranslatorEntryRequest.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/vpc/model/CreateIPv6TranslatorEntryRequest.h>
-
-using AlibabaCloud::Vpc::Model::CreateIPv6TranslatorEntryRequest;
-
-CreateIPv6TranslatorEntryRequest::CreateIPv6TranslatorEntryRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "CreateIPv6TranslatorEntry")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateIPv6TranslatorEntryRequest::~CreateIPv6TranslatorEntryRequest()
-{}
-
-int CreateIPv6TranslatorEntryRequest::getBackendIpv4Port()const
-{
-	return backendIpv4Port_;
+ */
+
+#include <alibabacloud/vpc/model/CreateIPv6TranslatorEntryRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreateIPv6TranslatorEntryRequest;
+
+CreateIPv6TranslatorEntryRequest::CreateIPv6TranslatorEntryRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CreateIPv6TranslatorEntry") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CreateIPv6TranslatorEntryRequest::setBackendIpv4Port(int backendIpv4Port)
-{
-	backendIpv4Port_ = backendIpv4Port;
-	setParameter("BackendIpv4Port", std::to_string(backendIpv4Port));
+CreateIPv6TranslatorEntryRequest::~CreateIPv6TranslatorEntryRequest() {}
+
+int CreateIPv6TranslatorEntryRequest::getBackendIpv4Port() const {
+  return backendIpv4Port_;
 }
 
-long CreateIPv6TranslatorEntryRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+void CreateIPv6TranslatorEntryRequest::setBackendIpv4Port(int backendIpv4Port) {
+  backendIpv4Port_ = backendIpv4Port;
+  setParameter(std::string("BackendIpv4Port"), std::to_string(backendIpv4Port));
 }
 
-void CreateIPv6TranslatorEntryRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+long CreateIPv6TranslatorEntryRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string CreateIPv6TranslatorEntryRequest::getEntryName()const
-{
-	return entryName_;
+void CreateIPv6TranslatorEntryRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void CreateIPv6TranslatorEntryRequest::setEntryName(const std::string& entryName)
-{
-	entryName_ = entryName;
-	setParameter("EntryName", entryName);
+std::string CreateIPv6TranslatorEntryRequest::getEntryName() const {
+  return entryName_;
 }
 
-std::string CreateIPv6TranslatorEntryRequest::getAclStatus()const
-{
-	return aclStatus_;
+void CreateIPv6TranslatorEntryRequest::setEntryName(const std::string &entryName) {
+  entryName_ = entryName;
+  setParameter(std::string("EntryName"), entryName);
 }
 
-void CreateIPv6TranslatorEntryRequest::setAclStatus(const std::string& aclStatus)
-{
-	aclStatus_ = aclStatus;
-	setParameter("AclStatus", aclStatus);
+std::string CreateIPv6TranslatorEntryRequest::getAclStatus() const {
+  return aclStatus_;
 }
 
-int CreateIPv6TranslatorEntryRequest::getEntryBandwidth()const
-{
-	return entryBandwidth_;
+void CreateIPv6TranslatorEntryRequest::setAclStatus(const std::string &aclStatus) {
+  aclStatus_ = aclStatus;
+  setParameter(std::string("AclStatus"), aclStatus);
 }
 
-void CreateIPv6TranslatorEntryRequest::setEntryBandwidth(int entryBandwidth)
-{
-	entryBandwidth_ = entryBandwidth;
-	setParameter("EntryBandwidth", std::to_string(entryBandwidth));
+int CreateIPv6TranslatorEntryRequest::getEntryBandwidth() const {
+  return entryBandwidth_;
 }
 
-std::string CreateIPv6TranslatorEntryRequest::getAclType()const
-{
-	return aclType_;
+void CreateIPv6TranslatorEntryRequest::setEntryBandwidth(int entryBandwidth) {
+  entryBandwidth_ = entryBandwidth;
+  setParameter(std::string("EntryBandwidth"), std::to_string(entryBandwidth));
 }
 
-void CreateIPv6TranslatorEntryRequest::setAclType(const std::string& aclType)
-{
-	aclType_ = aclType;
-	setParameter("AclType", aclType);
+std::string CreateIPv6TranslatorEntryRequest::getAclType() const {
+  return aclType_;
 }
 
-int CreateIPv6TranslatorEntryRequest::getAllocateIpv6Port()const
-{
-	return allocateIpv6Port_;
+void CreateIPv6TranslatorEntryRequest::setAclType(const std::string &aclType) {
+  aclType_ = aclType;
+  setParameter(std::string("AclType"), aclType);
 }
 
-void CreateIPv6TranslatorEntryRequest::setAllocateIpv6Port(int allocateIpv6Port)
-{
-	allocateIpv6Port_ = allocateIpv6Port;
-	setParameter("AllocateIpv6Port", std::to_string(allocateIpv6Port));
+int CreateIPv6TranslatorEntryRequest::getAllocateIpv6Port() const {
+  return allocateIpv6Port_;
 }
 
-std::string CreateIPv6TranslatorEntryRequest::getEntryDescription()const
-{
-	return entryDescription_;
+void CreateIPv6TranslatorEntryRequest::setAllocateIpv6Port(int allocateIpv6Port) {
+  allocateIpv6Port_ = allocateIpv6Port;
+  setParameter(std::string("AllocateIpv6Port"), std::to_string(allocateIpv6Port));
 }
 
-void CreateIPv6TranslatorEntryRequest::setEntryDescription(const std::string& entryDescription)
-{
-	entryDescription_ = entryDescription;
-	setParameter("EntryDescription", entryDescription);
+std::string CreateIPv6TranslatorEntryRequest::getEntryDescription() const {
+  return entryDescription_;
 }
 
-std::string CreateIPv6TranslatorEntryRequest::getRegionId()const
-{
-	return regionId_;
+void CreateIPv6TranslatorEntryRequest::setEntryDescription(const std::string &entryDescription) {
+  entryDescription_ = entryDescription;
+  setParameter(std::string("EntryDescription"), entryDescription);
 }
 
-void CreateIPv6TranslatorEntryRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string CreateIPv6TranslatorEntryRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string CreateIPv6TranslatorEntryRequest::getBackendIpv4Addr()const
-{
-	return backendIpv4Addr_;
+void CreateIPv6TranslatorEntryRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void CreateIPv6TranslatorEntryRequest::setBackendIpv4Addr(const std::string& backendIpv4Addr)
-{
-	backendIpv4Addr_ = backendIpv4Addr;
-	setParameter("BackendIpv4Addr", backendIpv4Addr);
+std::string CreateIPv6TranslatorEntryRequest::getBackendIpv4Addr() const {
+  return backendIpv4Addr_;
 }
 
-std::string CreateIPv6TranslatorEntryRequest::getAclId()const
-{
-	return aclId_;
+void CreateIPv6TranslatorEntryRequest::setBackendIpv4Addr(const std::string &backendIpv4Addr) {
+  backendIpv4Addr_ = backendIpv4Addr;
+  setParameter(std::string("BackendIpv4Addr"), backendIpv4Addr);
 }
 
-void CreateIPv6TranslatorEntryRequest::setAclId(const std::string& aclId)
-{
-	aclId_ = aclId;
-	setParameter("AclId", aclId);
+std::string CreateIPv6TranslatorEntryRequest::getAclId() const {
+  return aclId_;
 }
 
-std::string CreateIPv6TranslatorEntryRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void CreateIPv6TranslatorEntryRequest::setAclId(const std::string &aclId) {
+  aclId_ = aclId;
+  setParameter(std::string("AclId"), aclId);
 }
 
-void CreateIPv6TranslatorEntryRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string CreateIPv6TranslatorEntryRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string CreateIPv6TranslatorEntryRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void CreateIPv6TranslatorEntryRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void CreateIPv6TranslatorEntryRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string CreateIPv6TranslatorEntryRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long CreateIPv6TranslatorEntryRequest::getOwnerId()const
-{
-	return ownerId_;
+void CreateIPv6TranslatorEntryRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void CreateIPv6TranslatorEntryRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long CreateIPv6TranslatorEntryRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string CreateIPv6TranslatorEntryRequest::getTransProtocol()const
-{
-	return transProtocol_;
+void CreateIPv6TranslatorEntryRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void CreateIPv6TranslatorEntryRequest::setTransProtocol(const std::string& transProtocol)
-{
-	transProtocol_ = transProtocol;
-	setParameter("TransProtocol", transProtocol);
+std::string CreateIPv6TranslatorEntryRequest::getTransProtocol() const {
+  return transProtocol_;
 }
 
-std::string CreateIPv6TranslatorEntryRequest::getIpv6TranslatorId()const
-{
-	return ipv6TranslatorId_;
+void CreateIPv6TranslatorEntryRequest::setTransProtocol(const std::string &transProtocol) {
+  transProtocol_ = transProtocol;
+  setParameter(std::string("TransProtocol"), transProtocol);
 }
 
-void CreateIPv6TranslatorEntryRequest::setIpv6TranslatorId(const std::string& ipv6TranslatorId)
-{
-	ipv6TranslatorId_ = ipv6TranslatorId;
-	setParameter("Ipv6TranslatorId", ipv6TranslatorId);
+std::string CreateIPv6TranslatorEntryRequest::getIpv6TranslatorId() const {
+  return ipv6TranslatorId_;
+}
+
+void CreateIPv6TranslatorEntryRequest::setIpv6TranslatorId(const std::string &ipv6TranslatorId) {
+  ipv6TranslatorId_ = ipv6TranslatorId;
+  setParameter(std::string("Ipv6TranslatorId"), ipv6TranslatorId);
 }
 

vpc/src/model/CreateIPv6TranslatorRequest.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/vpc/model/CreateIPv6TranslatorRequest.h>
-
-using AlibabaCloud::Vpc::Model::CreateIPv6TranslatorRequest;
-
-CreateIPv6TranslatorRequest::CreateIPv6TranslatorRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "CreateIPv6Translator")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateIPv6TranslatorRequest::~CreateIPv6TranslatorRequest()
-{}
-
-long CreateIPv6TranslatorRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/CreateIPv6TranslatorRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreateIPv6TranslatorRequest;
+
+CreateIPv6TranslatorRequest::CreateIPv6TranslatorRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CreateIPv6Translator") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CreateIPv6TranslatorRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+CreateIPv6TranslatorRequest::~CreateIPv6TranslatorRequest() {}
+
+long CreateIPv6TranslatorRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string CreateIPv6TranslatorRequest::getClientToken()const
-{
-	return clientToken_;
+void CreateIPv6TranslatorRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void CreateIPv6TranslatorRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string CreateIPv6TranslatorRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string CreateIPv6TranslatorRequest::getSpec()const
-{
-	return spec_;
+void CreateIPv6TranslatorRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void CreateIPv6TranslatorRequest::setSpec(const std::string& spec)
-{
-	spec_ = spec;
-	setParameter("Spec", spec);
+std::string CreateIPv6TranslatorRequest::getSpec() const {
+  return spec_;
 }
 
-int CreateIPv6TranslatorRequest::getDuration()const
-{
-	return duration_;
+void CreateIPv6TranslatorRequest::setSpec(const std::string &spec) {
+  spec_ = spec;
+  setParameter(std::string("Spec"), spec);
 }
 
-void CreateIPv6TranslatorRequest::setDuration(int duration)
-{
-	duration_ = duration;
-	setParameter("Duration", std::to_string(duration));
+int CreateIPv6TranslatorRequest::getDuration() const {
+  return duration_;
 }
 
-std::string CreateIPv6TranslatorRequest::getRegionId()const
-{
-	return regionId_;
+void CreateIPv6TranslatorRequest::setDuration(int duration) {
+  duration_ = duration;
+  setParameter(std::string("Duration"), std::to_string(duration));
 }
 
-void CreateIPv6TranslatorRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string CreateIPv6TranslatorRequest::getRegionId() const {
+  return regionId_;
 }
 
-bool CreateIPv6TranslatorRequest::getAutoPay()const
-{
-	return autoPay_;
+void CreateIPv6TranslatorRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void CreateIPv6TranslatorRequest::setAutoPay(bool autoPay)
-{
-	autoPay_ = autoPay;
-	setParameter("AutoPay", autoPay ? "true" : "false");
+bool CreateIPv6TranslatorRequest::getAutoPay() const {
+  return autoPay_;
 }
 
-std::string CreateIPv6TranslatorRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void CreateIPv6TranslatorRequest::setAutoPay(bool autoPay) {
+  autoPay_ = autoPay;
+  setParameter(std::string("AutoPay"), autoPay ? "true" : "false");
 }
 
-void CreateIPv6TranslatorRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string CreateIPv6TranslatorRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-int CreateIPv6TranslatorRequest::getBandwidth()const
-{
-	return bandwidth_;
+void CreateIPv6TranslatorRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void CreateIPv6TranslatorRequest::setBandwidth(int bandwidth)
-{
-	bandwidth_ = bandwidth;
-	setParameter("Bandwidth", std::to_string(bandwidth));
+int CreateIPv6TranslatorRequest::getBandwidth() const {
+  return bandwidth_;
 }
 
-std::string CreateIPv6TranslatorRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void CreateIPv6TranslatorRequest::setBandwidth(int bandwidth) {
+  bandwidth_ = bandwidth;
+  setParameter(std::string("Bandwidth"), std::to_string(bandwidth));
 }
 
-void CreateIPv6TranslatorRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string CreateIPv6TranslatorRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long CreateIPv6TranslatorRequest::getOwnerId()const
-{
-	return ownerId_;
+void CreateIPv6TranslatorRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void CreateIPv6TranslatorRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long CreateIPv6TranslatorRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string CreateIPv6TranslatorRequest::getName()const
-{
-	return name_;
+void CreateIPv6TranslatorRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void CreateIPv6TranslatorRequest::setName(const std::string& name)
-{
-	name_ = name;
-	setParameter("Name", name);
+std::string CreateIPv6TranslatorRequest::getName() const {
+  return name_;
 }
 
-std::string CreateIPv6TranslatorRequest::getPayType()const
-{
-	return payType_;
+void CreateIPv6TranslatorRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
 }
 
-void CreateIPv6TranslatorRequest::setPayType(const std::string& payType)
-{
-	payType_ = payType;
-	setParameter("PayType", payType);
+std::string CreateIPv6TranslatorRequest::getPayType() const {
+  return payType_;
 }
 
-std::string CreateIPv6TranslatorRequest::getPricingCycle()const
-{
-	return pricingCycle_;
+void CreateIPv6TranslatorRequest::setPayType(const std::string &payType) {
+  payType_ = payType;
+  setParameter(std::string("PayType"), payType);
 }
 
-void CreateIPv6TranslatorRequest::setPricingCycle(const std::string& pricingCycle)
-{
-	pricingCycle_ = pricingCycle;
-	setParameter("PricingCycle", pricingCycle);
+std::string CreateIPv6TranslatorRequest::getPricingCycle() const {
+  return pricingCycle_;
+}
+
+void CreateIPv6TranslatorRequest::setPricingCycle(const std::string &pricingCycle) {
+  pricingCycle_ = pricingCycle;
+  setParameter(std::string("PricingCycle"), pricingCycle);
 }
 

vpc/src/model/CreateIPv6TranslatorResult.cc

@@ -41,10 +41,10 @@ void CreateIPv6TranslatorResult::parse(const std::string &payload)
 	setRequestId(value["RequestId"].asString());
 	if(!value["Ipv6TranslatorId"].isNull())
 		ipv6TranslatorId_ = value["Ipv6TranslatorId"].asString();
-	if(!value["Name"].isNull())
-		name_ = value["Name"].asString();
 	if(!value["Spec"].isNull())
 		spec_ = value["Spec"].asString();
+	if(!value["Name"].isNull())
+		name_ = value["Name"].asString();
 	if(!value["OrderId"].isNull())
 		orderId_ = std::stol(value["OrderId"].asString());
 

vpc/src/model/CreateIpsecServerRequest.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/vpc/model/CreateIpsecServerRequest.h>
-
-using AlibabaCloud::Vpc::Model::CreateIpsecServerRequest;
-
-CreateIpsecServerRequest::CreateIpsecServerRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "CreateIpsecServer")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateIpsecServerRequest::~CreateIpsecServerRequest()
-{}
-
-std::string CreateIpsecServerRequest::getIkeConfig()const
-{
-	return ikeConfig_;
+ */
+
+#include <alibabacloud/vpc/model/CreateIpsecServerRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreateIpsecServerRequest;
+
+CreateIpsecServerRequest::CreateIpsecServerRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CreateIpsecServer") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CreateIpsecServerRequest::setIkeConfig(const std::string& ikeConfig)
-{
-	ikeConfig_ = ikeConfig;
-	setParameter("IkeConfig", ikeConfig);
+CreateIpsecServerRequest::~CreateIpsecServerRequest() {}
+
+std::string CreateIpsecServerRequest::getIkeConfig() const {
+  return ikeConfig_;
 }
 
-long CreateIpsecServerRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+void CreateIpsecServerRequest::setIkeConfig(const std::string &ikeConfig) {
+  ikeConfig_ = ikeConfig;
+  setParameter(std::string("IkeConfig"), ikeConfig);
 }
 
-void CreateIpsecServerRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+long CreateIpsecServerRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string CreateIpsecServerRequest::getClientToken()const
-{
-	return clientToken_;
+void CreateIpsecServerRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void CreateIpsecServerRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string CreateIpsecServerRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string CreateIpsecServerRequest::getIpsecConfig()const
-{
-	return ipsecConfig_;
+void CreateIpsecServerRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void CreateIpsecServerRequest::setIpsecConfig(const std::string& ipsecConfig)
-{
-	ipsecConfig_ = ipsecConfig;
-	setParameter("IpsecConfig", ipsecConfig);
+std::string CreateIpsecServerRequest::getIpsecConfig() const {
+  return ipsecConfig_;
 }
 
-std::string CreateIpsecServerRequest::getPsk()const
-{
-	return psk_;
+void CreateIpsecServerRequest::setIpsecConfig(const std::string &ipsecConfig) {
+  ipsecConfig_ = ipsecConfig;
+  setParameter(std::string("IpsecConfig"), ipsecConfig);
 }
 
-void CreateIpsecServerRequest::setPsk(const std::string& psk)
-{
-	psk_ = psk;
-	setParameter("Psk", psk);
+std::string CreateIpsecServerRequest::getPsk() const {
+  return psk_;
 }
 
-std::string CreateIpsecServerRequest::getLocalSubnet()const
-{
-	return localSubnet_;
+void CreateIpsecServerRequest::setPsk(const std::string &psk) {
+  psk_ = psk;
+  setParameter(std::string("Psk"), psk);
 }
 
-void CreateIpsecServerRequest::setLocalSubnet(const std::string& localSubnet)
-{
-	localSubnet_ = localSubnet;
-	setParameter("LocalSubnet", localSubnet);
+std::string CreateIpsecServerRequest::getLocalSubnet() const {
+  return localSubnet_;
 }
 
-std::string CreateIpsecServerRequest::getRegionId()const
-{
-	return regionId_;
+void CreateIpsecServerRequest::setLocalSubnet(const std::string &localSubnet) {
+  localSubnet_ = localSubnet;
+  setParameter(std::string("LocalSubnet"), localSubnet);
 }
 
-void CreateIpsecServerRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string CreateIpsecServerRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string CreateIpsecServerRequest::getIDaaSInstanceId()const
-{
-	return iDaaSInstanceId_;
+void CreateIpsecServerRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void CreateIpsecServerRequest::setIDaaSInstanceId(const std::string& iDaaSInstanceId)
-{
-	iDaaSInstanceId_ = iDaaSInstanceId;
-	setParameter("IDaaSInstanceId", iDaaSInstanceId);
+std::string CreateIpsecServerRequest::getIDaaSInstanceId() const {
+  return iDaaSInstanceId_;
 }
 
-bool CreateIpsecServerRequest::getEffectImmediately()const
-{
-	return effectImmediately_;
+void CreateIpsecServerRequest::setIDaaSInstanceId(const std::string &iDaaSInstanceId) {
+  iDaaSInstanceId_ = iDaaSInstanceId;
+  setParameter(std::string("IDaaSInstanceId"), iDaaSInstanceId);
 }
 
-void CreateIpsecServerRequest::setEffectImmediately(bool effectImmediately)
-{
-	effectImmediately_ = effectImmediately;
-	setParameter("EffectImmediately", effectImmediately ? "true" : "false");
+bool CreateIpsecServerRequest::getEffectImmediately() const {
+  return effectImmediately_;
 }
 
-std::string CreateIpsecServerRequest::getClientIpPool()const
-{
-	return clientIpPool_;
+void CreateIpsecServerRequest::setEffectImmediately(bool effectImmediately) {
+  effectImmediately_ = effectImmediately;
+  setParameter(std::string("EffectImmediately"), effectImmediately ? "true" : "false");
 }
 
-void CreateIpsecServerRequest::setClientIpPool(const std::string& clientIpPool)
-{
-	clientIpPool_ = clientIpPool;
-	setParameter("ClientIpPool", clientIpPool);
+std::string CreateIpsecServerRequest::getClientIpPool() const {
+  return clientIpPool_;
 }
 
-std::string CreateIpsecServerRequest::getDryRun()const
-{
-	return dryRun_;
+void CreateIpsecServerRequest::setClientIpPool(const std::string &clientIpPool) {
+  clientIpPool_ = clientIpPool;
+  setParameter(std::string("ClientIpPool"), clientIpPool);
 }
 
-void CreateIpsecServerRequest::setDryRun(const std::string& dryRun)
-{
-	dryRun_ = dryRun;
-	setParameter("DryRun", dryRun);
+std::string CreateIpsecServerRequest::getDryRun() const {
+  return dryRun_;
 }
 
-std::string CreateIpsecServerRequest::getVpnGatewayId()const
-{
-	return vpnGatewayId_;
+void CreateIpsecServerRequest::setDryRun(const std::string &dryRun) {
+  dryRun_ = dryRun;
+  setParameter(std::string("DryRun"), dryRun);
 }
 
-void CreateIpsecServerRequest::setVpnGatewayId(const std::string& vpnGatewayId)
-{
-	vpnGatewayId_ = vpnGatewayId;
-	setParameter("VpnGatewayId", vpnGatewayId);
+std::string CreateIpsecServerRequest::getVpnGatewayId() const {
+  return vpnGatewayId_;
 }
 
-std::string CreateIpsecServerRequest::getCallerBid()const
-{
-	return callerBid_;
+void CreateIpsecServerRequest::setVpnGatewayId(const std::string &vpnGatewayId) {
+  vpnGatewayId_ = vpnGatewayId;
+  setParameter(std::string("VpnGatewayId"), vpnGatewayId);
 }
 
-void CreateIpsecServerRequest::setCallerBid(const std::string& callerBid)
-{
-	callerBid_ = callerBid;
-	setParameter("CallerBid", callerBid);
+std::string CreateIpsecServerRequest::getCallerBid() const {
+  return callerBid_;
 }
 
-bool CreateIpsecServerRequest::getPskEnabled()const
-{
-	return pskEnabled_;
+void CreateIpsecServerRequest::setCallerBid(const std::string &callerBid) {
+  callerBid_ = callerBid;
+  setParameter(std::string("callerBid"), callerBid);
 }
 
-void CreateIpsecServerRequest::setPskEnabled(bool pskEnabled)
-{
-	pskEnabled_ = pskEnabled;
-	setParameter("PskEnabled", pskEnabled ? "true" : "false");
+bool CreateIpsecServerRequest::getPskEnabled() const {
+  return pskEnabled_;
 }
 
-bool CreateIpsecServerRequest::getMultiFactorAuthEnabled()const
-{
-	return multiFactorAuthEnabled_;
+void CreateIpsecServerRequest::setPskEnabled(bool pskEnabled) {
+  pskEnabled_ = pskEnabled;
+  setParameter(std::string("PskEnabled"), pskEnabled ? "true" : "false");
 }
 
-void CreateIpsecServerRequest::setMultiFactorAuthEnabled(bool multiFactorAuthEnabled)
-{
-	multiFactorAuthEnabled_ = multiFactorAuthEnabled;
-	setParameter("MultiFactorAuthEnabled", multiFactorAuthEnabled ? "true" : "false");
+bool CreateIpsecServerRequest::getMultiFactorAuthEnabled() const {
+  return multiFactorAuthEnabled_;
 }
 
-std::string CreateIpsecServerRequest::getIpSecServerName()const
-{
-	return ipSecServerName_;
+void CreateIpsecServerRequest::setMultiFactorAuthEnabled(bool multiFactorAuthEnabled) {
+  multiFactorAuthEnabled_ = multiFactorAuthEnabled;
+  setParameter(std::string("MultiFactorAuthEnabled"), multiFactorAuthEnabled ? "true" : "false");
 }
 
-void CreateIpsecServerRequest::setIpSecServerName(const std::string& ipSecServerName)
-{
-	ipSecServerName_ = ipSecServerName;
-	setParameter("IpSecServerName", ipSecServerName);
+std::string CreateIpsecServerRequest::getIpSecServerName() const {
+  return ipSecServerName_;
+}
+
+void CreateIpsecServerRequest::setIpSecServerName(const std::string &ipSecServerName) {
+  ipSecServerName_ = ipSecServerName;
+  setParameter(std::string("IpSecServerName"), ipSecServerName);
 }
 

vpc/src/model/CreateIpsecServerResult.cc

@@ -39,16 +39,16 @@ void CreateIpsecServerResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["RegionId"].isNull())
-		regionId_ = value["RegionId"].asString();
+	if(!value["CreationTime"].isNull())
+		creationTime_ = value["CreationTime"].asString();
 	if(!value["IpsecServerId"].isNull())
 		ipsecServerId_ = value["IpsecServerId"].asString();
 	if(!value["IpsecServerName"].isNull())
 		ipsecServerName_ = value["IpsecServerName"].asString();
 	if(!value["VpnGatewayId"].isNull())
 		vpnGatewayId_ = value["VpnGatewayId"].asString();
-	if(!value["CreationTime"].isNull())
-		creationTime_ = value["CreationTime"].asString();
+	if(!value["RegionId"].isNull())
+		regionId_ = value["RegionId"].asString();
 
 }
 

vpc/src/model/CreateIpv4GatewayRequest.cc

@@ -0,0 +1,117 @@
+/*
+ * 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/vpc/model/CreateIpv4GatewayRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreateIpv4GatewayRequest;
+
+CreateIpv4GatewayRequest::CreateIpv4GatewayRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CreateIpv4Gateway") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateIpv4GatewayRequest::~CreateIpv4GatewayRequest() {}
+
+std::string CreateIpv4GatewayRequest::getIpv4GatewayDescription() const {
+  return ipv4GatewayDescription_;
+}
+
+void CreateIpv4GatewayRequest::setIpv4GatewayDescription(const std::string &ipv4GatewayDescription) {
+  ipv4GatewayDescription_ = ipv4GatewayDescription;
+  setParameter(std::string("Ipv4GatewayDescription"), ipv4GatewayDescription);
+}
+
+long CreateIpv4GatewayRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void CreateIpv4GatewayRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string CreateIpv4GatewayRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void CreateIpv4GatewayRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string CreateIpv4GatewayRequest::getIpv4GatewayName() const {
+  return ipv4GatewayName_;
+}
+
+void CreateIpv4GatewayRequest::setIpv4GatewayName(const std::string &ipv4GatewayName) {
+  ipv4GatewayName_ = ipv4GatewayName;
+  setParameter(std::string("Ipv4GatewayName"), ipv4GatewayName);
+}
+
+std::string CreateIpv4GatewayRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateIpv4GatewayRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+bool CreateIpv4GatewayRequest::getDryRun() const {
+  return dryRun_;
+}
+
+void CreateIpv4GatewayRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setParameter(std::string("DryRun"), dryRun ? "true" : "false");
+}
+
+std::string CreateIpv4GatewayRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void CreateIpv4GatewayRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string CreateIpv4GatewayRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void CreateIpv4GatewayRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long CreateIpv4GatewayRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CreateIpv4GatewayRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string CreateIpv4GatewayRequest::getVpcId() const {
+  return vpcId_;
+}
+
+void CreateIpv4GatewayRequest::setVpcId(const std::string &vpcId) {
+  vpcId_ = vpcId;
+  setParameter(std::string("VpcId"), vpcId);
+}
+

vpc/src/model/CreateIpv4GatewayResult.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/vpc/model/CreateIpv4GatewayResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vpc;
+using namespace AlibabaCloud::Vpc::Model;
+
+CreateIpv4GatewayResult::CreateIpv4GatewayResult() :
+	ServiceResult()
+{}
+
+CreateIpv4GatewayResult::CreateIpv4GatewayResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateIpv4GatewayResult::~CreateIpv4GatewayResult()
+{}
+
+void CreateIpv4GatewayResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Ipv4GatewayId"].isNull())
+		ipv4GatewayId_ = value["Ipv4GatewayId"].asString();
+
+}
+
+std::string CreateIpv4GatewayResult::getIpv4GatewayId()const
+{
+	return ipv4GatewayId_;
+}
+

vpc/src/model/CreateIpv6EgressOnlyRuleRequest.cc

@@ -1,150 +1,126 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
-
-#include <alibabacloud/vpc/model/CreateIpv6EgressOnlyRuleRequest.h>
-
-using AlibabaCloud::Vpc::Model::CreateIpv6EgressOnlyRuleRequest;
-
-CreateIpv6EgressOnlyRuleRequest::CreateIpv6EgressOnlyRuleRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "CreateIpv6EgressOnlyRule")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateIpv6EgressOnlyRuleRequest::~CreateIpv6EgressOnlyRuleRequest()
-{}
-
-long CreateIpv6EgressOnlyRuleRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/CreateIpv6EgressOnlyRuleRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreateIpv6EgressOnlyRuleRequest;
+
+CreateIpv6EgressOnlyRuleRequest::CreateIpv6EgressOnlyRuleRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CreateIpv6EgressOnlyRule") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CreateIpv6EgressOnlyRuleRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+CreateIpv6EgressOnlyRuleRequest::~CreateIpv6EgressOnlyRuleRequest() {}
+
+long CreateIpv6EgressOnlyRuleRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string CreateIpv6EgressOnlyRuleRequest::getClientToken()const
-{
-	return clientToken_;
+void CreateIpv6EgressOnlyRuleRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void CreateIpv6EgressOnlyRuleRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string CreateIpv6EgressOnlyRuleRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string CreateIpv6EgressOnlyRuleRequest::getDescription()const
-{
-	return description_;
+void CreateIpv6EgressOnlyRuleRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void CreateIpv6EgressOnlyRuleRequest::setDescription(const std::string& description)
-{
-	description_ = description;
-	setParameter("Description", description);
+std::string CreateIpv6EgressOnlyRuleRequest::getDescription() const {
+  return description_;
 }
 
-std::string CreateIpv6EgressOnlyRuleRequest::getRegionId()const
-{
-	return regionId_;
+void CreateIpv6EgressOnlyRuleRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
 }
 
-void CreateIpv6EgressOnlyRuleRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string CreateIpv6EgressOnlyRuleRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string CreateIpv6EgressOnlyRuleRequest::getInstanceType()const
-{
-	return instanceType_;
+void CreateIpv6EgressOnlyRuleRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void CreateIpv6EgressOnlyRuleRequest::setInstanceType(const std::string& instanceType)
-{
-	instanceType_ = instanceType;
-	setParameter("InstanceType", instanceType);
+std::string CreateIpv6EgressOnlyRuleRequest::getInstanceType() const {
+  return instanceType_;
 }
 
-std::string CreateIpv6EgressOnlyRuleRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void CreateIpv6EgressOnlyRuleRequest::setInstanceType(const std::string &instanceType) {
+  instanceType_ = instanceType;
+  setParameter(std::string("InstanceType"), instanceType);
 }
 
-void CreateIpv6EgressOnlyRuleRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string CreateIpv6EgressOnlyRuleRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string CreateIpv6EgressOnlyRuleRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void CreateIpv6EgressOnlyRuleRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void CreateIpv6EgressOnlyRuleRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string CreateIpv6EgressOnlyRuleRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long CreateIpv6EgressOnlyRuleRequest::getOwnerId()const
-{
-	return ownerId_;
+void CreateIpv6EgressOnlyRuleRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void CreateIpv6EgressOnlyRuleRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long CreateIpv6EgressOnlyRuleRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string CreateIpv6EgressOnlyRuleRequest::getInstanceId()const
-{
-	return instanceId_;
+void CreateIpv6EgressOnlyRuleRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void CreateIpv6EgressOnlyRuleRequest::setInstanceId(const std::string& instanceId)
-{
-	instanceId_ = instanceId;
-	setParameter("InstanceId", instanceId);
+std::string CreateIpv6EgressOnlyRuleRequest::getInstanceId() const {
+  return instanceId_;
 }
 
-std::string CreateIpv6EgressOnlyRuleRequest::getIpv6GatewayId()const
-{
-	return ipv6GatewayId_;
+void CreateIpv6EgressOnlyRuleRequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setParameter(std::string("InstanceId"), instanceId);
 }
 
-void CreateIpv6EgressOnlyRuleRequest::setIpv6GatewayId(const std::string& ipv6GatewayId)
-{
-	ipv6GatewayId_ = ipv6GatewayId;
-	setParameter("Ipv6GatewayId", ipv6GatewayId);
+std::string CreateIpv6EgressOnlyRuleRequest::getIpv6GatewayId() const {
+  return ipv6GatewayId_;
 }
 
-std::string CreateIpv6EgressOnlyRuleRequest::getName()const
-{
-	return name_;
+void CreateIpv6EgressOnlyRuleRequest::setIpv6GatewayId(const std::string &ipv6GatewayId) {
+  ipv6GatewayId_ = ipv6GatewayId;
+  setParameter(std::string("Ipv6GatewayId"), ipv6GatewayId);
 }
 
-void CreateIpv6EgressOnlyRuleRequest::setName(const std::string& name)
-{
-	name_ = name;
-	setParameter("Name", name);
+std::string CreateIpv6EgressOnlyRuleRequest::getName() const {
+  return name_;
+}
+
+void CreateIpv6EgressOnlyRuleRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
 }
 

vpc/src/model/CreateIpv6GatewayRequest.cc

@@ -1,139 +1,117 @@
 /*
  * 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/vpc/model/CreateIpv6GatewayRequest.h>
-
-using AlibabaCloud::Vpc::Model::CreateIpv6GatewayRequest;
-
-CreateIpv6GatewayRequest::CreateIpv6GatewayRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "CreateIpv6Gateway")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateIpv6GatewayRequest::~CreateIpv6GatewayRequest()
-{}
-
-long CreateIpv6GatewayRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/CreateIpv6GatewayRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreateIpv6GatewayRequest;
+
+CreateIpv6GatewayRequest::CreateIpv6GatewayRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CreateIpv6Gateway") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CreateIpv6GatewayRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+CreateIpv6GatewayRequest::~CreateIpv6GatewayRequest() {}
+
+long CreateIpv6GatewayRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string CreateIpv6GatewayRequest::getClientToken()const
-{
-	return clientToken_;
+void CreateIpv6GatewayRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void CreateIpv6GatewayRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string CreateIpv6GatewayRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string CreateIpv6GatewayRequest::getDescription()const
-{
-	return description_;
+void CreateIpv6GatewayRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void CreateIpv6GatewayRequest::setDescription(const std::string& description)
-{
-	description_ = description;
-	setParameter("Description", description);
+std::string CreateIpv6GatewayRequest::getDescription() const {
+  return description_;
 }
 
-std::string CreateIpv6GatewayRequest::getSpec()const
-{
-	return spec_;
+void CreateIpv6GatewayRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
 }
 
-void CreateIpv6GatewayRequest::setSpec(const std::string& spec)
-{
-	spec_ = spec;
-	setParameter("Spec", spec);
+std::string CreateIpv6GatewayRequest::getSpec() const {
+  return spec_;
 }
 
-std::string CreateIpv6GatewayRequest::getRegionId()const
-{
-	return regionId_;
+void CreateIpv6GatewayRequest::setSpec(const std::string &spec) {
+  spec_ = spec;
+  setParameter(std::string("Spec"), spec);
 }
 
-void CreateIpv6GatewayRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string CreateIpv6GatewayRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string CreateIpv6GatewayRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void CreateIpv6GatewayRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void CreateIpv6GatewayRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string CreateIpv6GatewayRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string CreateIpv6GatewayRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void CreateIpv6GatewayRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void CreateIpv6GatewayRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string CreateIpv6GatewayRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long CreateIpv6GatewayRequest::getOwnerId()const
-{
-	return ownerId_;
+void CreateIpv6GatewayRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void CreateIpv6GatewayRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long CreateIpv6GatewayRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string CreateIpv6GatewayRequest::getVpcId()const
-{
-	return vpcId_;
+void CreateIpv6GatewayRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void CreateIpv6GatewayRequest::setVpcId(const std::string& vpcId)
-{
-	vpcId_ = vpcId;
-	setParameter("VpcId", vpcId);
+std::string CreateIpv6GatewayRequest::getVpcId() const {
+  return vpcId_;
 }
 
-std::string CreateIpv6GatewayRequest::getName()const
-{
-	return name_;
+void CreateIpv6GatewayRequest::setVpcId(const std::string &vpcId) {
+  vpcId_ = vpcId;
+  setParameter(std::string("VpcId"), vpcId);
 }
 
-void CreateIpv6GatewayRequest::setName(const std::string& name)
-{
-	name_ = name;
-	setParameter("Name", name);
+std::string CreateIpv6GatewayRequest::getName() const {
+  return name_;
+}
+
+void CreateIpv6GatewayRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
 }
 

vpc/src/model/CreateNatGatewayRequest.cc

@@ -1,235 +1,274 @@
 /*
  * 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/vpc/model/CreateNatGatewayRequest.h>
-
-using AlibabaCloud::Vpc::Model::CreateNatGatewayRequest;
-
-CreateNatGatewayRequest::CreateNatGatewayRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "CreateNatGateway")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateNatGatewayRequest::~CreateNatGatewayRequest()
-{}
-
-long CreateNatGatewayRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/CreateNatGatewayRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreateNatGatewayRequest;
+
+CreateNatGatewayRequest::CreateNatGatewayRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CreateNatGateway") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CreateNatGatewayRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+CreateNatGatewayRequest::~CreateNatGatewayRequest() {}
+
+long CreateNatGatewayRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string CreateNatGatewayRequest::getClientToken()const
-{
-	return clientToken_;
+void CreateNatGatewayRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void CreateNatGatewayRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string CreateNatGatewayRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string CreateNatGatewayRequest::getDescription()const
-{
-	return description_;
+void CreateNatGatewayRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void CreateNatGatewayRequest::setDescription(const std::string& description)
-{
-	description_ = description;
-	setParameter("Description", description);
+bool CreateNatGatewayRequest::getSecurityProtectionEnabled() const {
+  return securityProtectionEnabled_;
 }
 
-std::string CreateNatGatewayRequest::getSpec()const
-{
-	return spec_;
+void CreateNatGatewayRequest::setSecurityProtectionEnabled(bool securityProtectionEnabled) {
+  securityProtectionEnabled_ = securityProtectionEnabled;
+  setParameter(std::string("SecurityProtectionEnabled"), securityProtectionEnabled ? "true" : "false");
 }
 
-void CreateNatGatewayRequest::setSpec(const std::string& spec)
-{
-	spec_ = spec;
-	setParameter("Spec", spec);
+std::string CreateNatGatewayRequest::getSecurityGroupId() const {
+  return securityGroupId_;
 }
 
-std::string CreateNatGatewayRequest::getDuration()const
-{
-	return duration_;
+void CreateNatGatewayRequest::setSecurityGroupId(const std::string &securityGroupId) {
+  securityGroupId_ = securityGroupId;
+  setParameter(std::string("SecurityGroupId"), securityGroupId);
 }
 
-void CreateNatGatewayRequest::setDuration(const std::string& duration)
-{
-	duration_ = duration;
-	setParameter("Duration", duration);
+std::string CreateNatGatewayRequest::getDescription() const {
+  return description_;
 }
 
-std::string CreateNatGatewayRequest::getRegionId()const
-{
-	return regionId_;
+void CreateNatGatewayRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
 }
 
-void CreateNatGatewayRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string CreateNatGatewayRequest::getNetworkType() const {
+  return networkType_;
 }
 
-std::string CreateNatGatewayRequest::getNatType()const
-{
-	return natType_;
+void CreateNatGatewayRequest::setNetworkType(const std::string &networkType) {
+  networkType_ = networkType;
+  setParameter(std::string("NetworkType"), networkType);
 }
 
-void CreateNatGatewayRequest::setNatType(const std::string& natType)
-{
-	natType_ = natType;
-	setParameter("NatType", natType);
+std::string CreateNatGatewayRequest::getSpec() const {
+  return spec_;
 }
 
-std::vector<CreateNatGatewayRequest::BandwidthPackage> CreateNatGatewayRequest::getBandwidthPackage()const
-{
-	return bandwidthPackage_;
+void CreateNatGatewayRequest::setSpec(const std::string &spec) {
+  spec_ = spec;
+  setParameter(std::string("Spec"), spec);
 }
 
-void CreateNatGatewayRequest::setBandwidthPackage(const std::vector<BandwidthPackage>& bandwidthPackage)
-{
-	bandwidthPackage_ = bandwidthPackage;
-	for(int dep1 = 0; dep1!= bandwidthPackage.size(); dep1++) {
-		auto bandwidthPackageObj = bandwidthPackage.at(dep1);
-		std::string bandwidthPackageObjStr = "BandwidthPackage." + std::to_string(dep1 + 1);
-		setParameter(bandwidthPackageObjStr + ".Bandwidth", std::to_string(bandwidthPackageObj.bandwidth));
-		setParameter(bandwidthPackageObjStr + ".Zone", bandwidthPackageObj.zone);
-		setParameter(bandwidthPackageObjStr + ".InternetChargeType", bandwidthPackageObj.internetChargeType);
-		setParameter(bandwidthPackageObjStr + ".ISP", bandwidthPackageObj.iSP);
-		setParameter(bandwidthPackageObjStr + ".IpCount", std::to_string(bandwidthPackageObj.ipCount));
-	}
+std::string CreateNatGatewayRequest::getDuration() const {
+  return duration_;
 }
 
-std::string CreateNatGatewayRequest::getInstanceChargeType()const
-{
-	return instanceChargeType_;
+void CreateNatGatewayRequest::setDuration(const std::string &duration) {
+  duration_ = duration;
+  setParameter(std::string("Duration"), duration);
 }
 
-void CreateNatGatewayRequest::setInstanceChargeType(const std::string& instanceChargeType)
-{
-	instanceChargeType_ = instanceChargeType;
-	setParameter("InstanceChargeType", instanceChargeType);
+bool CreateNatGatewayRequest::getIcmpReplyEnabled() const {
+  return icmpReplyEnabled_;
 }
 
-bool CreateNatGatewayRequest::getAutoPay()const
-{
-	return autoPay_;
+void CreateNatGatewayRequest::setIcmpReplyEnabled(bool icmpReplyEnabled) {
+  icmpReplyEnabled_ = icmpReplyEnabled;
+  setParameter(std::string("IcmpReplyEnabled"), icmpReplyEnabled ? "true" : "false");
 }
 
-void CreateNatGatewayRequest::setAutoPay(bool autoPay)
-{
-	autoPay_ = autoPay;
-	setParameter("AutoPay", autoPay ? "true" : "false");
+std::string CreateNatGatewayRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string CreateNatGatewayRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void CreateNatGatewayRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void CreateNatGatewayRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string CreateNatGatewayRequest::getNatType() const {
+  return natType_;
 }
 
-std::string CreateNatGatewayRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void CreateNatGatewayRequest::setNatType(const std::string &natType) {
+  natType_ = natType;
+  setParameter(std::string("NatType"), natType);
 }
 
-void CreateNatGatewayRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::vector<CreateNatGatewayRequest::Tag> CreateNatGatewayRequest::getTag() const {
+  return tag_;
 }
 
-long CreateNatGatewayRequest::getOwnerId()const
-{
-	return ownerId_;
+void CreateNatGatewayRequest::setTag(const std::vector<CreateNatGatewayRequest::Tag> &tag) {
+  tag_ = tag;
+  for(int dep1 = 0; dep1 != tag.size(); dep1++) {
+  auto tagObj = tag.at(dep1);
+  std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1);
+    setParameter(tagObjStr + ".Value", tagObj.value);
+    setParameter(tagObjStr + ".Key", tagObj.key);
+  }
 }
 
-void CreateNatGatewayRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+std::string CreateNatGatewayRequest::getInstanceChargeType() const {
+  return instanceChargeType_;
 }
 
-std::string CreateNatGatewayRequest::getVSwitchId()const
-{
-	return vSwitchId_;
+void CreateNatGatewayRequest::setInstanceChargeType(const std::string &instanceChargeType) {
+  instanceChargeType_ = instanceChargeType;
+  setParameter(std::string("InstanceChargeType"), instanceChargeType);
 }
 
-void CreateNatGatewayRequest::setVSwitchId(const std::string& vSwitchId)
-{
-	vSwitchId_ = vSwitchId;
-	setParameter("VSwitchId", vSwitchId);
+std::vector<CreateNatGatewayRequest::BandwidthPackage> CreateNatGatewayRequest::getBandwidthPackage() const {
+  return bandwidthPackage_;
 }
 
-std::string CreateNatGatewayRequest::getInternetChargeType()const
-{
-	return internetChargeType_;
+void CreateNatGatewayRequest::setBandwidthPackage(const std::vector<CreateNatGatewayRequest::BandwidthPackage> &bandwidthPackage) {
+  bandwidthPackage_ = bandwidthPackage;
+  for(int dep1 = 0; dep1 != bandwidthPackage.size(); dep1++) {
+  auto bandwidthPackageObj = bandwidthPackage.at(dep1);
+  std::string bandwidthPackageObjStr = std::string("BandwidthPackage") + "." + std::to_string(dep1 + 1);
+    setParameter(bandwidthPackageObjStr + ".Bandwidth", std::to_string(bandwidthPackageObj.bandwidth));
+    setParameter(bandwidthPackageObjStr + ".Zone", bandwidthPackageObj.zone);
+    setParameter(bandwidthPackageObjStr + ".InternetChargeType", bandwidthPackageObj.internetChargeType);
+    setParameter(bandwidthPackageObjStr + ".ISP", bandwidthPackageObj.iSP);
+    setParameter(bandwidthPackageObjStr + ".IpCount", std::to_string(bandwidthPackageObj.ipCount));
+  }
 }
 
-void CreateNatGatewayRequest::setInternetChargeType(const std::string& internetChargeType)
-{
-	internetChargeType_ = internetChargeType;
-	setParameter("InternetChargeType", internetChargeType);
+bool CreateNatGatewayRequest::getAutoPay() const {
+  return autoPay_;
 }
 
-std::string CreateNatGatewayRequest::getVpcId()const
-{
-	return vpcId_;
+void CreateNatGatewayRequest::setAutoPay(bool autoPay) {
+  autoPay_ = autoPay;
+  setParameter(std::string("AutoPay"), autoPay ? "true" : "false");
 }
 
-void CreateNatGatewayRequest::setVpcId(const std::string& vpcId)
-{
-	vpcId_ = vpcId;
-	setParameter("VpcId", vpcId);
+std::string CreateNatGatewayRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string CreateNatGatewayRequest::getName()const
-{
-	return name_;
+void CreateNatGatewayRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void CreateNatGatewayRequest::setName(const std::string& name)
-{
-	name_ = name;
-	setParameter("Name", name);
+std::string CreateNatGatewayRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-std::string CreateNatGatewayRequest::getPricingCycle()const
-{
-	return pricingCycle_;
+void CreateNatGatewayRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void CreateNatGatewayRequest::setPricingCycle(const std::string& pricingCycle)
-{
-	pricingCycle_ = pricingCycle;
-	setParameter("PricingCycle", pricingCycle);
+std::string CreateNatGatewayRequest::getPrivateLinkMode() const {
+  return privateLinkMode_;
+}
+
+void CreateNatGatewayRequest::setPrivateLinkMode(const std::string &privateLinkMode) {
+  privateLinkMode_ = privateLinkMode;
+  setParameter(std::string("PrivateLinkMode"), privateLinkMode);
+}
+
+long CreateNatGatewayRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CreateNatGatewayRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string CreateNatGatewayRequest::getVSwitchId() const {
+  return vSwitchId_;
+}
+
+void CreateNatGatewayRequest::setVSwitchId(const std::string &vSwitchId) {
+  vSwitchId_ = vSwitchId;
+  setParameter(std::string("VSwitchId"), vSwitchId);
+}
+
+std::string CreateNatGatewayRequest::getInternetChargeType() const {
+  return internetChargeType_;
+}
+
+void CreateNatGatewayRequest::setInternetChargeType(const std::string &internetChargeType) {
+  internetChargeType_ = internetChargeType;
+  setParameter(std::string("InternetChargeType"), internetChargeType);
+}
+
+std::string CreateNatGatewayRequest::getVpcId() const {
+  return vpcId_;
+}
+
+void CreateNatGatewayRequest::setVpcId(const std::string &vpcId) {
+  vpcId_ = vpcId;
+  setParameter(std::string("VpcId"), vpcId);
+}
+
+std::string CreateNatGatewayRequest::getName() const {
+  return name_;
+}
+
+void CreateNatGatewayRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
+}
+
+bool CreateNatGatewayRequest::getPrivateLinkEnabled() const {
+  return privateLinkEnabled_;
+}
+
+void CreateNatGatewayRequest::setPrivateLinkEnabled(bool privateLinkEnabled) {
+  privateLinkEnabled_ = privateLinkEnabled;
+  setParameter(std::string("PrivateLinkEnabled"), privateLinkEnabled ? "true" : "false");
+}
+
+std::string CreateNatGatewayRequest::getEipBindMode() const {
+  return eipBindMode_;
+}
+
+void CreateNatGatewayRequest::setEipBindMode(const std::string &eipBindMode) {
+  eipBindMode_ = eipBindMode;
+  setParameter(std::string("EipBindMode"), eipBindMode);
+}
+
+std::string CreateNatGatewayRequest::getPricingCycle() const {
+  return pricingCycle_;
+}
+
+void CreateNatGatewayRequest::setPricingCycle(const std::string &pricingCycle) {
+  pricingCycle_ = pricingCycle;
+  setParameter(std::string("PricingCycle"), pricingCycle);
 }
 

vpc/src/model/CreateNatGatewayResult.cc

@@ -48,6 +48,9 @@ void CreateNatGatewayResult::parse(const std::string &payload)
 	auto allBandwidthPackageIds = value["BandwidthPackageIds"]["BandwidthPackageId"];
 	for (const auto &item : allBandwidthPackageIds)
 		bandwidthPackageIds_.push_back(item.asString());
+	auto allFullNatTableIds = value["FullNatTableIds"]["FullNatTableId"];
+	for (const auto &item : allFullNatTableIds)
+		fullNatTableIds_.push_back(item.asString());
 	if(!value["NatGatewayId"].isNull())
 		natGatewayId_ = value["NatGatewayId"].asString();
 
@@ -63,6 +66,11 @@ std::vector<std::string> CreateNatGatewayResult::getForwardTableIds()const
 	return forwardTableIds_;
 }
 
+std::vector<std::string> CreateNatGatewayResult::getFullNatTableIds()const
+{
+	return fullNatTableIds_;
+}
+
 std::vector<std::string> CreateNatGatewayResult::getBandwidthPackageIds()const
 {
 	return bandwidthPackageIds_;

vpc/src/model/CreateNatIpCidrRequest.cc

@@ -0,0 +1,126 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/vpc/model/CreateNatIpCidrRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreateNatIpCidrRequest;
+
+CreateNatIpCidrRequest::CreateNatIpCidrRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CreateNatIpCidr") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateNatIpCidrRequest::~CreateNatIpCidrRequest() {}
+
+std::string CreateNatIpCidrRequest::getNatIpCidrDescription() const {
+  return natIpCidrDescription_;
+}
+
+void CreateNatIpCidrRequest::setNatIpCidrDescription(const std::string &natIpCidrDescription) {
+  natIpCidrDescription_ = natIpCidrDescription;
+  setParameter(std::string("NatIpCidrDescription"), natIpCidrDescription);
+}
+
+long CreateNatIpCidrRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void CreateNatIpCidrRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string CreateNatIpCidrRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void CreateNatIpCidrRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string CreateNatIpCidrRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateNatIpCidrRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string CreateNatIpCidrRequest::getNatGatewayId() const {
+  return natGatewayId_;
+}
+
+void CreateNatIpCidrRequest::setNatGatewayId(const std::string &natGatewayId) {
+  natGatewayId_ = natGatewayId;
+  setParameter(std::string("NatGatewayId"), natGatewayId);
+}
+
+bool CreateNatIpCidrRequest::getDryRun() const {
+  return dryRun_;
+}
+
+void CreateNatIpCidrRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setParameter(std::string("DryRun"), dryRun ? "true" : "false");
+}
+
+std::string CreateNatIpCidrRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void CreateNatIpCidrRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string CreateNatIpCidrRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void CreateNatIpCidrRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+std::string CreateNatIpCidrRequest::getNatIpCidrName() const {
+  return natIpCidrName_;
+}
+
+void CreateNatIpCidrRequest::setNatIpCidrName(const std::string &natIpCidrName) {
+  natIpCidrName_ = natIpCidrName;
+  setParameter(std::string("NatIpCidrName"), natIpCidrName);
+}
+
+long CreateNatIpCidrRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CreateNatIpCidrRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string CreateNatIpCidrRequest::getNatIpCidr() const {
+  return natIpCidr_;
+}
+
+void CreateNatIpCidrRequest::setNatIpCidr(const std::string &natIpCidr) {
+  natIpCidr_ = natIpCidr;
+  setParameter(std::string("NatIpCidr"), natIpCidr);
+}
+

vpc/src/model/CreateNatIpCidrResult.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/vpc/model/CreateNatIpCidrResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vpc;
+using namespace AlibabaCloud::Vpc::Model;
+
+CreateNatIpCidrResult::CreateNatIpCidrResult() :
+	ServiceResult()
+{}
+
+CreateNatIpCidrResult::CreateNatIpCidrResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateNatIpCidrResult::~CreateNatIpCidrResult()
+{}
+
+void CreateNatIpCidrResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["NatIpCidrId"].isNull())
+		natIpCidrId_ = value["NatIpCidrId"].asString();
+
+}
+
+std::string CreateNatIpCidrResult::getNatIpCidrId()const
+{
+	return natIpCidrId_;
+}
+

vpc/src/model/CreateNatIpRequest.cc

@@ -0,0 +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/vpc/model/CreateNatIpRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreateNatIpRequest;
+
+CreateNatIpRequest::CreateNatIpRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CreateNatIp") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateNatIpRequest::~CreateNatIpRequest() {}
+
+std::string CreateNatIpRequest::getNatIpCidrId() const {
+  return natIpCidrId_;
+}
+
+void CreateNatIpRequest::setNatIpCidrId(const std::string &natIpCidrId) {
+  natIpCidrId_ = natIpCidrId;
+  setParameter(std::string("NatIpCidrId"), natIpCidrId);
+}
+
+long CreateNatIpRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void CreateNatIpRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string CreateNatIpRequest::getNatIpName() const {
+  return natIpName_;
+}
+
+void CreateNatIpRequest::setNatIpName(const std::string &natIpName) {
+  natIpName_ = natIpName;
+  setParameter(std::string("NatIpName"), natIpName);
+}
+
+std::string CreateNatIpRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void CreateNatIpRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string CreateNatIpRequest::getNatIpDescription() const {
+  return natIpDescription_;
+}
+
+void CreateNatIpRequest::setNatIpDescription(const std::string &natIpDescription) {
+  natIpDescription_ = natIpDescription;
+  setParameter(std::string("NatIpDescription"), natIpDescription);
+}
+
+std::string CreateNatIpRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateNatIpRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string CreateNatIpRequest::getNatGatewayId() const {
+  return natGatewayId_;
+}
+
+void CreateNatIpRequest::setNatGatewayId(const std::string &natGatewayId) {
+  natGatewayId_ = natGatewayId;
+  setParameter(std::string("NatGatewayId"), natGatewayId);
+}
+
+bool CreateNatIpRequest::getDryRun() const {
+  return dryRun_;
+}
+
+void CreateNatIpRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setParameter(std::string("DryRun"), dryRun ? "true" : "false");
+}
+
+std::string CreateNatIpRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void CreateNatIpRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string CreateNatIpRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void CreateNatIpRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long CreateNatIpRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CreateNatIpRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string CreateNatIpRequest::getNatIpCidr() const {
+  return natIpCidr_;
+}
+
+void CreateNatIpRequest::setNatIpCidr(const std::string &natIpCidr) {
+  natIpCidr_ = natIpCidr;
+  setParameter(std::string("NatIpCidr"), natIpCidr);
+}
+
+std::string CreateNatIpRequest::getNatIp() const {
+  return natIp_;
+}
+
+void CreateNatIpRequest::setNatIp(const std::string &natIp) {
+  natIp_ = natIp;
+  setParameter(std::string("NatIp"), natIp);
+}
+

vpc/src/model/CreateNatIpResult.cc

@@ -14,31 +14,45 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/vpc/model/ModifyCommonBandwidthPackageInternetChargeTypeResult.h>
+#include <alibabacloud/vpc/model/CreateNatIpResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Vpc;
 using namespace AlibabaCloud::Vpc::Model;
 
-ModifyCommonBandwidthPackageInternetChargeTypeResult::ModifyCommonBandwidthPackageInternetChargeTypeResult() :
+CreateNatIpResult::CreateNatIpResult() :
 	ServiceResult()
 {}
 
-ModifyCommonBandwidthPackageInternetChargeTypeResult::ModifyCommonBandwidthPackageInternetChargeTypeResult(const std::string &payload) :
+CreateNatIpResult::CreateNatIpResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-ModifyCommonBandwidthPackageInternetChargeTypeResult::~ModifyCommonBandwidthPackageInternetChargeTypeResult()
+CreateNatIpResult::~CreateNatIpResult()
 {}
 
-void ModifyCommonBandwidthPackageInternetChargeTypeResult::parse(const std::string &payload)
+void CreateNatIpResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
+	if(!value["NatIp"].isNull())
+		natIp_ = value["NatIp"].asString();
+	if(!value["NatIpId"].isNull())
+		natIpId_ = value["NatIpId"].asString();
 
 }
 
+std::string CreateNatIpResult::getNatIp()const
+{
+	return natIp_;
+}
+
+std::string CreateNatIpResult::getNatIpId()const
+{
+	return natIpId_;
+}
+

vpc/src/model/CreateNetworkAclRequest.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/vpc/model/CreateNetworkAclRequest.h>
-
-using AlibabaCloud::Vpc::Model::CreateNetworkAclRequest;
-
-CreateNetworkAclRequest::CreateNetworkAclRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "CreateNetworkAcl")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateNetworkAclRequest::~CreateNetworkAclRequest()
-{}
-
-long CreateNetworkAclRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/CreateNetworkAclRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreateNetworkAclRequest;
+
+CreateNetworkAclRequest::CreateNetworkAclRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CreateNetworkAcl") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CreateNetworkAclRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+CreateNetworkAclRequest::~CreateNetworkAclRequest() {}
+
+long CreateNetworkAclRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string CreateNetworkAclRequest::getClientToken()const
-{
-	return clientToken_;
+void CreateNetworkAclRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void CreateNetworkAclRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string CreateNetworkAclRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string CreateNetworkAclRequest::getDescription()const
-{
-	return description_;
+void CreateNetworkAclRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void CreateNetworkAclRequest::setDescription(const std::string& description)
-{
-	description_ = description;
-	setParameter("Description", description);
+std::string CreateNetworkAclRequest::getDescription() const {
+  return description_;
 }
 
-std::string CreateNetworkAclRequest::getRegionId()const
-{
-	return regionId_;
+void CreateNetworkAclRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
 }
 
-void CreateNetworkAclRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string CreateNetworkAclRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string CreateNetworkAclRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void CreateNetworkAclRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void CreateNetworkAclRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string CreateNetworkAclRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string CreateNetworkAclRequest::getNetworkAclName()const
-{
-	return networkAclName_;
+void CreateNetworkAclRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void CreateNetworkAclRequest::setNetworkAclName(const std::string& networkAclName)
-{
-	networkAclName_ = networkAclName;
-	setParameter("NetworkAclName", networkAclName);
+std::string CreateNetworkAclRequest::getNetworkAclName() const {
+  return networkAclName_;
 }
 
-long CreateNetworkAclRequest::getOwnerId()const
-{
-	return ownerId_;
+void CreateNetworkAclRequest::setNetworkAclName(const std::string &networkAclName) {
+  networkAclName_ = networkAclName;
+  setParameter(std::string("NetworkAclName"), networkAclName);
 }
 
-void CreateNetworkAclRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long CreateNetworkAclRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string CreateNetworkAclRequest::getVpcId()const
-{
-	return vpcId_;
+void CreateNetworkAclRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void CreateNetworkAclRequest::setVpcId(const std::string& vpcId)
-{
-	vpcId_ = vpcId;
-	setParameter("VpcId", vpcId);
+std::string CreateNetworkAclRequest::getVpcId() const {
+  return vpcId_;
+}
+
+void CreateNetworkAclRequest::setVpcId(const std::string &vpcId) {
+  vpcId_ = vpcId;
+  setParameter(std::string("VpcId"), vpcId);
 }
 

vpc/src/model/CreateNetworkAclResult.cc

@@ -40,40 +40,40 @@ void CreateNetworkAclResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto networkAclAttributeNode = value["NetworkAclAttribute"];
-	if(!networkAclAttributeNode["NetworkAclId"].isNull())
-		networkAclAttribute_.networkAclId = networkAclAttributeNode["NetworkAclId"].asString();
-	if(!networkAclAttributeNode["RegionId"].isNull())
-		networkAclAttribute_.regionId = networkAclAttributeNode["RegionId"].asString();
-	if(!networkAclAttributeNode["NetworkAclName"].isNull())
-		networkAclAttribute_.networkAclName = networkAclAttributeNode["NetworkAclName"].asString();
-	if(!networkAclAttributeNode["Description"].isNull())
-		networkAclAttribute_.description = networkAclAttributeNode["Description"].asString();
+	if(!networkAclAttributeNode["Status"].isNull())
+		networkAclAttribute_.status = networkAclAttributeNode["Status"].asString();
 	if(!networkAclAttributeNode["VpcId"].isNull())
 		networkAclAttribute_.vpcId = networkAclAttributeNode["VpcId"].asString();
 	if(!networkAclAttributeNode["CreationTime"].isNull())
 		networkAclAttribute_.creationTime = networkAclAttributeNode["CreationTime"].asString();
-	if(!networkAclAttributeNode["Status"].isNull())
-		networkAclAttribute_.status = networkAclAttributeNode["Status"].asString();
+	if(!networkAclAttributeNode["Description"].isNull())
+		networkAclAttribute_.description = networkAclAttributeNode["Description"].asString();
+	if(!networkAclAttributeNode["NetworkAclName"].isNull())
+		networkAclAttribute_.networkAclName = networkAclAttributeNode["NetworkAclName"].asString();
+	if(!networkAclAttributeNode["NetworkAclId"].isNull())
+		networkAclAttribute_.networkAclId = networkAclAttributeNode["NetworkAclId"].asString();
+	if(!networkAclAttributeNode["RegionId"].isNull())
+		networkAclAttribute_.regionId = networkAclAttributeNode["RegionId"].asString();
 	auto allIngressAclEntriesNode = networkAclAttributeNode["IngressAclEntries"]["IngressAclEntry"];
 	for (auto networkAclAttributeNodeIngressAclEntriesIngressAclEntry : allIngressAclEntriesNode)
 	{
 		NetworkAclAttribute::IngressAclEntry ingressAclEntryObject;
 		if(!networkAclAttributeNodeIngressAclEntriesIngressAclEntry["NetworkAclEntryId"].isNull())
 			ingressAclEntryObject.networkAclEntryId = networkAclAttributeNodeIngressAclEntriesIngressAclEntry["NetworkAclEntryId"].asString();
-		if(!networkAclAttributeNodeIngressAclEntriesIngressAclEntry["Policy"].isNull())
-			ingressAclEntryObject.policy = networkAclAttributeNodeIngressAclEntriesIngressAclEntry["Policy"].asString();
-		if(!networkAclAttributeNodeIngressAclEntriesIngressAclEntry["Protocol"].isNull())
-			ingressAclEntryObject.protocol = networkAclAttributeNodeIngressAclEntriesIngressAclEntry["Protocol"].asString();
-		if(!networkAclAttributeNodeIngressAclEntriesIngressAclEntry["SourceCidrIp"].isNull())
-			ingressAclEntryObject.sourceCidrIp = networkAclAttributeNodeIngressAclEntriesIngressAclEntry["SourceCidrIp"].asString();
-		if(!networkAclAttributeNodeIngressAclEntriesIngressAclEntry["Port"].isNull())
-			ingressAclEntryObject.port = networkAclAttributeNodeIngressAclEntriesIngressAclEntry["Port"].asString();
 		if(!networkAclAttributeNodeIngressAclEntriesIngressAclEntry["EntryType"].isNull())
 			ingressAclEntryObject.entryType = networkAclAttributeNodeIngressAclEntriesIngressAclEntry["EntryType"].asString();
 		if(!networkAclAttributeNodeIngressAclEntriesIngressAclEntry["NetworkAclEntryName"].isNull())
 			ingressAclEntryObject.networkAclEntryName = networkAclAttributeNodeIngressAclEntriesIngressAclEntry["NetworkAclEntryName"].asString();
+		if(!networkAclAttributeNodeIngressAclEntriesIngressAclEntry["Policy"].isNull())
+			ingressAclEntryObject.policy = networkAclAttributeNodeIngressAclEntriesIngressAclEntry["Policy"].asString();
 		if(!networkAclAttributeNodeIngressAclEntriesIngressAclEntry["Description"].isNull())
 			ingressAclEntryObject.description = networkAclAttributeNodeIngressAclEntriesIngressAclEntry["Description"].asString();
+		if(!networkAclAttributeNodeIngressAclEntriesIngressAclEntry["SourceCidrIp"].isNull())
+			ingressAclEntryObject.sourceCidrIp = networkAclAttributeNodeIngressAclEntriesIngressAclEntry["SourceCidrIp"].asString();
+		if(!networkAclAttributeNodeIngressAclEntriesIngressAclEntry["Protocol"].isNull())
+			ingressAclEntryObject.protocol = networkAclAttributeNodeIngressAclEntriesIngressAclEntry["Protocol"].asString();
+		if(!networkAclAttributeNodeIngressAclEntriesIngressAclEntry["Port"].isNull())
+			ingressAclEntryObject.port = networkAclAttributeNodeIngressAclEntriesIngressAclEntry["Port"].asString();
 		networkAclAttribute_.ingressAclEntries.push_back(ingressAclEntryObject);
 	}
 	auto allEgressAclEntriesNode = networkAclAttributeNode["EgressAclEntries"]["EgressAclEntry"];
@@ -82,32 +82,32 @@ void CreateNetworkAclResult::parse(const std::string &payload)
 		NetworkAclAttribute::EgressAclEntry egressAclEntryObject;
 		if(!networkAclAttributeNodeEgressAclEntriesEgressAclEntry["NetworkAclEntryId"].isNull())
 			egressAclEntryObject.networkAclEntryId = networkAclAttributeNodeEgressAclEntriesEgressAclEntry["NetworkAclEntryId"].asString();
+		if(!networkAclAttributeNodeEgressAclEntriesEgressAclEntry["EntryType"].isNull())
+			egressAclEntryObject.entryType = networkAclAttributeNodeEgressAclEntriesEgressAclEntry["EntryType"].asString();
+		if(!networkAclAttributeNodeEgressAclEntriesEgressAclEntry["NetworkAclEntryName"].isNull())
+			egressAclEntryObject.networkAclEntryName = networkAclAttributeNodeEgressAclEntriesEgressAclEntry["NetworkAclEntryName"].asString();
 		if(!networkAclAttributeNodeEgressAclEntriesEgressAclEntry["Policy"].isNull())
 			egressAclEntryObject.policy = networkAclAttributeNodeEgressAclEntriesEgressAclEntry["Policy"].asString();
+		if(!networkAclAttributeNodeEgressAclEntriesEgressAclEntry["Description"].isNull())
+			egressAclEntryObject.description = networkAclAttributeNodeEgressAclEntriesEgressAclEntry["Description"].asString();
 		if(!networkAclAttributeNodeEgressAclEntriesEgressAclEntry["Protocol"].isNull())
 			egressAclEntryObject.protocol = networkAclAttributeNodeEgressAclEntriesEgressAclEntry["Protocol"].asString();
 		if(!networkAclAttributeNodeEgressAclEntriesEgressAclEntry["DestinationCidrIp"].isNull())
 			egressAclEntryObject.destinationCidrIp = networkAclAttributeNodeEgressAclEntriesEgressAclEntry["DestinationCidrIp"].asString();
 		if(!networkAclAttributeNodeEgressAclEntriesEgressAclEntry["Port"].isNull())
 			egressAclEntryObject.port = networkAclAttributeNodeEgressAclEntriesEgressAclEntry["Port"].asString();
-		if(!networkAclAttributeNodeEgressAclEntriesEgressAclEntry["EntryType"].isNull())
-			egressAclEntryObject.entryType = networkAclAttributeNodeEgressAclEntriesEgressAclEntry["EntryType"].asString();
-		if(!networkAclAttributeNodeEgressAclEntriesEgressAclEntry["Description"].isNull())
-			egressAclEntryObject.description = networkAclAttributeNodeEgressAclEntriesEgressAclEntry["Description"].asString();
-		if(!networkAclAttributeNodeEgressAclEntriesEgressAclEntry["NetworkAclEntryName"].isNull())
-			egressAclEntryObject.networkAclEntryName = networkAclAttributeNodeEgressAclEntriesEgressAclEntry["NetworkAclEntryName"].asString();
 		networkAclAttribute_.egressAclEntries.push_back(egressAclEntryObject);
 	}
 	auto allResourcesNode = networkAclAttributeNode["Resources"]["Resource"];
 	for (auto networkAclAttributeNodeResourcesResource : allResourcesNode)
 	{
 		NetworkAclAttribute::Resource resourceObject;
-		if(!networkAclAttributeNodeResourcesResource["ResourceId"].isNull())
-			resourceObject.resourceId = networkAclAttributeNodeResourcesResource["ResourceId"].asString();
-		if(!networkAclAttributeNodeResourcesResource["ResourceType"].isNull())
-			resourceObject.resourceType = networkAclAttributeNodeResourcesResource["ResourceType"].asString();
 		if(!networkAclAttributeNodeResourcesResource["Status"].isNull())
 			resourceObject.status = networkAclAttributeNodeResourcesResource["Status"].asString();
+		if(!networkAclAttributeNodeResourcesResource["ResourceType"].isNull())
+			resourceObject.resourceType = networkAclAttributeNodeResourcesResource["ResourceType"].asString();
+		if(!networkAclAttributeNodeResourcesResource["ResourceId"].isNull())
+			resourceObject.resourceId = networkAclAttributeNodeResourcesResource["ResourceId"].asString();
 		networkAclAttribute_.resources.push_back(resourceObject);
 	}
 	if(!value["NetworkAclId"].isNull())

vpc/src/model/CreatePhysicalConnectionOccupancyOrderRequest.cc

@@ -1,150 +1,126 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
-
-#include <alibabacloud/vpc/model/CreatePhysicalConnectionOccupancyOrderRequest.h>
-
-using AlibabaCloud::Vpc::Model::CreatePhysicalConnectionOccupancyOrderRequest;
-
-CreatePhysicalConnectionOccupancyOrderRequest::CreatePhysicalConnectionOccupancyOrderRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "CreatePhysicalConnectionOccupancyOrder")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreatePhysicalConnectionOccupancyOrderRequest::~CreatePhysicalConnectionOccupancyOrderRequest()
-{}
-
-long CreatePhysicalConnectionOccupancyOrderRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/CreatePhysicalConnectionOccupancyOrderRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreatePhysicalConnectionOccupancyOrderRequest;
+
+CreatePhysicalConnectionOccupancyOrderRequest::CreatePhysicalConnectionOccupancyOrderRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CreatePhysicalConnectionOccupancyOrder") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CreatePhysicalConnectionOccupancyOrderRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+CreatePhysicalConnectionOccupancyOrderRequest::~CreatePhysicalConnectionOccupancyOrderRequest() {}
+
+long CreatePhysicalConnectionOccupancyOrderRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string CreatePhysicalConnectionOccupancyOrderRequest::getClientToken()const
-{
-	return clientToken_;
+void CreatePhysicalConnectionOccupancyOrderRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void CreatePhysicalConnectionOccupancyOrderRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string CreatePhysicalConnectionOccupancyOrderRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string CreatePhysicalConnectionOccupancyOrderRequest::getRegionId()const
-{
-	return regionId_;
+void CreatePhysicalConnectionOccupancyOrderRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void CreatePhysicalConnectionOccupancyOrderRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string CreatePhysicalConnectionOccupancyOrderRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string CreatePhysicalConnectionOccupancyOrderRequest::getInstanceChargeType()const
-{
-	return instanceChargeType_;
+void CreatePhysicalConnectionOccupancyOrderRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void CreatePhysicalConnectionOccupancyOrderRequest::setInstanceChargeType(const std::string& instanceChargeType)
-{
-	instanceChargeType_ = instanceChargeType;
-	setParameter("InstanceChargeType", instanceChargeType);
+std::string CreatePhysicalConnectionOccupancyOrderRequest::getInstanceChargeType() const {
+  return instanceChargeType_;
 }
 
-int CreatePhysicalConnectionOccupancyOrderRequest::getPeriod()const
-{
-	return period_;
+void CreatePhysicalConnectionOccupancyOrderRequest::setInstanceChargeType(const std::string &instanceChargeType) {
+  instanceChargeType_ = instanceChargeType;
+  setParameter(std::string("InstanceChargeType"), instanceChargeType);
 }
 
-void CreatePhysicalConnectionOccupancyOrderRequest::setPeriod(int period)
-{
-	period_ = period;
-	setParameter("Period", std::to_string(period));
+int CreatePhysicalConnectionOccupancyOrderRequest::getPeriod() const {
+  return period_;
 }
 
-bool CreatePhysicalConnectionOccupancyOrderRequest::getAutoPay()const
-{
-	return autoPay_;
+void CreatePhysicalConnectionOccupancyOrderRequest::setPeriod(int period) {
+  period_ = period;
+  setParameter(std::string("Period"), std::to_string(period));
 }
 
-void CreatePhysicalConnectionOccupancyOrderRequest::setAutoPay(bool autoPay)
-{
-	autoPay_ = autoPay;
-	setParameter("AutoPay", autoPay ? "true" : "false");
+bool CreatePhysicalConnectionOccupancyOrderRequest::getAutoPay() const {
+  return autoPay_;
 }
 
-std::string CreatePhysicalConnectionOccupancyOrderRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void CreatePhysicalConnectionOccupancyOrderRequest::setAutoPay(bool autoPay) {
+  autoPay_ = autoPay;
+  setParameter(std::string("AutoPay"), autoPay ? "true" : "false");
 }
 
-void CreatePhysicalConnectionOccupancyOrderRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string CreatePhysicalConnectionOccupancyOrderRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string CreatePhysicalConnectionOccupancyOrderRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void CreatePhysicalConnectionOccupancyOrderRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void CreatePhysicalConnectionOccupancyOrderRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string CreatePhysicalConnectionOccupancyOrderRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long CreatePhysicalConnectionOccupancyOrderRequest::getOwnerId()const
-{
-	return ownerId_;
+void CreatePhysicalConnectionOccupancyOrderRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void CreatePhysicalConnectionOccupancyOrderRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long CreatePhysicalConnectionOccupancyOrderRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string CreatePhysicalConnectionOccupancyOrderRequest::getPhysicalConnectionId()const
-{
-	return physicalConnectionId_;
+void CreatePhysicalConnectionOccupancyOrderRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void CreatePhysicalConnectionOccupancyOrderRequest::setPhysicalConnectionId(const std::string& physicalConnectionId)
-{
-	physicalConnectionId_ = physicalConnectionId;
-	setParameter("PhysicalConnectionId", physicalConnectionId);
+std::string CreatePhysicalConnectionOccupancyOrderRequest::getPhysicalConnectionId() const {
+  return physicalConnectionId_;
 }
 
-std::string CreatePhysicalConnectionOccupancyOrderRequest::getPricingCycle()const
-{
-	return pricingCycle_;
+void CreatePhysicalConnectionOccupancyOrderRequest::setPhysicalConnectionId(const std::string &physicalConnectionId) {
+  physicalConnectionId_ = physicalConnectionId;
+  setParameter(std::string("PhysicalConnectionId"), physicalConnectionId);
 }
 
-void CreatePhysicalConnectionOccupancyOrderRequest::setPricingCycle(const std::string& pricingCycle)
-{
-	pricingCycle_ = pricingCycle;
-	setParameter("PricingCycle", pricingCycle);
+std::string CreatePhysicalConnectionOccupancyOrderRequest::getPricingCycle() const {
+  return pricingCycle_;
+}
+
+void CreatePhysicalConnectionOccupancyOrderRequest::setPricingCycle(const std::string &pricingCycle) {
+  pricingCycle_ = pricingCycle;
+  setParameter(std::string("PricingCycle"), pricingCycle);
 }
 

vpc/src/model/CreatePhysicalConnectionOccupancyOrderResult.cc

@@ -39,6 +39,14 @@ void CreatePhysicalConnectionOccupancyOrderResult::parse(const std::string &payl
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["OrderId"].isNull())
+		data_.orderId = dataNode["OrderId"].asString();
 
 }
 
+CreatePhysicalConnectionOccupancyOrderResult::Data CreatePhysicalConnectionOccupancyOrderResult::getData()const
+{
+	return data_;
+}
+

vpc/src/model/CreatePhysicalConnectionRequest.cc

@@ -1,205 +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/vpc/model/CreatePhysicalConnectionRequest.h>
-
-using AlibabaCloud::Vpc::Model::CreatePhysicalConnectionRequest;
-
-CreatePhysicalConnectionRequest::CreatePhysicalConnectionRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "CreatePhysicalConnection")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreatePhysicalConnectionRequest::~CreatePhysicalConnectionRequest()
-{}
-
-std::string CreatePhysicalConnectionRequest::getAccessPointId()const
-{
-	return accessPointId_;
+ */
+
+#include <alibabacloud/vpc/model/CreatePhysicalConnectionRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreatePhysicalConnectionRequest;
+
+CreatePhysicalConnectionRequest::CreatePhysicalConnectionRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CreatePhysicalConnection") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CreatePhysicalConnectionRequest::setAccessPointId(const std::string& accessPointId)
-{
-	accessPointId_ = accessPointId;
-	setParameter("AccessPointId", accessPointId);
+CreatePhysicalConnectionRequest::~CreatePhysicalConnectionRequest() {}
+
+std::string CreatePhysicalConnectionRequest::getAccessPointId() const {
+  return accessPointId_;
 }
 
-long CreatePhysicalConnectionRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+void CreatePhysicalConnectionRequest::setAccessPointId(const std::string &accessPointId) {
+  accessPointId_ = accessPointId;
+  setParameter(std::string("AccessPointId"), accessPointId);
 }
 
-void CreatePhysicalConnectionRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+std::string CreatePhysicalConnectionRequest::getCloudBoxInstanceId() const {
+  return cloudBoxInstanceId_;
 }
 
-std::string CreatePhysicalConnectionRequest::getPortType()const
-{
-	return portType_;
+void CreatePhysicalConnectionRequest::setCloudBoxInstanceId(const std::string &cloudBoxInstanceId) {
+  cloudBoxInstanceId_ = cloudBoxInstanceId;
+  setParameter(std::string("CloudBoxInstanceId"), cloudBoxInstanceId);
 }
 
-void CreatePhysicalConnectionRequest::setPortType(const std::string& portType)
-{
-	portType_ = portType;
-	setParameter("PortType", portType);
+long CreatePhysicalConnectionRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string CreatePhysicalConnectionRequest::getCircuitCode()const
-{
-	return circuitCode_;
+void CreatePhysicalConnectionRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void CreatePhysicalConnectionRequest::setCircuitCode(const std::string& circuitCode)
-{
-	circuitCode_ = circuitCode;
-	setParameter("CircuitCode", circuitCode);
+std::string CreatePhysicalConnectionRequest::getPortType() const {
+  return portType_;
 }
 
-std::string CreatePhysicalConnectionRequest::getClientToken()const
-{
-	return clientToken_;
+void CreatePhysicalConnectionRequest::setPortType(const std::string &portType) {
+  portType_ = portType;
+  setParameter(std::string("PortType"), portType);
 }
 
-void CreatePhysicalConnectionRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string CreatePhysicalConnectionRequest::getCircuitCode() const {
+  return circuitCode_;
 }
 
-std::string CreatePhysicalConnectionRequest::getDescription()const
-{
-	return description_;
+void CreatePhysicalConnectionRequest::setCircuitCode(const std::string &circuitCode) {
+  circuitCode_ = circuitCode;
+  setParameter(std::string("CircuitCode"), circuitCode);
 }
 
-void CreatePhysicalConnectionRequest::setDescription(const std::string& description)
-{
-	description_ = description;
-	setParameter("Description", description);
+std::string CreatePhysicalConnectionRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string CreatePhysicalConnectionRequest::getType()const
-{
-	return type_;
+void CreatePhysicalConnectionRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void CreatePhysicalConnectionRequest::setType(const std::string& type)
-{
-	type_ = type;
-	setParameter("Type", type);
+std::string CreatePhysicalConnectionRequest::getDescription() const {
+  return description_;
 }
 
-std::string CreatePhysicalConnectionRequest::getRegionId()const
-{
-	return regionId_;
+void CreatePhysicalConnectionRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
 }
 
-void CreatePhysicalConnectionRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string CreatePhysicalConnectionRequest::getType() const {
+  return type_;
 }
 
-std::string CreatePhysicalConnectionRequest::getRedundantPhysicalConnectionId()const
-{
-	return redundantPhysicalConnectionId_;
+void CreatePhysicalConnectionRequest::setType(const std::string &type) {
+  type_ = type;
+  setParameter(std::string("Type"), type);
 }
 
-void CreatePhysicalConnectionRequest::setRedundantPhysicalConnectionId(const std::string& redundantPhysicalConnectionId)
-{
-	redundantPhysicalConnectionId_ = redundantPhysicalConnectionId;
-	setParameter("RedundantPhysicalConnectionId", redundantPhysicalConnectionId);
+std::string CreatePhysicalConnectionRequest::getResourceGroupId() const {
+  return resourceGroupId_;
 }
 
-std::string CreatePhysicalConnectionRequest::getPeerLocation()const
-{
-	return peerLocation_;
+void CreatePhysicalConnectionRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
 }
 
-void CreatePhysicalConnectionRequest::setPeerLocation(const std::string& peerLocation)
-{
-	peerLocation_ = peerLocation;
-	setParameter("PeerLocation", peerLocation);
+std::string CreatePhysicalConnectionRequest::getRegionId() const {
+  return regionId_;
 }
 
-int CreatePhysicalConnectionRequest::getBandwidth()const
-{
-	return bandwidth_;
+void CreatePhysicalConnectionRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void CreatePhysicalConnectionRequest::setBandwidth(int bandwidth)
-{
-	bandwidth_ = bandwidth;
-	setParameter("Bandwidth", std::to_string(bandwidth));
+std::string CreatePhysicalConnectionRequest::getRedundantPhysicalConnectionId() const {
+  return redundantPhysicalConnectionId_;
 }
 
-std::string CreatePhysicalConnectionRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void CreatePhysicalConnectionRequest::setRedundantPhysicalConnectionId(const std::string &redundantPhysicalConnectionId) {
+  redundantPhysicalConnectionId_ = redundantPhysicalConnectionId;
+  setParameter(std::string("RedundantPhysicalConnectionId"), redundantPhysicalConnectionId);
 }
 
-void CreatePhysicalConnectionRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string CreatePhysicalConnectionRequest::getPeerLocation() const {
+  return peerLocation_;
 }
 
-std::string CreatePhysicalConnectionRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void CreatePhysicalConnectionRequest::setPeerLocation(const std::string &peerLocation) {
+  peerLocation_ = peerLocation;
+  setParameter(std::string("PeerLocation"), peerLocation);
 }
 
-void CreatePhysicalConnectionRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+int CreatePhysicalConnectionRequest::getBandwidth() const {
+  return bandwidth_;
 }
 
-long CreatePhysicalConnectionRequest::getOwnerId()const
-{
-	return ownerId_;
+void CreatePhysicalConnectionRequest::setBandwidth(int bandwidth) {
+  bandwidth_ = bandwidth;
+  setParameter(std::string("bandwidth"), std::to_string(bandwidth));
 }
 
-void CreatePhysicalConnectionRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+std::string CreatePhysicalConnectionRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string CreatePhysicalConnectionRequest::getLineOperator()const
-{
-	return lineOperator_;
+void CreatePhysicalConnectionRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void CreatePhysicalConnectionRequest::setLineOperator(const std::string& lineOperator)
-{
-	lineOperator_ = lineOperator;
-	setParameter("LineOperator", lineOperator);
+std::string CreatePhysicalConnectionRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-std::string CreatePhysicalConnectionRequest::getName()const
-{
-	return name_;
+void CreatePhysicalConnectionRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void CreatePhysicalConnectionRequest::setName(const std::string& name)
-{
-	name_ = name;
-	setParameter("Name", name);
+long CreatePhysicalConnectionRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CreatePhysicalConnectionRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string CreatePhysicalConnectionRequest::getLineOperator() const {
+  return lineOperator_;
+}
+
+void CreatePhysicalConnectionRequest::setLineOperator(const std::string &lineOperator) {
+  lineOperator_ = lineOperator;
+  setParameter(std::string("LineOperator"), lineOperator);
+}
+
+std::string CreatePhysicalConnectionRequest::getName() const {
+  return name_;
+}
+
+void CreatePhysicalConnectionRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
 }
 

vpc/src/model/CreatePhysicalConnectionSetupOrderRequest.cc

@@ -1,150 +1,126 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
-
-#include <alibabacloud/vpc/model/CreatePhysicalConnectionSetupOrderRequest.h>
-
-using AlibabaCloud::Vpc::Model::CreatePhysicalConnectionSetupOrderRequest;
-
-CreatePhysicalConnectionSetupOrderRequest::CreatePhysicalConnectionSetupOrderRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "CreatePhysicalConnectionSetupOrder")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreatePhysicalConnectionSetupOrderRequest::~CreatePhysicalConnectionSetupOrderRequest()
-{}
-
-std::string CreatePhysicalConnectionSetupOrderRequest::getAccessPointId()const
-{
-	return accessPointId_;
+ */
+
+#include <alibabacloud/vpc/model/CreatePhysicalConnectionSetupOrderRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreatePhysicalConnectionSetupOrderRequest;
+
+CreatePhysicalConnectionSetupOrderRequest::CreatePhysicalConnectionSetupOrderRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CreatePhysicalConnectionSetupOrder") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CreatePhysicalConnectionSetupOrderRequest::setAccessPointId(const std::string& accessPointId)
-{
-	accessPointId_ = accessPointId;
-	setParameter("AccessPointId", accessPointId);
+CreatePhysicalConnectionSetupOrderRequest::~CreatePhysicalConnectionSetupOrderRequest() {}
+
+std::string CreatePhysicalConnectionSetupOrderRequest::getAccessPointId() const {
+  return accessPointId_;
 }
 
-long CreatePhysicalConnectionSetupOrderRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+void CreatePhysicalConnectionSetupOrderRequest::setAccessPointId(const std::string &accessPointId) {
+  accessPointId_ = accessPointId;
+  setParameter(std::string("AccessPointId"), accessPointId);
 }
 
-void CreatePhysicalConnectionSetupOrderRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+long CreatePhysicalConnectionSetupOrderRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string CreatePhysicalConnectionSetupOrderRequest::getPortType()const
-{
-	return portType_;
+void CreatePhysicalConnectionSetupOrderRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void CreatePhysicalConnectionSetupOrderRequest::setPortType(const std::string& portType)
-{
-	portType_ = portType;
-	setParameter("PortType", portType);
+std::string CreatePhysicalConnectionSetupOrderRequest::getPortType() const {
+  return portType_;
 }
 
-std::string CreatePhysicalConnectionSetupOrderRequest::getClientToken()const
-{
-	return clientToken_;
+void CreatePhysicalConnectionSetupOrderRequest::setPortType(const std::string &portType) {
+  portType_ = portType;
+  setParameter(std::string("PortType"), portType);
 }
 
-void CreatePhysicalConnectionSetupOrderRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string CreatePhysicalConnectionSetupOrderRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string CreatePhysicalConnectionSetupOrderRequest::getRegionId()const
-{
-	return regionId_;
+void CreatePhysicalConnectionSetupOrderRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void CreatePhysicalConnectionSetupOrderRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string CreatePhysicalConnectionSetupOrderRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string CreatePhysicalConnectionSetupOrderRequest::getRedundantPhysicalConnectionId()const
-{
-	return redundantPhysicalConnectionId_;
+void CreatePhysicalConnectionSetupOrderRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void CreatePhysicalConnectionSetupOrderRequest::setRedundantPhysicalConnectionId(const std::string& redundantPhysicalConnectionId)
-{
-	redundantPhysicalConnectionId_ = redundantPhysicalConnectionId;
-	setParameter("RedundantPhysicalConnectionId", redundantPhysicalConnectionId);
+std::string CreatePhysicalConnectionSetupOrderRequest::getRedundantPhysicalConnectionId() const {
+  return redundantPhysicalConnectionId_;
 }
 
-bool CreatePhysicalConnectionSetupOrderRequest::getAutoPay()const
-{
-	return autoPay_;
+void CreatePhysicalConnectionSetupOrderRequest::setRedundantPhysicalConnectionId(const std::string &redundantPhysicalConnectionId) {
+  redundantPhysicalConnectionId_ = redundantPhysicalConnectionId;
+  setParameter(std::string("RedundantPhysicalConnectionId"), redundantPhysicalConnectionId);
 }
 
-void CreatePhysicalConnectionSetupOrderRequest::setAutoPay(bool autoPay)
-{
-	autoPay_ = autoPay;
-	setParameter("AutoPay", autoPay ? "true" : "false");
+bool CreatePhysicalConnectionSetupOrderRequest::getAutoPay() const {
+  return autoPay_;
 }
 
-std::string CreatePhysicalConnectionSetupOrderRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void CreatePhysicalConnectionSetupOrderRequest::setAutoPay(bool autoPay) {
+  autoPay_ = autoPay;
+  setParameter(std::string("AutoPay"), autoPay ? "true" : "false");
 }
 
-void CreatePhysicalConnectionSetupOrderRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string CreatePhysicalConnectionSetupOrderRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string CreatePhysicalConnectionSetupOrderRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void CreatePhysicalConnectionSetupOrderRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void CreatePhysicalConnectionSetupOrderRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string CreatePhysicalConnectionSetupOrderRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long CreatePhysicalConnectionSetupOrderRequest::getOwnerId()const
-{
-	return ownerId_;
+void CreatePhysicalConnectionSetupOrderRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void CreatePhysicalConnectionSetupOrderRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long CreatePhysicalConnectionSetupOrderRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string CreatePhysicalConnectionSetupOrderRequest::getLineOperator()const
-{
-	return lineOperator_;
+void CreatePhysicalConnectionSetupOrderRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void CreatePhysicalConnectionSetupOrderRequest::setLineOperator(const std::string& lineOperator)
-{
-	lineOperator_ = lineOperator;
-	setParameter("LineOperator", lineOperator);
+std::string CreatePhysicalConnectionSetupOrderRequest::getLineOperator() const {
+  return lineOperator_;
+}
+
+void CreatePhysicalConnectionSetupOrderRequest::setLineOperator(const std::string &lineOperator) {
+  lineOperator_ = lineOperator;
+  setParameter(std::string("LineOperator"), lineOperator);
 }
 

vpc/src/model/CreatePublicIpAddressPoolRequest.cc

@@ -0,0 +1,126 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/vpc/model/CreatePublicIpAddressPoolRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreatePublicIpAddressPoolRequest;
+
+CreatePublicIpAddressPoolRequest::CreatePublicIpAddressPoolRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CreatePublicIpAddressPool") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreatePublicIpAddressPoolRequest::~CreatePublicIpAddressPoolRequest() {}
+
+long CreatePublicIpAddressPoolRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void CreatePublicIpAddressPoolRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string CreatePublicIpAddressPoolRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void CreatePublicIpAddressPoolRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string CreatePublicIpAddressPoolRequest::getIsp() const {
+  return isp_;
+}
+
+void CreatePublicIpAddressPoolRequest::setIsp(const std::string &isp) {
+  isp_ = isp;
+  setParameter(std::string("Isp"), isp);
+}
+
+std::string CreatePublicIpAddressPoolRequest::getDescription() const {
+  return description_;
+}
+
+void CreatePublicIpAddressPoolRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
+}
+
+std::string CreatePublicIpAddressPoolRequest::getResourceGroupId() const {
+  return resourceGroupId_;
+}
+
+void CreatePublicIpAddressPoolRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
+}
+
+std::string CreatePublicIpAddressPoolRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreatePublicIpAddressPoolRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+bool CreatePublicIpAddressPoolRequest::getDryRun() const {
+  return dryRun_;
+}
+
+void CreatePublicIpAddressPoolRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setParameter(std::string("DryRun"), dryRun ? "true" : "false");
+}
+
+std::string CreatePublicIpAddressPoolRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void CreatePublicIpAddressPoolRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string CreatePublicIpAddressPoolRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void CreatePublicIpAddressPoolRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long CreatePublicIpAddressPoolRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CreatePublicIpAddressPoolRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string CreatePublicIpAddressPoolRequest::getName() const {
+  return name_;
+}
+
+void CreatePublicIpAddressPoolRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
+}
+

vpc/src/model/CreatePublicIpAddressPoolResult.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/vpc/model/CreatePublicIpAddressPoolResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vpc;
+using namespace AlibabaCloud::Vpc::Model;
+
+CreatePublicIpAddressPoolResult::CreatePublicIpAddressPoolResult() :
+	ServiceResult()
+{}
+
+CreatePublicIpAddressPoolResult::CreatePublicIpAddressPoolResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreatePublicIpAddressPoolResult::~CreatePublicIpAddressPoolResult()
+{}
+
+void CreatePublicIpAddressPoolResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["PulbicIpAddressPoolId"].isNull())
+		pulbicIpAddressPoolId_ = value["PulbicIpAddressPoolId"].asString();
+	if(!value["ResourceGroupId"].isNull())
+		resourceGroupId_ = value["ResourceGroupId"].asString();
+
+}
+
+std::string CreatePublicIpAddressPoolResult::getResourceGroupId()const
+{
+	return resourceGroupId_;
+}
+
+std::string CreatePublicIpAddressPoolResult::getPulbicIpAddressPoolId()const
+{
+	return pulbicIpAddressPoolId_;
+}
+

vpc/src/model/CreateRouteEntriesRequest.cc

@@ -0,0 +1,91 @@
+/*
+ * 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/vpc/model/CreateRouteEntriesRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreateRouteEntriesRequest;
+
+CreateRouteEntriesRequest::CreateRouteEntriesRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CreateRouteEntries") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateRouteEntriesRequest::~CreateRouteEntriesRequest() {}
+
+long CreateRouteEntriesRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void CreateRouteEntriesRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string CreateRouteEntriesRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateRouteEntriesRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string CreateRouteEntriesRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void CreateRouteEntriesRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string CreateRouteEntriesRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void CreateRouteEntriesRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long CreateRouteEntriesRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CreateRouteEntriesRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::vector<CreateRouteEntriesRequest::RouteEntries> CreateRouteEntriesRequest::getRouteEntries() const {
+  return routeEntries_;
+}
+
+void CreateRouteEntriesRequest::setRouteEntries(const std::vector<CreateRouteEntriesRequest::RouteEntries> &routeEntries) {
+  routeEntries_ = routeEntries;
+  for(int dep1 = 0; dep1 != routeEntries.size(); dep1++) {
+  auto routeEntriesObj = routeEntries.at(dep1);
+  std::string routeEntriesObjStr = std::string("RouteEntries") + "." + std::to_string(dep1 + 1);
+    setParameter(routeEntriesObjStr + ".DstCidrBlock", routeEntriesObj.dstCidrBlock);
+    setParameter(routeEntriesObjStr + ".RouteTableId", routeEntriesObj.routeTableId);
+    setParameter(routeEntriesObjStr + ".IpVersion", std::to_string(routeEntriesObj.ipVersion));
+    setParameter(routeEntriesObjStr + ".NextHop", routeEntriesObj.nextHop);
+    setParameter(routeEntriesObjStr + ".NextHopType", routeEntriesObj.nextHopType);
+    setParameter(routeEntriesObjStr + ".Name", routeEntriesObj.name);
+    setParameter(routeEntriesObjStr + ".Describption", routeEntriesObj.describption);
+  }
+}
+

vpc/src/model/CreateRouteEntriesResult.cc

@@ -0,0 +1,85 @@
+/*
+ * 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/vpc/model/CreateRouteEntriesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vpc;
+using namespace AlibabaCloud::Vpc::Model;
+
+CreateRouteEntriesResult::CreateRouteEntriesResult() :
+	ServiceResult()
+{}
+
+CreateRouteEntriesResult::CreateRouteEntriesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateRouteEntriesResult::~CreateRouteEntriesResult()
+{}
+
+void CreateRouteEntriesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allFailedRouteEntriesNode = value["FailedRouteEntries"]["FailedRouteEntriesItem"];
+	for (auto valueFailedRouteEntriesFailedRouteEntriesItem : allFailedRouteEntriesNode)
+	{
+		FailedRouteEntriesItem failedRouteEntriesObject;
+		if(!valueFailedRouteEntriesFailedRouteEntriesItem["DstCidrBlock"].isNull())
+			failedRouteEntriesObject.dstCidrBlock = valueFailedRouteEntriesFailedRouteEntriesItem["DstCidrBlock"].asString();
+		if(!valueFailedRouteEntriesFailedRouteEntriesItem["NextHop"].isNull())
+			failedRouteEntriesObject.nextHop = valueFailedRouteEntriesFailedRouteEntriesItem["NextHop"].asString();
+		if(!valueFailedRouteEntriesFailedRouteEntriesItem["FailedCode"].isNull())
+			failedRouteEntriesObject.failedCode = valueFailedRouteEntriesFailedRouteEntriesItem["FailedCode"].asString();
+		if(!valueFailedRouteEntriesFailedRouteEntriesItem["FailedMessage"].isNull())
+			failedRouteEntriesObject.failedMessage = valueFailedRouteEntriesFailedRouteEntriesItem["FailedMessage"].asString();
+		failedRouteEntries_.push_back(failedRouteEntriesObject);
+	}
+	auto allRouteEntryIds = value["RouteEntryIds"]["RouteEntryIds"];
+	for (const auto &item : allRouteEntryIds)
+		routeEntryIds_.push_back(item.asString());
+	if(!value["SuccessCount"].isNull())
+		successCount_ = std::stoi(value["SuccessCount"].asString());
+	if(!value["FailedCount"].isNull())
+		failedCount_ = std::stoi(value["FailedCount"].asString());
+
+}
+
+std::vector<std::string> CreateRouteEntriesResult::getRouteEntryIds()const
+{
+	return routeEntryIds_;
+}
+
+int CreateRouteEntriesResult::getFailedCount()const
+{
+	return failedCount_;
+}
+
+int CreateRouteEntriesResult::getSuccessCount()const
+{
+	return successCount_;
+}
+
+std::vector<CreateRouteEntriesResult::FailedRouteEntriesItem> CreateRouteEntriesResult::getFailedRouteEntries()const
+{
+	return failedRouteEntries_;
+}
+

vpc/src/model/CreateRouteEntryRequest.cc

@@ -1,189 +1,159 @@
 /*
  * 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/vpc/model/CreateRouteEntryRequest.h>
-
-using AlibabaCloud::Vpc::Model::CreateRouteEntryRequest;
-
-CreateRouteEntryRequest::CreateRouteEntryRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "CreateRouteEntry")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateRouteEntryRequest::~CreateRouteEntryRequest()
-{}
-
-long CreateRouteEntryRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/CreateRouteEntryRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreateRouteEntryRequest;
+
+CreateRouteEntryRequest::CreateRouteEntryRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CreateRouteEntry") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CreateRouteEntryRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+CreateRouteEntryRequest::~CreateRouteEntryRequest() {}
+
+long CreateRouteEntryRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string CreateRouteEntryRequest::getRouteEntryName()const
-{
-	return routeEntryName_;
+void CreateRouteEntryRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void CreateRouteEntryRequest::setRouteEntryName(const std::string& routeEntryName)
-{
-	routeEntryName_ = routeEntryName;
-	setParameter("RouteEntryName", routeEntryName);
+std::string CreateRouteEntryRequest::getRouteEntryName() const {
+  return routeEntryName_;
 }
 
-std::string CreateRouteEntryRequest::getClientToken()const
-{
-	return clientToken_;
+void CreateRouteEntryRequest::setRouteEntryName(const std::string &routeEntryName) {
+  routeEntryName_ = routeEntryName;
+  setParameter(std::string("RouteEntryName"), routeEntryName);
 }
 
-void CreateRouteEntryRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string CreateRouteEntryRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string CreateRouteEntryRequest::getDescription()const
-{
-	return description_;
+void CreateRouteEntryRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void CreateRouteEntryRequest::setDescription(const std::string& description)
-{
-	description_ = description;
-	setParameter("Description", description);
+std::string CreateRouteEntryRequest::getDescription() const {
+  return description_;
 }
 
-std::string CreateRouteEntryRequest::getRegionId()const
-{
-	return regionId_;
+void CreateRouteEntryRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
 }
 
-void CreateRouteEntryRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string CreateRouteEntryRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string CreateRouteEntryRequest::getNextHopId()const
-{
-	return nextHopId_;
+void CreateRouteEntryRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void CreateRouteEntryRequest::setNextHopId(const std::string& nextHopId)
-{
-	nextHopId_ = nextHopId;
-	setParameter("NextHopId", nextHopId);
+std::string CreateRouteEntryRequest::getNextHopId() const {
+  return nextHopId_;
 }
 
-std::string CreateRouteEntryRequest::getNextHopType()const
-{
-	return nextHopType_;
+void CreateRouteEntryRequest::setNextHopId(const std::string &nextHopId) {
+  nextHopId_ = nextHopId;
+  setParameter(std::string("NextHopId"), nextHopId);
 }
 
-void CreateRouteEntryRequest::setNextHopType(const std::string& nextHopType)
-{
-	nextHopType_ = nextHopType;
-	setParameter("NextHopType", nextHopType);
+std::string CreateRouteEntryRequest::getNextHopType() const {
+  return nextHopType_;
 }
 
-std::string CreateRouteEntryRequest::getRouteTableId()const
-{
-	return routeTableId_;
+void CreateRouteEntryRequest::setNextHopType(const std::string &nextHopType) {
+  nextHopType_ = nextHopType;
+  setParameter(std::string("NextHopType"), nextHopType);
 }
 
-void CreateRouteEntryRequest::setRouteTableId(const std::string& routeTableId)
-{
-	routeTableId_ = routeTableId;
-	setParameter("RouteTableId", routeTableId);
+std::string CreateRouteEntryRequest::getRouteTableId() const {
+  return routeTableId_;
 }
 
-std::string CreateRouteEntryRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void CreateRouteEntryRequest::setRouteTableId(const std::string &routeTableId) {
+  routeTableId_ = routeTableId;
+  setParameter(std::string("RouteTableId"), routeTableId);
 }
 
-void CreateRouteEntryRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string CreateRouteEntryRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string CreateRouteEntryRequest::getDestinationCidrBlock()const
-{
-	return destinationCidrBlock_;
+void CreateRouteEntryRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void CreateRouteEntryRequest::setDestinationCidrBlock(const std::string& destinationCidrBlock)
-{
-	destinationCidrBlock_ = destinationCidrBlock;
-	setParameter("DestinationCidrBlock", destinationCidrBlock);
+std::string CreateRouteEntryRequest::getDestinationCidrBlock() const {
+  return destinationCidrBlock_;
 }
 
-std::string CreateRouteEntryRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void CreateRouteEntryRequest::setDestinationCidrBlock(const std::string &destinationCidrBlock) {
+  destinationCidrBlock_ = destinationCidrBlock;
+  setParameter(std::string("DestinationCidrBlock"), destinationCidrBlock);
 }
 
-void CreateRouteEntryRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string CreateRouteEntryRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long CreateRouteEntryRequest::getOwnerId()const
-{
-	return ownerId_;
+void CreateRouteEntryRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void CreateRouteEntryRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long CreateRouteEntryRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string CreateRouteEntryRequest::getPrivateIpAddress()const
-{
-	return privateIpAddress_;
+void CreateRouteEntryRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void CreateRouteEntryRequest::setPrivateIpAddress(const std::string& privateIpAddress)
-{
-	privateIpAddress_ = privateIpAddress;
-	setParameter("PrivateIpAddress", privateIpAddress);
+std::string CreateRouteEntryRequest::getPrivateIpAddress() const {
+  return privateIpAddress_;
 }
 
-std::vector<CreateRouteEntryRequest::NextHopList> CreateRouteEntryRequest::getNextHopList()const
-{
-	return nextHopList_;
+void CreateRouteEntryRequest::setPrivateIpAddress(const std::string &privateIpAddress) {
+  privateIpAddress_ = privateIpAddress;
+  setParameter(std::string("PrivateIpAddress"), privateIpAddress);
 }
 
-void CreateRouteEntryRequest::setNextHopList(const std::vector<NextHopList>& nextHopList)
-{
-	nextHopList_ = nextHopList;
-	for(int dep1 = 0; dep1!= nextHopList.size(); dep1++) {
-		auto nextHopListObj = nextHopList.at(dep1);
-		std::string nextHopListObjStr = "NextHopList." + std::to_string(dep1 + 1);
-		setParameter(nextHopListObjStr + ".Weight", std::to_string(nextHopListObj.weight));
-		setParameter(nextHopListObjStr + ".NextHopId", nextHopListObj.nextHopId);
-		setParameter(nextHopListObjStr + ".NextHopType", nextHopListObj.nextHopType);
-	}
+std::vector<CreateRouteEntryRequest::NextHopList> CreateRouteEntryRequest::getNextHopList() const {
+  return nextHopList_;
+}
+
+void CreateRouteEntryRequest::setNextHopList(const std::vector<CreateRouteEntryRequest::NextHopList> &nextHopList) {
+  nextHopList_ = nextHopList;
+  for(int dep1 = 0; dep1 != nextHopList.size(); dep1++) {
+  auto nextHopListObj = nextHopList.at(dep1);
+  std::string nextHopListObjStr = std::string("NextHopList") + "." + std::to_string(dep1 + 1);
+    setParameter(nextHopListObjStr + ".Weight", std::to_string(nextHopListObj.weight));
+    setParameter(nextHopListObjStr + ".NextHopId", nextHopListObj.nextHopId);
+    setParameter(nextHopListObjStr + ".NextHopType", nextHopListObj.nextHopType);
+  }
 }
 

vpc/src/model/CreateRouteTableRequest.cc

@@ -1,128 +1,117 @@
 /*
  * 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/vpc/model/CreateRouteTableRequest.h>
-
-using AlibabaCloud::Vpc::Model::CreateRouteTableRequest;
-
-CreateRouteTableRequest::CreateRouteTableRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "CreateRouteTable")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateRouteTableRequest::~CreateRouteTableRequest()
-{}
-
-long CreateRouteTableRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/CreateRouteTableRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreateRouteTableRequest;
+
+CreateRouteTableRequest::CreateRouteTableRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CreateRouteTable") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CreateRouteTableRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+CreateRouteTableRequest::~CreateRouteTableRequest() {}
+
+long CreateRouteTableRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string CreateRouteTableRequest::getClientToken()const
-{
-	return clientToken_;
+void CreateRouteTableRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void CreateRouteTableRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string CreateRouteTableRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string CreateRouteTableRequest::getDescription()const
-{
-	return description_;
+void CreateRouteTableRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void CreateRouteTableRequest::setDescription(const std::string& description)
-{
-	description_ = description;
-	setParameter("Description", description);
+std::string CreateRouteTableRequest::getDescription() const {
+  return description_;
 }
 
-std::string CreateRouteTableRequest::getRouteTableName()const
-{
-	return routeTableName_;
+void CreateRouteTableRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
 }
 
-void CreateRouteTableRequest::setRouteTableName(const std::string& routeTableName)
-{
-	routeTableName_ = routeTableName;
-	setParameter("RouteTableName", routeTableName);
+std::string CreateRouteTableRequest::getRouteTableName() const {
+  return routeTableName_;
 }
 
-std::string CreateRouteTableRequest::getRegionId()const
-{
-	return regionId_;
+void CreateRouteTableRequest::setRouteTableName(const std::string &routeTableName) {
+  routeTableName_ = routeTableName;
+  setParameter(std::string("RouteTableName"), routeTableName);
 }
 
-void CreateRouteTableRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string CreateRouteTableRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string CreateRouteTableRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void CreateRouteTableRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void CreateRouteTableRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string CreateRouteTableRequest::getAssociateType() const {
+  return associateType_;
 }
 
-std::string CreateRouteTableRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void CreateRouteTableRequest::setAssociateType(const std::string &associateType) {
+  associateType_ = associateType;
+  setParameter(std::string("AssociateType"), associateType);
 }
 
-void CreateRouteTableRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string CreateRouteTableRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-long CreateRouteTableRequest::getOwnerId()const
-{
-	return ownerId_;
+void CreateRouteTableRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void CreateRouteTableRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+std::string CreateRouteTableRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-std::string CreateRouteTableRequest::getVpcId()const
-{
-	return vpcId_;
+void CreateRouteTableRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void CreateRouteTableRequest::setVpcId(const std::string& vpcId)
-{
-	vpcId_ = vpcId;
-	setParameter("VpcId", vpcId);
+long CreateRouteTableRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CreateRouteTableRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string CreateRouteTableRequest::getVpcId() const {
+  return vpcId_;
+}
+
+void CreateRouteTableRequest::setVpcId(const std::string &vpcId) {
+  vpcId_ = vpcId;
+  setParameter(std::string("VpcId"), vpcId);
 }
 

vpc/src/model/CreateRouteTableResult.cc

@@ -41,6 +41,8 @@ void CreateRouteTableResult::parse(const std::string &payload)
 	setRequestId(value["RequestId"].asString());
 	if(!value["RouteTableId"].isNull())
 		routeTableId_ = value["RouteTableId"].asString();
+	if(!value["AssociateType"].isNull())
+		associateType_ = value["AssociateType"].asString();
 
 }
 
@@ -49,3 +51,8 @@ std::string CreateRouteTableResult::getRouteTableId()const
 	return routeTableId_;
 }
 
+std::string CreateRouteTableResult::getAssociateType()const
+{
+	return associateType_;
+}
+

vpc/src/model/CreateRouterInterfaceRequest.cc

@@ -1,304 +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/vpc/model/CreateRouterInterfaceRequest.h>
-
-using AlibabaCloud::Vpc::Model::CreateRouterInterfaceRequest;
-
-CreateRouterInterfaceRequest::CreateRouterInterfaceRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "CreateRouterInterface")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateRouterInterfaceRequest::~CreateRouterInterfaceRequest()
-{}
-
-std::string CreateRouterInterfaceRequest::getAccessPointId()const
-{
-	return accessPointId_;
+ */
+
+#include <alibabacloud/vpc/model/CreateRouterInterfaceRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreateRouterInterfaceRequest;
+
+CreateRouterInterfaceRequest::CreateRouterInterfaceRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CreateRouterInterface") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CreateRouterInterfaceRequest::setAccessPointId(const std::string& accessPointId)
-{
-	accessPointId_ = accessPointId;
-	setParameter("AccessPointId", accessPointId);
+CreateRouterInterfaceRequest::~CreateRouterInterfaceRequest() {}
+
+std::string CreateRouterInterfaceRequest::getAccessPointId() const {
+  return accessPointId_;
 }
 
-std::string CreateRouterInterfaceRequest::getOppositeRouterId()const
-{
-	return oppositeRouterId_;
+void CreateRouterInterfaceRequest::setAccessPointId(const std::string &accessPointId) {
+  accessPointId_ = accessPointId;
+  setParameter(std::string("AccessPointId"), accessPointId);
 }
 
-void CreateRouterInterfaceRequest::setOppositeRouterId(const std::string& oppositeRouterId)
-{
-	oppositeRouterId_ = oppositeRouterId;
-	setParameter("OppositeRouterId", oppositeRouterId);
+std::string CreateRouterInterfaceRequest::getOppositeRouterId() const {
+  return oppositeRouterId_;
 }
 
-std::string CreateRouterInterfaceRequest::getOppositeAccessPointId()const
-{
-	return oppositeAccessPointId_;
+void CreateRouterInterfaceRequest::setOppositeRouterId(const std::string &oppositeRouterId) {
+  oppositeRouterId_ = oppositeRouterId;
+  setParameter(std::string("OppositeRouterId"), oppositeRouterId);
 }
 
-void CreateRouterInterfaceRequest::setOppositeAccessPointId(const std::string& oppositeAccessPointId)
-{
-	oppositeAccessPointId_ = oppositeAccessPointId;
-	setParameter("OppositeAccessPointId", oppositeAccessPointId);
+std::string CreateRouterInterfaceRequest::getOppositeAccessPointId() const {
+  return oppositeAccessPointId_;
 }
 
-long CreateRouterInterfaceRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+void CreateRouterInterfaceRequest::setOppositeAccessPointId(const std::string &oppositeAccessPointId) {
+  oppositeAccessPointId_ = oppositeAccessPointId;
+  setParameter(std::string("OppositeAccessPointId"), oppositeAccessPointId);
 }
 
-void CreateRouterInterfaceRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+long CreateRouterInterfaceRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string CreateRouterInterfaceRequest::getRole()const
-{
-	return role_;
+void CreateRouterInterfaceRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void CreateRouterInterfaceRequest::setRole(const std::string& role)
-{
-	role_ = role;
-	setParameter("Role", role);
+std::string CreateRouterInterfaceRequest::getRole() const {
+  return role_;
 }
 
-std::string CreateRouterInterfaceRequest::getClientToken()const
-{
-	return clientToken_;
+void CreateRouterInterfaceRequest::setRole(const std::string &role) {
+  role_ = role;
+  setParameter(std::string("Role"), role);
 }
 
-void CreateRouterInterfaceRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string CreateRouterInterfaceRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string CreateRouterInterfaceRequest::getHealthCheckTargetIp()const
-{
-	return healthCheckTargetIp_;
+void CreateRouterInterfaceRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void CreateRouterInterfaceRequest::setHealthCheckTargetIp(const std::string& healthCheckTargetIp)
-{
-	healthCheckTargetIp_ = healthCheckTargetIp;
-	setParameter("HealthCheckTargetIp", healthCheckTargetIp);
+std::string CreateRouterInterfaceRequest::getHealthCheckTargetIp() const {
+  return healthCheckTargetIp_;
 }
 
-std::string CreateRouterInterfaceRequest::getDescription()const
-{
-	return description_;
+void CreateRouterInterfaceRequest::setHealthCheckTargetIp(const std::string &healthCheckTargetIp) {
+  healthCheckTargetIp_ = healthCheckTargetIp;
+  setParameter(std::string("HealthCheckTargetIp"), healthCheckTargetIp);
 }
 
-void CreateRouterInterfaceRequest::setDescription(const std::string& description)
-{
-	description_ = description;
-	setParameter("Description", description);
+std::string CreateRouterInterfaceRequest::getDescription() const {
+  return description_;
 }
 
-std::string CreateRouterInterfaceRequest::getSpec()const
-{
-	return spec_;
+void CreateRouterInterfaceRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
 }
 
-void CreateRouterInterfaceRequest::setSpec(const std::string& spec)
-{
-	spec_ = spec;
-	setParameter("Spec", spec);
+std::string CreateRouterInterfaceRequest::getSpec() const {
+  return spec_;
 }
 
-std::string CreateRouterInterfaceRequest::getRegionId()const
-{
-	return regionId_;
+void CreateRouterInterfaceRequest::setSpec(const std::string &spec) {
+  spec_ = spec;
+  setParameter(std::string("Spec"), spec);
 }
 
-void CreateRouterInterfaceRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+bool CreateRouterInterfaceRequest::getFastLinkMode() const {
+  return fastLinkMode_;
 }
 
-std::string CreateRouterInterfaceRequest::getOppositeInterfaceId()const
-{
-	return oppositeInterfaceId_;
+void CreateRouterInterfaceRequest::setFastLinkMode(bool fastLinkMode) {
+  fastLinkMode_ = fastLinkMode;
+  setParameter(std::string("FastLinkMode"), fastLinkMode ? "true" : "false");
 }
 
-void CreateRouterInterfaceRequest::setOppositeInterfaceId(const std::string& oppositeInterfaceId)
-{
-	oppositeInterfaceId_ = oppositeInterfaceId;
-	setParameter("OppositeInterfaceId", oppositeInterfaceId);
+std::string CreateRouterInterfaceRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string CreateRouterInterfaceRequest::getInstanceChargeType()const
-{
-	return instanceChargeType_;
+void CreateRouterInterfaceRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void CreateRouterInterfaceRequest::setInstanceChargeType(const std::string& instanceChargeType)
-{
-	instanceChargeType_ = instanceChargeType;
-	setParameter("InstanceChargeType", instanceChargeType);
+std::string CreateRouterInterfaceRequest::getOppositeInterfaceId() const {
+  return oppositeInterfaceId_;
 }
 
-int CreateRouterInterfaceRequest::getPeriod()const
-{
-	return period_;
+void CreateRouterInterfaceRequest::setOppositeInterfaceId(const std::string &oppositeInterfaceId) {
+  oppositeInterfaceId_ = oppositeInterfaceId;
+  setParameter(std::string("OppositeInterfaceId"), oppositeInterfaceId);
 }
 
-void CreateRouterInterfaceRequest::setPeriod(int period)
-{
-	period_ = period;
-	setParameter("Period", std::to_string(period));
+std::string CreateRouterInterfaceRequest::getInstanceChargeType() const {
+  return instanceChargeType_;
 }
 
-bool CreateRouterInterfaceRequest::getAutoPay()const
-{
-	return autoPay_;
+void CreateRouterInterfaceRequest::setInstanceChargeType(const std::string &instanceChargeType) {
+  instanceChargeType_ = instanceChargeType;
+  setParameter(std::string("InstanceChargeType"), instanceChargeType);
 }
 
-void CreateRouterInterfaceRequest::setAutoPay(bool autoPay)
-{
-	autoPay_ = autoPay;
-	setParameter("AutoPay", autoPay ? "true" : "false");
+int CreateRouterInterfaceRequest::getPeriod() const {
+  return period_;
 }
 
-std::string CreateRouterInterfaceRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void CreateRouterInterfaceRequest::setPeriod(int period) {
+  period_ = period;
+  setParameter(std::string("Period"), std::to_string(period));
 }
 
-void CreateRouterInterfaceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+bool CreateRouterInterfaceRequest::getAutoPay() const {
+  return autoPay_;
 }
 
-std::string CreateRouterInterfaceRequest::getOppositeRegionId()const
-{
-	return oppositeRegionId_;
+void CreateRouterInterfaceRequest::setAutoPay(bool autoPay) {
+  autoPay_ = autoPay;
+  setParameter(std::string("AutoPay"), autoPay ? "true" : "false");
 }
 
-void CreateRouterInterfaceRequest::setOppositeRegionId(const std::string& oppositeRegionId)
-{
-	oppositeRegionId_ = oppositeRegionId;
-	setParameter("OppositeRegionId", oppositeRegionId);
+std::string CreateRouterInterfaceRequest::getAvailableZoneId() const {
+  return availableZoneId_;
 }
 
-std::string CreateRouterInterfaceRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void CreateRouterInterfaceRequest::setAvailableZoneId(const std::string &availableZoneId) {
+  availableZoneId_ = availableZoneId;
+  setParameter(std::string("AvailableZoneId"), availableZoneId);
 }
 
-void CreateRouterInterfaceRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string CreateRouterInterfaceRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-long CreateRouterInterfaceRequest::getOwnerId()const
-{
-	return ownerId_;
+void CreateRouterInterfaceRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void CreateRouterInterfaceRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+std::string CreateRouterInterfaceRequest::getOppositeRegionId() const {
+  return oppositeRegionId_;
 }
 
-std::string CreateRouterInterfaceRequest::getOppositeInterfaceOwnerId()const
-{
-	return oppositeInterfaceOwnerId_;
+void CreateRouterInterfaceRequest::setOppositeRegionId(const std::string &oppositeRegionId) {
+  oppositeRegionId_ = oppositeRegionId;
+  setParameter(std::string("OppositeRegionId"), oppositeRegionId);
 }
 
-void CreateRouterInterfaceRequest::setOppositeInterfaceOwnerId(const std::string& oppositeInterfaceOwnerId)
-{
-	oppositeInterfaceOwnerId_ = oppositeInterfaceOwnerId;
-	setParameter("OppositeInterfaceOwnerId", oppositeInterfaceOwnerId);
+std::string CreateRouterInterfaceRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-std::string CreateRouterInterfaceRequest::getRouterType()const
-{
-	return routerType_;
+void CreateRouterInterfaceRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void CreateRouterInterfaceRequest::setRouterType(const std::string& routerType)
-{
-	routerType_ = routerType;
-	setParameter("RouterType", routerType);
+long CreateRouterInterfaceRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string CreateRouterInterfaceRequest::getHealthCheckSourceIp()const
-{
-	return healthCheckSourceIp_;
+void CreateRouterInterfaceRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void CreateRouterInterfaceRequest::setHealthCheckSourceIp(const std::string& healthCheckSourceIp)
-{
-	healthCheckSourceIp_ = healthCheckSourceIp;
-	setParameter("HealthCheckSourceIp", healthCheckSourceIp);
+std::string CreateRouterInterfaceRequest::getOppositeInterfaceOwnerId() const {
+  return oppositeInterfaceOwnerId_;
 }
 
-std::string CreateRouterInterfaceRequest::getRouterId()const
-{
-	return routerId_;
+void CreateRouterInterfaceRequest::setOppositeInterfaceOwnerId(const std::string &oppositeInterfaceOwnerId) {
+  oppositeInterfaceOwnerId_ = oppositeInterfaceOwnerId;
+  setParameter(std::string("OppositeInterfaceOwnerId"), oppositeInterfaceOwnerId);
 }
 
-void CreateRouterInterfaceRequest::setRouterId(const std::string& routerId)
-{
-	routerId_ = routerId;
-	setParameter("RouterId", routerId);
+std::string CreateRouterInterfaceRequest::getRouterType() const {
+  return routerType_;
 }
 
-std::string CreateRouterInterfaceRequest::getOppositeRouterType()const
-{
-	return oppositeRouterType_;
+void CreateRouterInterfaceRequest::setRouterType(const std::string &routerType) {
+  routerType_ = routerType;
+  setParameter(std::string("RouterType"), routerType);
 }
 
-void CreateRouterInterfaceRequest::setOppositeRouterType(const std::string& oppositeRouterType)
-{
-	oppositeRouterType_ = oppositeRouterType;
-	setParameter("OppositeRouterType", oppositeRouterType);
+std::string CreateRouterInterfaceRequest::getHealthCheckSourceIp() const {
+  return healthCheckSourceIp_;
 }
 
-std::string CreateRouterInterfaceRequest::getName()const
-{
-	return name_;
+void CreateRouterInterfaceRequest::setHealthCheckSourceIp(const std::string &healthCheckSourceIp) {
+  healthCheckSourceIp_ = healthCheckSourceIp;
+  setParameter(std::string("HealthCheckSourceIp"), healthCheckSourceIp);
 }
 
-void CreateRouterInterfaceRequest::setName(const std::string& name)
-{
-	name_ = name;
-	setParameter("Name", name);
+std::string CreateRouterInterfaceRequest::getRouterId() const {
+  return routerId_;
 }
 
-std::string CreateRouterInterfaceRequest::getPricingCycle()const
-{
-	return pricingCycle_;
+void CreateRouterInterfaceRequest::setRouterId(const std::string &routerId) {
+  routerId_ = routerId;
+  setParameter(std::string("RouterId"), routerId);
 }
 
-void CreateRouterInterfaceRequest::setPricingCycle(const std::string& pricingCycle)
-{
-	pricingCycle_ = pricingCycle;
-	setParameter("PricingCycle", pricingCycle);
+std::string CreateRouterInterfaceRequest::getOppositeRouterType() const {
+  return oppositeRouterType_;
+}
+
+void CreateRouterInterfaceRequest::setOppositeRouterType(const std::string &oppositeRouterType) {
+  oppositeRouterType_ = oppositeRouterType;
+  setParameter(std::string("OppositeRouterType"), oppositeRouterType);
+}
+
+std::string CreateRouterInterfaceRequest::getName() const {
+  return name_;
+}
+
+void CreateRouterInterfaceRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
+}
+
+std::string CreateRouterInterfaceRequest::getPricingCycle() const {
+  return pricingCycle_;
+}
+
+void CreateRouterInterfaceRequest::setPricingCycle(const std::string &pricingCycle) {
+  pricingCycle_ = pricingCycle;
+  setParameter(std::string("PricingCycle"), pricingCycle);
 }
 

vpc/src/model/CreateRouterInterfaceResult.cc

@@ -39,10 +39,10 @@ void CreateRouterInterfaceResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["RouterInterfaceId"].isNull())
-		routerInterfaceId_ = value["RouterInterfaceId"].asString();
 	if(!value["OrderId"].isNull())
 		orderId_ = std::stol(value["OrderId"].asString());
+	if(!value["RouterInterfaceId"].isNull())
+		routerInterfaceId_ = value["RouterInterfaceId"].asString();
 
 }
 

vpc/src/model/CreateSnatEntryRequest.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/vpc/model/CreateSnatEntryRequest.h>
-
-using AlibabaCloud::Vpc::Model::CreateSnatEntryRequest;
-
-CreateSnatEntryRequest::CreateSnatEntryRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "CreateSnatEntry")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateSnatEntryRequest::~CreateSnatEntryRequest()
-{}
-
-long CreateSnatEntryRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/CreateSnatEntryRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreateSnatEntryRequest;
+
+CreateSnatEntryRequest::CreateSnatEntryRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CreateSnatEntry") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CreateSnatEntryRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+CreateSnatEntryRequest::~CreateSnatEntryRequest() {}
+
+long CreateSnatEntryRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string CreateSnatEntryRequest::getClientToken()const
-{
-	return clientToken_;
+void CreateSnatEntryRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void CreateSnatEntryRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string CreateSnatEntryRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string CreateSnatEntryRequest::getSourceCIDR()const
-{
-	return sourceCIDR_;
+void CreateSnatEntryRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void CreateSnatEntryRequest::setSourceCIDR(const std::string& sourceCIDR)
-{
-	sourceCIDR_ = sourceCIDR;
-	setParameter("SourceCIDR", sourceCIDR);
+std::string CreateSnatEntryRequest::getSourceCIDR() const {
+  return sourceCIDR_;
 }
 
-std::string CreateSnatEntryRequest::getSnatIp()const
-{
-	return snatIp_;
+void CreateSnatEntryRequest::setSourceCIDR(const std::string &sourceCIDR) {
+  sourceCIDR_ = sourceCIDR;
+  setParameter(std::string("SourceCIDR"), sourceCIDR);
 }
 
-void CreateSnatEntryRequest::setSnatIp(const std::string& snatIp)
-{
-	snatIp_ = snatIp;
-	setParameter("SnatIp", snatIp);
+std::string CreateSnatEntryRequest::getSnatIp() const {
+  return snatIp_;
 }
 
-std::string CreateSnatEntryRequest::getSourceVSwitchId()const
-{
-	return sourceVSwitchId_;
+void CreateSnatEntryRequest::setSnatIp(const std::string &snatIp) {
+  snatIp_ = snatIp;
+  setParameter(std::string("SnatIp"), snatIp);
 }
 
-void CreateSnatEntryRequest::setSourceVSwitchId(const std::string& sourceVSwitchId)
-{
-	sourceVSwitchId_ = sourceVSwitchId;
-	setParameter("SourceVSwitchId", sourceVSwitchId);
+std::string CreateSnatEntryRequest::getSourceVSwitchId() const {
+  return sourceVSwitchId_;
 }
 
-std::string CreateSnatEntryRequest::getRegionId()const
-{
-	return regionId_;
+void CreateSnatEntryRequest::setSourceVSwitchId(const std::string &sourceVSwitchId) {
+  sourceVSwitchId_ = sourceVSwitchId;
+  setParameter(std::string("SourceVSwitchId"), sourceVSwitchId);
 }
 
-void CreateSnatEntryRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string CreateSnatEntryRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string CreateSnatEntryRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void CreateSnatEntryRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void CreateSnatEntryRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+int CreateSnatEntryRequest::getEipAffinity() const {
+  return eipAffinity_;
 }
 
-std::string CreateSnatEntryRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void CreateSnatEntryRequest::setEipAffinity(int eipAffinity) {
+  eipAffinity_ = eipAffinity;
+  setParameter(std::string("EipAffinity"), std::to_string(eipAffinity));
 }
 
-void CreateSnatEntryRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string CreateSnatEntryRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string CreateSnatEntryRequest::getSnatTableId()const
-{
-	return snatTableId_;
+void CreateSnatEntryRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void CreateSnatEntryRequest::setSnatTableId(const std::string& snatTableId)
-{
-	snatTableId_ = snatTableId;
-	setParameter("SnatTableId", snatTableId);
+std::string CreateSnatEntryRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long CreateSnatEntryRequest::getOwnerId()const
-{
-	return ownerId_;
+void CreateSnatEntryRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void CreateSnatEntryRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+std::string CreateSnatEntryRequest::getSnatTableId() const {
+  return snatTableId_;
 }
 
-std::string CreateSnatEntryRequest::getSnatEntryName()const
-{
-	return snatEntryName_;
+void CreateSnatEntryRequest::setSnatTableId(const std::string &snatTableId) {
+  snatTableId_ = snatTableId;
+  setParameter(std::string("SnatTableId"), snatTableId);
 }
 
-void CreateSnatEntryRequest::setSnatEntryName(const std::string& snatEntryName)
-{
-	snatEntryName_ = snatEntryName;
-	setParameter("SnatEntryName", snatEntryName);
+long CreateSnatEntryRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CreateSnatEntryRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string CreateSnatEntryRequest::getSnatEntryName() const {
+  return snatEntryName_;
+}
+
+void CreateSnatEntryRequest::setSnatEntryName(const std::string &snatEntryName) {
+  snatEntryName_ = snatEntryName;
+  setParameter(std::string("SnatEntryName"), snatEntryName);
 }
 

vpc/src/model/CreateSslVpnClientCertRequest.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/vpc/model/CreateSslVpnClientCertRequest.h>
-
-using AlibabaCloud::Vpc::Model::CreateSslVpnClientCertRequest;
-
-CreateSslVpnClientCertRequest::CreateSslVpnClientCertRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "CreateSslVpnClientCert")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateSslVpnClientCertRequest::~CreateSslVpnClientCertRequest()
-{}
-
-long CreateSslVpnClientCertRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/CreateSslVpnClientCertRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreateSslVpnClientCertRequest;
+
+CreateSslVpnClientCertRequest::CreateSslVpnClientCertRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CreateSslVpnClientCert") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CreateSslVpnClientCertRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+CreateSslVpnClientCertRequest::~CreateSslVpnClientCertRequest() {}
+
+long CreateSslVpnClientCertRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string CreateSslVpnClientCertRequest::getClientToken()const
-{
-	return clientToken_;
+void CreateSslVpnClientCertRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void CreateSslVpnClientCertRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string CreateSslVpnClientCertRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string CreateSslVpnClientCertRequest::getSslVpnServerId()const
-{
-	return sslVpnServerId_;
+void CreateSslVpnClientCertRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void CreateSslVpnClientCertRequest::setSslVpnServerId(const std::string& sslVpnServerId)
-{
-	sslVpnServerId_ = sslVpnServerId;
-	setParameter("SslVpnServerId", sslVpnServerId);
+std::string CreateSslVpnClientCertRequest::getSslVpnServerId() const {
+  return sslVpnServerId_;
 }
 
-std::string CreateSslVpnClientCertRequest::getRegionId()const
-{
-	return regionId_;
+void CreateSslVpnClientCertRequest::setSslVpnServerId(const std::string &sslVpnServerId) {
+  sslVpnServerId_ = sslVpnServerId;
+  setParameter(std::string("SslVpnServerId"), sslVpnServerId);
 }
 
-void CreateSslVpnClientCertRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string CreateSslVpnClientCertRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string CreateSslVpnClientCertRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void CreateSslVpnClientCertRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void CreateSslVpnClientCertRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string CreateSslVpnClientCertRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string CreateSslVpnClientCertRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void CreateSslVpnClientCertRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void CreateSslVpnClientCertRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string CreateSslVpnClientCertRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long CreateSslVpnClientCertRequest::getOwnerId()const
-{
-	return ownerId_;
+void CreateSslVpnClientCertRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void CreateSslVpnClientCertRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long CreateSslVpnClientCertRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string CreateSslVpnClientCertRequest::getName()const
-{
-	return name_;
+void CreateSslVpnClientCertRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void CreateSslVpnClientCertRequest::setName(const std::string& name)
-{
-	name_ = name;
-	setParameter("Name", name);
+std::string CreateSslVpnClientCertRequest::getName() const {
+  return name_;
+}
+
+void CreateSslVpnClientCertRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
 }
 

vpc/src/model/CreateSslVpnServerRequest.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/vpc/model/CreateSslVpnServerRequest.h>
-
-using AlibabaCloud::Vpc::Model::CreateSslVpnServerRequest;
-
-CreateSslVpnServerRequest::CreateSslVpnServerRequest() :
-	RpcServiceRequest("vpc", "2016-04-28", "CreateSslVpnServer")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateSslVpnServerRequest::~CreateSslVpnServerRequest()
-{}
-
-long CreateSslVpnServerRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/vpc/model/CreateSslVpnServerRequest.h>
+
+using AlibabaCloud::Vpc::Model::CreateSslVpnServerRequest;
+
+CreateSslVpnServerRequest::CreateSslVpnServerRequest()
+    : RpcServiceRequest("vpc", "2016-04-28", "CreateSslVpnServer") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CreateSslVpnServerRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+CreateSslVpnServerRequest::~CreateSslVpnServerRequest() {}
+
+long CreateSslVpnServerRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string CreateSslVpnServerRequest::getClientToken()const
-{
-	return clientToken_;
+void CreateSslVpnServerRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void CreateSslVpnServerRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string CreateSslVpnServerRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string CreateSslVpnServerRequest::getLocalSubnet()const
-{
-	return localSubnet_;
+void CreateSslVpnServerRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void CreateSslVpnServerRequest::setLocalSubnet(const std::string& localSubnet)
-{
-	localSubnet_ = localSubnet;
-	setParameter("LocalSubnet", localSubnet);
+std::string CreateSslVpnServerRequest::getLocalSubnet() const {
+  return localSubnet_;
 }
 
-std::string CreateSslVpnServerRequest::getIDaaSRegionId()const
-{
-	return iDaaSRegionId_;
+void CreateSslVpnServerRequest::setLocalSubnet(const std::string &localSubnet) {
+  localSubnet_ = localSubnet;
+  setParameter(std::string("LocalSubnet"), localSubnet);
 }
 
-void CreateSslVpnServerRequest::setIDaaSRegionId(const std::string& iDaaSRegionId)
-{
-	iDaaSRegionId_ = iDaaSRegionId;
-	setParameter("IDaaSRegionId", iDaaSRegionId);
+std::string CreateSslVpnServerRequest::getIDaaSRegionId() const {
+  return iDaaSRegionId_;
 }
 
-std::string CreateSslVpnServerRequest::getRegionId()const
-{
-	return regionId_;
+void CreateSslVpnServerRequest::setIDaaSRegionId(const std::string &iDaaSRegionId) {
+  iDaaSRegionId_ = iDaaSRegionId;
+  setParameter(std::string("IDaaSRegionId"), iDaaSRegionId);
 }
 
-void CreateSslVpnServerRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string CreateSslVpnServerRequest::getRegionId() const {
+  return regionId_;
 }
 
-bool CreateSslVpnServerRequest::getEnableMultiFactorAuth()const
-{
-	return enableMultiFactorAuth_;
+void CreateSslVpnServerRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void CreateSslVpnServerRequest::setEnableMultiFactorAuth(bool enableMultiFactorAuth)
-{
-	enableMultiFactorAuth_ = enableMultiFactorAuth;
-	setParameter("EnableMultiFactorAuth", enableMultiFactorAuth ? "true" : "false");
+bool CreateSslVpnServerRequest::getEnableMultiFactorAuth() const {
+  return enableMultiFactorAuth_;
 }
 
-std::string CreateSslVpnServerRequest::getIDaaSInstanceId()const
-{
-	return iDaaSInstanceId_;
+void CreateSslVpnServerRequest::setEnableMultiFactorAuth(bool enableMultiFactorAuth) {
+  enableMultiFactorAuth_ = enableMultiFactorAuth;
+  setParameter(std::string("EnableMultiFactorAuth"), enableMultiFactorAuth ? "true" : "false");
 }
 
-void CreateSslVpnServerRequest::setIDaaSInstanceId(const std::string& iDaaSInstanceId)
-{
-	iDaaSInstanceId_ = iDaaSInstanceId;
-	setParameter("IDaaSInstanceId", iDaaSInstanceId);
+std::string CreateSslVpnServerRequest::getIDaaSInstanceId() const {
+  return iDaaSInstanceId_;
 }
 
-std::string CreateSslVpnServerRequest::getCipher()const
-{
-	return cipher_;
+void CreateSslVpnServerRequest::setIDaaSInstanceId(const std::string &iDaaSInstanceId) {
+  iDaaSInstanceId_ = iDaaSInstanceId;
+  setParameter(std::string("IDaaSInstanceId"), iDaaSInstanceId);
 }
 
-void CreateSslVpnServerRequest::setCipher(const std::string& cipher)
-{
-	cipher_ = cipher;
-	setParameter("Cipher", cipher);
+std::string CreateSslVpnServerRequest::getCipher() const {
+  return cipher_;
 }
 
-std::string CreateSslVpnServerRequest::getClientIpPool()const
-{
-	return clientIpPool_;
+void CreateSslVpnServerRequest::setCipher(const std::string &cipher) {
+  cipher_ = cipher;
+  setParameter(std::string("Cipher"), cipher);
 }
 
-void CreateSslVpnServerRequest::setClientIpPool(const std::string& clientIpPool)
-{
-	clientIpPool_ = clientIpPool;
-	setParameter("ClientIpPool", clientIpPool);
+std::string CreateSslVpnServerRequest::getClientIpPool() const {
+  return clientIpPool_;
 }
 
-std::string CreateSslVpnServerRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void CreateSslVpnServerRequest::setClientIpPool(const std::string &clientIpPool) {
+  clientIpPool_ = clientIpPool;
+  setParameter(std::string("ClientIpPool"), clientIpPool);
 }
 
-void CreateSslVpnServerRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string CreateSslVpnServerRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-bool CreateSslVpnServerRequest::getCompress()const
-{
-	return compress_;
+void CreateSslVpnServerRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void CreateSslVpnServerRequest::setCompress(bool compress)
-{
-	compress_ = compress;
-	setParameter("Compress", compress ? "true" : "false");
+bool CreateSslVpnServerRequest::getCompress() const {
+  return compress_;
 }
 
-std::string CreateSslVpnServerRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void CreateSslVpnServerRequest::setCompress(bool compress) {
+  compress_ = compress;
+  setParameter(std::string("Compress"), compress ? "true" : "false");
 }
 
-void CreateSslVpnServerRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string CreateSslVpnServerRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-std::string CreateSslVpnServerRequest::getVpnGatewayId()const
-{
-	return vpnGatewayId_;
+void CreateSslVpnServerRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void CreateSslVpnServerRequest::setVpnGatewayId(const std::string& vpnGatewayId)
-{
-	vpnGatewayId_ = vpnGatewayId;
-	setParameter("VpnGatewayId", vpnGatewayId);
+std::string CreateSslVpnServerRequest::getVpnGatewayId() const {
+  return vpnGatewayId_;
 }
 
-long CreateSslVpnServerRequest::getOwnerId()const
-{
-	return ownerId_;
+void CreateSslVpnServerRequest::setVpnGatewayId(const std::string &vpnGatewayId) {
+  vpnGatewayId_ = vpnGatewayId;
+  setParameter(std::string("VpnGatewayId"), vpnGatewayId);
 }
 
-void CreateSslVpnServerRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long CreateSslVpnServerRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-int CreateSslVpnServerRequest::getPort()const
-{
-	return port_;
+void CreateSslVpnServerRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void CreateSslVpnServerRequest::setPort(int port)
-{
-	port_ = port;
-	setParameter("Port", std::to_string(port));
+int CreateSslVpnServerRequest::getPort() const {
+  return port_;
 }
 
-std::string CreateSslVpnServerRequest::getProto()const
-{
-	return proto_;
+void CreateSslVpnServerRequest::setPort(int port) {
+  port_ = port;
+  setParameter(std::string("Port"), std::to_string(port));
 }
 
-void CreateSslVpnServerRequest::setProto(const std::string& proto)
-{
-	proto_ = proto;
-	setParameter("Proto", proto);
+std::string CreateSslVpnServerRequest::getProto() const {
+  return proto_;
 }
 
-std::string CreateSslVpnServerRequest::getName()const
-{
-	return name_;
+void CreateSslVpnServerRequest::setProto(const std::string &proto) {
+  proto_ = proto;
+  setParameter(std::string("Proto"), proto);
 }
 
-void CreateSslVpnServerRequest::setName(const std::string& name)
-{
-	name_ = name;
-	setParameter("Name", name);
+std::string CreateSslVpnServerRequest::getName() const {
+  return name_;
+}
+
+void CreateSslVpnServerRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
 }