diff --git a/modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/RestbedCodegen.java b/modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/RestbedCodegen.java
index 435f773e9b6f..79134c513f19 100644
--- a/modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/RestbedCodegen.java
+++ b/modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/RestbedCodegen.java
@@ -234,16 +234,24 @@ public class RestbedCodegen extends AbstractCppCodegen {
       String path = new String(op.path);
 
       String[] items = path.split("/", -1);
-      List<String> splitPath = new ArrayList<String>();
+      String resourceNameCamelCase = "";
       op.path = "";
       for (String item: items) {
-        if (item.matches("^\\{(.*)\\}$")) {
-          item = item.substring(0, item.length()-1);
-          item += ": .*}";
-        }
-        splitPath.add(item);
+        if (item.length() > 1) {
+          if (item.matches("^\\{(.*)\\}$")) { 
+        	String tmpResourceName = item.substring(1, item.length()-1);
+            resourceNameCamelCase += Character.toUpperCase(tmpResourceName.charAt(0)) + tmpResourceName.substring(1);
+            item = item.substring(0, item.length()-1);
+            item += ": .*}";
+          } else {
+          	resourceNameCamelCase +=  Character.toUpperCase(item.charAt(0)) + item.substring(1);
+          }
+    	} else if (item.length() == 1) {
+    	  resourceNameCamelCase +=  Character.toUpperCase(item.charAt(0));
+    	}
         op.path += item + "/";
       }
+      op.vendorExtensions.put("x-codegen-resourceName", resourceNameCamelCase);
       boolean foundInNewList = false;
       for (CodegenOperation op1 : newOpList) {
         if (!foundInNewList) {
diff --git a/modules/swagger-codegen/src/main/resources/restbed/api-header.mustache b/modules/swagger-codegen/src/main/resources/restbed/api-header.mustache
index e934035a63cd..22d1f330378f 100644
--- a/modules/swagger-codegen/src/main/resources/restbed/api-header.mustache
+++ b/modules/swagger-codegen/src/main/resources/restbed/api-header.mustache
@@ -40,11 +40,11 @@ public:
 /// <remarks>
 /// {{notes}}
 /// </remarks>
-class {{declspec}} {{classname}}{{operationIdCamelCase}}Resource: public restbed::Resource
+class {{declspec}} {{classname}}{{vendorExtensions.x-codegen-resourceName}}Resource: public restbed::Resource
 {
 public:
-	{{classname}}{{operationIdCamelCase}}Resource();
-    virtual ~{{classname}}{{operationIdCamelCase}}Resource();
+	{{classname}}{{vendorExtensions.x-codegen-resourceName}}Resource();
+    virtual ~{{classname}}{{vendorExtensions.x-codegen-resourceName}}Resource();
     void {{httpMethod}}_method_handler(const std::shared_ptr<restbed::Session> session);
     {{#vendorExtensions.x-codegen-otherMethods}}
     void {{httpMethod}}_method_handler(const std::shared_ptr<restbed::Session> session);
diff --git a/modules/swagger-codegen/src/main/resources/restbed/api-source.mustache b/modules/swagger-codegen/src/main/resources/restbed/api-source.mustache
index 852627d90411..ab9ab30ddaa7 100644
--- a/modules/swagger-codegen/src/main/resources/restbed/api-source.mustache
+++ b/modules/swagger-codegen/src/main/resources/restbed/api-source.mustache
@@ -16,8 +16,8 @@ using namespace {{modelNamespace}};
 
 {{classname}}::{{classname}}() {
 	{{#operation}}
-	std::shared_ptr<{{classname}}{{operationIdCamelCase}}Resource> sp{{classname}}{{operationIdCamelCase}}Resource = std::make_shared<{{classname}}{{operationIdCamelCase}}Resource>();
-	this->publish(sp{{classname}}{{operationIdCamelCase}}Resource);
+	std::shared_ptr<{{classname}}{{vendorExtensions.x-codegen-resourceName}}Resource> sp{{classname}}{{vendorExtensions.x-codegen-resourceName}}Resource = std::make_shared<{{classname}}{{vendorExtensions.x-codegen-resourceName}}Resource>();
+	this->publish(sp{{classname}}{{vendorExtensions.x-codegen-resourceName}}Resource);
 	
 	{{/operation}}
 }
@@ -37,24 +37,24 @@ void {{classname}}::stopService() {
 }
 
 {{#operation}}
-{{classname}}{{operationIdCamelCase}}Resource::{{classname}}{{operationIdCamelCase}}Resource()
+{{classname}}{{vendorExtensions.x-codegen-resourceName}}Resource::{{classname}}{{vendorExtensions.x-codegen-resourceName}}Resource()
 {
 	this->set_path("{{path}}");
 	this->set_method_handler("{{httpMethod}}",
-		std::bind(&{{classname}}{{operationIdCamelCase}}Resource::{{httpMethod}}_method_handler, this,
+		std::bind(&{{classname}}{{vendorExtensions.x-codegen-resourceName}}Resource::{{httpMethod}}_method_handler, this,
 			std::placeholders::_1));
 	{{#vendorExtensions.x-codegen-otherMethods}}
 	this->set_method_handler("{{httpMethod}}",
-		std::bind(&{{classname}}{{operationIdCamelCase}}Resource::{{httpMethod}}_method_handler, this,
+		std::bind(&{{classname}}{{vendorExtensions.x-codegen-resourceName}}Resource::{{httpMethod}}_method_handler, this,
 			std::placeholders::_1));
 	{{/vendorExtensions.x-codegen-otherMethods}}
 }
 
-{{classname}}{{operationIdCamelCase}}Resource::~{{classname}}{{operationIdCamelCase}}Resource()
+{{classname}}{{vendorExtensions.x-codegen-resourceName}}Resource::~{{classname}}{{vendorExtensions.x-codegen-resourceName}}Resource()
 {
 }
 
-void {{classname}}{{operationIdCamelCase}}Resource::{{httpMethod}}_method_handler(const std::shared_ptr<restbed::Session> session) {
+void {{classname}}{{vendorExtensions.x-codegen-resourceName}}Resource::{{httpMethod}}_method_handler(const std::shared_ptr<restbed::Session> session) {
 
 	const auto request = session->get_request();
 	{{#hasBodyParam}}
@@ -122,7 +122,7 @@ void {{classname}}{{operationIdCamelCase}}Resource::{{httpMethod}}_method_handle
 }
 
 {{#vendorExtensions.x-codegen-otherMethods}}
-void {{classname}}{{operationIdCamelCase}}Resource::{{httpMethod}}_method_handler(const std::shared_ptr<restbed::Session> session) {
+void {{classname}}{{vendorExtensions.x-codegen-resourceName}}Resource::{{httpMethod}}_method_handler(const std::shared_ptr<restbed::Session> session) {
 
 	const auto request = session->get_request();
 	{{#hasBodyParam}}
diff --git a/samples/server/petstore/restbed/api/PetApi.cpp b/samples/server/petstore/restbed/api/PetApi.cpp
index aaceb24001ba..06214eee575b 100644
--- a/samples/server/petstore/restbed/api/PetApi.cpp
+++ b/samples/server/petstore/restbed/api/PetApi.cpp
@@ -26,20 +26,20 @@ namespace api {
 using namespace io::swagger::server::model;
 
 PetApi::PetApi() {
-	std::shared_ptr<PetApiAddPetResource> spPetApiAddPetResource = std::make_shared<PetApiAddPetResource>();
-	this->publish(spPetApiAddPetResource);
+	std::shared_ptr<PetApiPetResource> spPetApiPetResource = std::make_shared<PetApiPetResource>();
+	this->publish(spPetApiPetResource);
 	
-	std::shared_ptr<PetApiDeletePetResource> spPetApiDeletePetResource = std::make_shared<PetApiDeletePetResource>();
-	this->publish(spPetApiDeletePetResource);
+	std::shared_ptr<PetApiPetPetIdResource> spPetApiPetPetIdResource = std::make_shared<PetApiPetPetIdResource>();
+	this->publish(spPetApiPetPetIdResource);
 	
-	std::shared_ptr<PetApiFindPetsByStatusResource> spPetApiFindPetsByStatusResource = std::make_shared<PetApiFindPetsByStatusResource>();
-	this->publish(spPetApiFindPetsByStatusResource);
+	std::shared_ptr<PetApiPetFindByStatusResource> spPetApiPetFindByStatusResource = std::make_shared<PetApiPetFindByStatusResource>();
+	this->publish(spPetApiPetFindByStatusResource);
 	
-	std::shared_ptr<PetApiFindPetsByTagsResource> spPetApiFindPetsByTagsResource = std::make_shared<PetApiFindPetsByTagsResource>();
-	this->publish(spPetApiFindPetsByTagsResource);
+	std::shared_ptr<PetApiPetFindByTagsResource> spPetApiPetFindByTagsResource = std::make_shared<PetApiPetFindByTagsResource>();
+	this->publish(spPetApiPetFindByTagsResource);
 	
-	std::shared_ptr<PetApiUploadFileResource> spPetApiUploadFileResource = std::make_shared<PetApiUploadFileResource>();
-	this->publish(spPetApiUploadFileResource);
+	std::shared_ptr<PetApiPetPetIdUploadImageResource> spPetApiPetPetIdUploadImageResource = std::make_shared<PetApiPetPetIdUploadImageResource>();
+	this->publish(spPetApiPetPetIdUploadImageResource);
 	
 }
 
@@ -57,22 +57,22 @@ void PetApi::stopService() {
 	this->stop();
 }
 
-PetApiAddPetResource::PetApiAddPetResource()
+PetApiPetResource::PetApiPetResource()
 {
 	this->set_path("/pet/");
 	this->set_method_handler("POST",
-		std::bind(&PetApiAddPetResource::POST_method_handler, this,
+		std::bind(&PetApiPetResource::POST_method_handler, this,
 			std::placeholders::_1));
 	this->set_method_handler("PUT",
-		std::bind(&PetApiAddPetResource::PUT_method_handler, this,
+		std::bind(&PetApiPetResource::PUT_method_handler, this,
 			std::placeholders::_1));
 }
 
-PetApiAddPetResource::~PetApiAddPetResource()
+PetApiPetResource::~PetApiPetResource()
 {
 }
 
-void PetApiAddPetResource::POST_method_handler(const std::shared_ptr<restbed::Session> session) {
+void PetApiPetResource::POST_method_handler(const std::shared_ptr<restbed::Session> session) {
 
 	const auto request = session->get_request();
 	// Body params are present, therefore we have to fetch them
@@ -105,7 +105,7 @@ void PetApiAddPetResource::POST_method_handler(const std::shared_ptr<restbed::Se
 		});
 }
 
-void PetApiAddPetResource::PUT_method_handler(const std::shared_ptr<restbed::Session> session) {
+void PetApiPetResource::PUT_method_handler(const std::shared_ptr<restbed::Session> session) {
 
 	const auto request = session->get_request();
 	// Body params are present, therefore we have to fetch them
@@ -144,25 +144,25 @@ void PetApiAddPetResource::PUT_method_handler(const std::shared_ptr<restbed::Ses
 }
 
 
-PetApiDeletePetResource::PetApiDeletePetResource()
+PetApiPetPetIdResource::PetApiPetPetIdResource()
 {
 	this->set_path("/pet/{petId: .*}/");
 	this->set_method_handler("DELETE",
-		std::bind(&PetApiDeletePetResource::DELETE_method_handler, this,
+		std::bind(&PetApiPetPetIdResource::DELETE_method_handler, this,
 			std::placeholders::_1));
 	this->set_method_handler("GET",
-		std::bind(&PetApiDeletePetResource::GET_method_handler, this,
+		std::bind(&PetApiPetPetIdResource::GET_method_handler, this,
 			std::placeholders::_1));
 	this->set_method_handler("POST",
-		std::bind(&PetApiDeletePetResource::POST_method_handler, this,
+		std::bind(&PetApiPetPetIdResource::POST_method_handler, this,
 			std::placeholders::_1));
 }
 
-PetApiDeletePetResource::~PetApiDeletePetResource()
+PetApiPetPetIdResource::~PetApiPetPetIdResource()
 {
 }
 
-void PetApiDeletePetResource::DELETE_method_handler(const std::shared_ptr<restbed::Session> session) {
+void PetApiPetPetIdResource::DELETE_method_handler(const std::shared_ptr<restbed::Session> session) {
 
 	const auto request = session->get_request();
 			
@@ -187,7 +187,7 @@ void PetApiDeletePetResource::DELETE_method_handler(const std::shared_ptr<restbe
 
 }
 
-void PetApiDeletePetResource::GET_method_handler(const std::shared_ptr<restbed::Session> session) {
+void PetApiPetPetIdResource::GET_method_handler(const std::shared_ptr<restbed::Session> session) {
 
 	const auto request = session->get_request();
 
@@ -218,7 +218,7 @@ void PetApiDeletePetResource::GET_method_handler(const std::shared_ptr<restbed::
 			}
 
 }
-void PetApiDeletePetResource::POST_method_handler(const std::shared_ptr<restbed::Session> session) {
+void PetApiPetPetIdResource::POST_method_handler(const std::shared_ptr<restbed::Session> session) {
 
 	const auto request = session->get_request();
 
@@ -242,19 +242,19 @@ void PetApiDeletePetResource::POST_method_handler(const std::shared_ptr<restbed:
 }
 
 
-PetApiFindPetsByStatusResource::PetApiFindPetsByStatusResource()
+PetApiPetFindByStatusResource::PetApiPetFindByStatusResource()
 {
 	this->set_path("/pet/findByStatus/");
 	this->set_method_handler("GET",
-		std::bind(&PetApiFindPetsByStatusResource::GET_method_handler, this,
+		std::bind(&PetApiPetFindByStatusResource::GET_method_handler, this,
 			std::placeholders::_1));
 }
 
-PetApiFindPetsByStatusResource::~PetApiFindPetsByStatusResource()
+PetApiPetFindByStatusResource::~PetApiPetFindByStatusResource()
 {
 }
 
-void PetApiFindPetsByStatusResource::GET_method_handler(const std::shared_ptr<restbed::Session> session) {
+void PetApiPetFindByStatusResource::GET_method_handler(const std::shared_ptr<restbed::Session> session) {
 
 	const auto request = session->get_request();
 			
@@ -282,19 +282,19 @@ void PetApiFindPetsByStatusResource::GET_method_handler(const std::shared_ptr<re
 
 
 
-PetApiFindPetsByTagsResource::PetApiFindPetsByTagsResource()
+PetApiPetFindByTagsResource::PetApiPetFindByTagsResource()
 {
 	this->set_path("/pet/findByTags/");
 	this->set_method_handler("GET",
-		std::bind(&PetApiFindPetsByTagsResource::GET_method_handler, this,
+		std::bind(&PetApiPetFindByTagsResource::GET_method_handler, this,
 			std::placeholders::_1));
 }
 
-PetApiFindPetsByTagsResource::~PetApiFindPetsByTagsResource()
+PetApiPetFindByTagsResource::~PetApiPetFindByTagsResource()
 {
 }
 
-void PetApiFindPetsByTagsResource::GET_method_handler(const std::shared_ptr<restbed::Session> session) {
+void PetApiPetFindByTagsResource::GET_method_handler(const std::shared_ptr<restbed::Session> session) {
 
 	const auto request = session->get_request();
 			
@@ -322,19 +322,19 @@ void PetApiFindPetsByTagsResource::GET_method_handler(const std::shared_ptr<rest
 
 
 
-PetApiUploadFileResource::PetApiUploadFileResource()
+PetApiPetPetIdUploadImageResource::PetApiPetPetIdUploadImageResource()
 {
 	this->set_path("/pet/{petId: .*}/uploadImage/");
 	this->set_method_handler("POST",
-		std::bind(&PetApiUploadFileResource::POST_method_handler, this,
+		std::bind(&PetApiPetPetIdUploadImageResource::POST_method_handler, this,
 			std::placeholders::_1));
 }
 
-PetApiUploadFileResource::~PetApiUploadFileResource()
+PetApiPetPetIdUploadImageResource::~PetApiPetPetIdUploadImageResource()
 {
 }
 
-void PetApiUploadFileResource::POST_method_handler(const std::shared_ptr<restbed::Session> session) {
+void PetApiPetPetIdUploadImageResource::POST_method_handler(const std::shared_ptr<restbed::Session> session) {
 
 	const auto request = session->get_request();
 			
diff --git a/samples/server/petstore/restbed/api/PetApi.h b/samples/server/petstore/restbed/api/PetApi.h
index eff260b039e0..85c8e53ae754 100644
--- a/samples/server/petstore/restbed/api/PetApi.h
+++ b/samples/server/petstore/restbed/api/PetApi.h
@@ -52,11 +52,11 @@ public:
 /// <remarks>
 /// 
 /// </remarks>
-class  PetApiAddPetResource: public restbed::Resource
+class  PetApiPetResource: public restbed::Resource
 {
 public:
-	PetApiAddPetResource();
-    virtual ~PetApiAddPetResource();
+	PetApiPetResource();
+    virtual ~PetApiPetResource();
     void POST_method_handler(const std::shared_ptr<restbed::Session> session);
     void PUT_method_handler(const std::shared_ptr<restbed::Session> session);
 };
@@ -67,11 +67,11 @@ public:
 /// <remarks>
 /// 
 /// </remarks>
-class  PetApiDeletePetResource: public restbed::Resource
+class  PetApiPetPetIdResource: public restbed::Resource
 {
 public:
-	PetApiDeletePetResource();
-    virtual ~PetApiDeletePetResource();
+	PetApiPetPetIdResource();
+    virtual ~PetApiPetPetIdResource();
     void DELETE_method_handler(const std::shared_ptr<restbed::Session> session);
     void GET_method_handler(const std::shared_ptr<restbed::Session> session);
     void POST_method_handler(const std::shared_ptr<restbed::Session> session);
@@ -83,11 +83,11 @@ public:
 /// <remarks>
 /// Multiple status values can be provided with comma separated strings
 /// </remarks>
-class  PetApiFindPetsByStatusResource: public restbed::Resource
+class  PetApiPetFindByStatusResource: public restbed::Resource
 {
 public:
-	PetApiFindPetsByStatusResource();
-    virtual ~PetApiFindPetsByStatusResource();
+	PetApiPetFindByStatusResource();
+    virtual ~PetApiPetFindByStatusResource();
     void GET_method_handler(const std::shared_ptr<restbed::Session> session);
 };
 
@@ -97,11 +97,11 @@ public:
 /// <remarks>
 /// Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
 /// </remarks>
-class  PetApiFindPetsByTagsResource: public restbed::Resource
+class  PetApiPetFindByTagsResource: public restbed::Resource
 {
 public:
-	PetApiFindPetsByTagsResource();
-    virtual ~PetApiFindPetsByTagsResource();
+	PetApiPetFindByTagsResource();
+    virtual ~PetApiPetFindByTagsResource();
     void GET_method_handler(const std::shared_ptr<restbed::Session> session);
 };
 
@@ -111,11 +111,11 @@ public:
 /// <remarks>
 /// 
 /// </remarks>
-class  PetApiUploadFileResource: public restbed::Resource
+class  PetApiPetPetIdUploadImageResource: public restbed::Resource
 {
 public:
-	PetApiUploadFileResource();
-    virtual ~PetApiUploadFileResource();
+	PetApiPetPetIdUploadImageResource();
+    virtual ~PetApiPetPetIdUploadImageResource();
     void POST_method_handler(const std::shared_ptr<restbed::Session> session);
 };
 
diff --git a/samples/server/petstore/restbed/api/StoreApi.cpp b/samples/server/petstore/restbed/api/StoreApi.cpp
index f3b6e97b94ca..38bb1b836d71 100644
--- a/samples/server/petstore/restbed/api/StoreApi.cpp
+++ b/samples/server/petstore/restbed/api/StoreApi.cpp
@@ -26,14 +26,14 @@ namespace api {
 using namespace io::swagger::server::model;
 
 StoreApi::StoreApi() {
-	std::shared_ptr<StoreApiDeleteOrderResource> spStoreApiDeleteOrderResource = std::make_shared<StoreApiDeleteOrderResource>();
-	this->publish(spStoreApiDeleteOrderResource);
+	std::shared_ptr<StoreApiStoreOrderOrderIdResource> spStoreApiStoreOrderOrderIdResource = std::make_shared<StoreApiStoreOrderOrderIdResource>();
+	this->publish(spStoreApiStoreOrderOrderIdResource);
 	
-	std::shared_ptr<StoreApiGetInventoryResource> spStoreApiGetInventoryResource = std::make_shared<StoreApiGetInventoryResource>();
-	this->publish(spStoreApiGetInventoryResource);
+	std::shared_ptr<StoreApiStoreInventoryResource> spStoreApiStoreInventoryResource = std::make_shared<StoreApiStoreInventoryResource>();
+	this->publish(spStoreApiStoreInventoryResource);
 	
-	std::shared_ptr<StoreApiPlaceOrderResource> spStoreApiPlaceOrderResource = std::make_shared<StoreApiPlaceOrderResource>();
-	this->publish(spStoreApiPlaceOrderResource);
+	std::shared_ptr<StoreApiStoreOrderResource> spStoreApiStoreOrderResource = std::make_shared<StoreApiStoreOrderResource>();
+	this->publish(spStoreApiStoreOrderResource);
 	
 }
 
@@ -51,22 +51,22 @@ void StoreApi::stopService() {
 	this->stop();
 }
 
-StoreApiDeleteOrderResource::StoreApiDeleteOrderResource()
+StoreApiStoreOrderOrderIdResource::StoreApiStoreOrderOrderIdResource()
 {
 	this->set_path("/store/order/{orderId: .*}/");
 	this->set_method_handler("DELETE",
-		std::bind(&StoreApiDeleteOrderResource::DELETE_method_handler, this,
+		std::bind(&StoreApiStoreOrderOrderIdResource::DELETE_method_handler, this,
 			std::placeholders::_1));
 	this->set_method_handler("GET",
-		std::bind(&StoreApiDeleteOrderResource::GET_method_handler, this,
+		std::bind(&StoreApiStoreOrderOrderIdResource::GET_method_handler, this,
 			std::placeholders::_1));
 }
 
-StoreApiDeleteOrderResource::~StoreApiDeleteOrderResource()
+StoreApiStoreOrderOrderIdResource::~StoreApiStoreOrderOrderIdResource()
 {
 }
 
-void StoreApiDeleteOrderResource::DELETE_method_handler(const std::shared_ptr<restbed::Session> session) {
+void StoreApiStoreOrderOrderIdResource::DELETE_method_handler(const std::shared_ptr<restbed::Session> session) {
 
 	const auto request = session->get_request();
 			
@@ -93,7 +93,7 @@ void StoreApiDeleteOrderResource::DELETE_method_handler(const std::shared_ptr<re
 
 }
 
-void StoreApiDeleteOrderResource::GET_method_handler(const std::shared_ptr<restbed::Session> session) {
+void StoreApiStoreOrderOrderIdResource::GET_method_handler(const std::shared_ptr<restbed::Session> session) {
 
 	const auto request = session->get_request();
 
@@ -126,19 +126,19 @@ void StoreApiDeleteOrderResource::GET_method_handler(const std::shared_ptr<restb
 }
 
 
-StoreApiGetInventoryResource::StoreApiGetInventoryResource()
+StoreApiStoreInventoryResource::StoreApiStoreInventoryResource()
 {
 	this->set_path("/store/inventory/");
 	this->set_method_handler("GET",
-		std::bind(&StoreApiGetInventoryResource::GET_method_handler, this,
+		std::bind(&StoreApiStoreInventoryResource::GET_method_handler, this,
 			std::placeholders::_1));
 }
 
-StoreApiGetInventoryResource::~StoreApiGetInventoryResource()
+StoreApiStoreInventoryResource::~StoreApiStoreInventoryResource()
 {
 }
 
-void StoreApiGetInventoryResource::GET_method_handler(const std::shared_ptr<restbed::Session> session) {
+void StoreApiStoreInventoryResource::GET_method_handler(const std::shared_ptr<restbed::Session> session) {
 
 	const auto request = session->get_request();
 			
@@ -161,19 +161,19 @@ void StoreApiGetInventoryResource::GET_method_handler(const std::shared_ptr<rest
 
 
 
-StoreApiPlaceOrderResource::StoreApiPlaceOrderResource()
+StoreApiStoreOrderResource::StoreApiStoreOrderResource()
 {
 	this->set_path("/store/order/");
 	this->set_method_handler("POST",
-		std::bind(&StoreApiPlaceOrderResource::POST_method_handler, this,
+		std::bind(&StoreApiStoreOrderResource::POST_method_handler, this,
 			std::placeholders::_1));
 }
 
-StoreApiPlaceOrderResource::~StoreApiPlaceOrderResource()
+StoreApiStoreOrderResource::~StoreApiStoreOrderResource()
 {
 }
 
-void StoreApiPlaceOrderResource::POST_method_handler(const std::shared_ptr<restbed::Session> session) {
+void StoreApiStoreOrderResource::POST_method_handler(const std::shared_ptr<restbed::Session> session) {
 
 	const auto request = session->get_request();
 	// Body params are present, therefore we have to fetch them
diff --git a/samples/server/petstore/restbed/api/StoreApi.h b/samples/server/petstore/restbed/api/StoreApi.h
index d4765c108234..9000e500faf2 100644
--- a/samples/server/petstore/restbed/api/StoreApi.h
+++ b/samples/server/petstore/restbed/api/StoreApi.h
@@ -52,11 +52,11 @@ public:
 /// <remarks>
 /// For valid response try integer IDs with value &lt; 1000. Anything above 1000 or nonintegers will generate API errors
 /// </remarks>
-class  StoreApiDeleteOrderResource: public restbed::Resource
+class  StoreApiStoreOrderOrderIdResource: public restbed::Resource
 {
 public:
-	StoreApiDeleteOrderResource();
-    virtual ~StoreApiDeleteOrderResource();
+	StoreApiStoreOrderOrderIdResource();
+    virtual ~StoreApiStoreOrderOrderIdResource();
     void DELETE_method_handler(const std::shared_ptr<restbed::Session> session);
     void GET_method_handler(const std::shared_ptr<restbed::Session> session);
 };
@@ -67,11 +67,11 @@ public:
 /// <remarks>
 /// Returns a map of status codes to quantities
 /// </remarks>
-class  StoreApiGetInventoryResource: public restbed::Resource
+class  StoreApiStoreInventoryResource: public restbed::Resource
 {
 public:
-	StoreApiGetInventoryResource();
-    virtual ~StoreApiGetInventoryResource();
+	StoreApiStoreInventoryResource();
+    virtual ~StoreApiStoreInventoryResource();
     void GET_method_handler(const std::shared_ptr<restbed::Session> session);
 };
 
@@ -81,11 +81,11 @@ public:
 /// <remarks>
 /// 
 /// </remarks>
-class  StoreApiPlaceOrderResource: public restbed::Resource
+class  StoreApiStoreOrderResource: public restbed::Resource
 {
 public:
-	StoreApiPlaceOrderResource();
-    virtual ~StoreApiPlaceOrderResource();
+	StoreApiStoreOrderResource();
+    virtual ~StoreApiStoreOrderResource();
     void POST_method_handler(const std::shared_ptr<restbed::Session> session);
 };
 
diff --git a/samples/server/petstore/restbed/api/UserApi.cpp b/samples/server/petstore/restbed/api/UserApi.cpp
index 3477f3c4926f..adaba834175d 100644
--- a/samples/server/petstore/restbed/api/UserApi.cpp
+++ b/samples/server/petstore/restbed/api/UserApi.cpp
@@ -26,23 +26,23 @@ namespace api {
 using namespace io::swagger::server::model;
 
 UserApi::UserApi() {
-	std::shared_ptr<UserApiCreateUserResource> spUserApiCreateUserResource = std::make_shared<UserApiCreateUserResource>();
-	this->publish(spUserApiCreateUserResource);
+	std::shared_ptr<UserApiUserResource> spUserApiUserResource = std::make_shared<UserApiUserResource>();
+	this->publish(spUserApiUserResource);
 	
-	std::shared_ptr<UserApiCreateUsersWithArrayInputResource> spUserApiCreateUsersWithArrayInputResource = std::make_shared<UserApiCreateUsersWithArrayInputResource>();
-	this->publish(spUserApiCreateUsersWithArrayInputResource);
+	std::shared_ptr<UserApiUserCreateWithArrayResource> spUserApiUserCreateWithArrayResource = std::make_shared<UserApiUserCreateWithArrayResource>();
+	this->publish(spUserApiUserCreateWithArrayResource);
 	
-	std::shared_ptr<UserApiCreateUsersWithListInputResource> spUserApiCreateUsersWithListInputResource = std::make_shared<UserApiCreateUsersWithListInputResource>();
-	this->publish(spUserApiCreateUsersWithListInputResource);
+	std::shared_ptr<UserApiUserCreateWithListResource> spUserApiUserCreateWithListResource = std::make_shared<UserApiUserCreateWithListResource>();
+	this->publish(spUserApiUserCreateWithListResource);
 	
-	std::shared_ptr<UserApiDeleteUserResource> spUserApiDeleteUserResource = std::make_shared<UserApiDeleteUserResource>();
-	this->publish(spUserApiDeleteUserResource);
+	std::shared_ptr<UserApiUserUsernameResource> spUserApiUserUsernameResource = std::make_shared<UserApiUserUsernameResource>();
+	this->publish(spUserApiUserUsernameResource);
 	
-	std::shared_ptr<UserApiLoginUserResource> spUserApiLoginUserResource = std::make_shared<UserApiLoginUserResource>();
-	this->publish(spUserApiLoginUserResource);
+	std::shared_ptr<UserApiUserLoginResource> spUserApiUserLoginResource = std::make_shared<UserApiUserLoginResource>();
+	this->publish(spUserApiUserLoginResource);
 	
-	std::shared_ptr<UserApiLogoutUserResource> spUserApiLogoutUserResource = std::make_shared<UserApiLogoutUserResource>();
-	this->publish(spUserApiLogoutUserResource);
+	std::shared_ptr<UserApiUserLogoutResource> spUserApiUserLogoutResource = std::make_shared<UserApiUserLogoutResource>();
+	this->publish(spUserApiUserLogoutResource);
 	
 }
 
@@ -60,19 +60,19 @@ void UserApi::stopService() {
 	this->stop();
 }
 
-UserApiCreateUserResource::UserApiCreateUserResource()
+UserApiUserResource::UserApiUserResource()
 {
 	this->set_path("/user/");
 	this->set_method_handler("POST",
-		std::bind(&UserApiCreateUserResource::POST_method_handler, this,
+		std::bind(&UserApiUserResource::POST_method_handler, this,
 			std::placeholders::_1));
 }
 
-UserApiCreateUserResource::~UserApiCreateUserResource()
+UserApiUserResource::~UserApiUserResource()
 {
 }
 
-void UserApiCreateUserResource::POST_method_handler(const std::shared_ptr<restbed::Session> session) {
+void UserApiUserResource::POST_method_handler(const std::shared_ptr<restbed::Session> session) {
 
 	const auto request = session->get_request();
 	// Body params are present, therefore we have to fetch them
@@ -107,19 +107,19 @@ void UserApiCreateUserResource::POST_method_handler(const std::shared_ptr<restbe
 
 
 
-UserApiCreateUsersWithArrayInputResource::UserApiCreateUsersWithArrayInputResource()
+UserApiUserCreateWithArrayResource::UserApiUserCreateWithArrayResource()
 {
 	this->set_path("/user/createWithArray/");
 	this->set_method_handler("POST",
-		std::bind(&UserApiCreateUsersWithArrayInputResource::POST_method_handler, this,
+		std::bind(&UserApiUserCreateWithArrayResource::POST_method_handler, this,
 			std::placeholders::_1));
 }
 
-UserApiCreateUsersWithArrayInputResource::~UserApiCreateUsersWithArrayInputResource()
+UserApiUserCreateWithArrayResource::~UserApiUserCreateWithArrayResource()
 {
 }
 
-void UserApiCreateUsersWithArrayInputResource::POST_method_handler(const std::shared_ptr<restbed::Session> session) {
+void UserApiUserCreateWithArrayResource::POST_method_handler(const std::shared_ptr<restbed::Session> session) {
 
 	const auto request = session->get_request();
 	// Body params are present, therefore we have to fetch them
@@ -154,19 +154,19 @@ void UserApiCreateUsersWithArrayInputResource::POST_method_handler(const std::sh
 
 
 
-UserApiCreateUsersWithListInputResource::UserApiCreateUsersWithListInputResource()
+UserApiUserCreateWithListResource::UserApiUserCreateWithListResource()
 {
 	this->set_path("/user/createWithList/");
 	this->set_method_handler("POST",
-		std::bind(&UserApiCreateUsersWithListInputResource::POST_method_handler, this,
+		std::bind(&UserApiUserCreateWithListResource::POST_method_handler, this,
 			std::placeholders::_1));
 }
 
-UserApiCreateUsersWithListInputResource::~UserApiCreateUsersWithListInputResource()
+UserApiUserCreateWithListResource::~UserApiUserCreateWithListResource()
 {
 }
 
-void UserApiCreateUsersWithListInputResource::POST_method_handler(const std::shared_ptr<restbed::Session> session) {
+void UserApiUserCreateWithListResource::POST_method_handler(const std::shared_ptr<restbed::Session> session) {
 
 	const auto request = session->get_request();
 	// Body params are present, therefore we have to fetch them
@@ -201,25 +201,25 @@ void UserApiCreateUsersWithListInputResource::POST_method_handler(const std::sha
 
 
 
-UserApiDeleteUserResource::UserApiDeleteUserResource()
+UserApiUserUsernameResource::UserApiUserUsernameResource()
 {
 	this->set_path("/user/{username: .*}/");
 	this->set_method_handler("DELETE",
-		std::bind(&UserApiDeleteUserResource::DELETE_method_handler, this,
+		std::bind(&UserApiUserUsernameResource::DELETE_method_handler, this,
 			std::placeholders::_1));
 	this->set_method_handler("GET",
-		std::bind(&UserApiDeleteUserResource::GET_method_handler, this,
+		std::bind(&UserApiUserUsernameResource::GET_method_handler, this,
 			std::placeholders::_1));
 	this->set_method_handler("PUT",
-		std::bind(&UserApiDeleteUserResource::PUT_method_handler, this,
+		std::bind(&UserApiUserUsernameResource::PUT_method_handler, this,
 			std::placeholders::_1));
 }
 
-UserApiDeleteUserResource::~UserApiDeleteUserResource()
+UserApiUserUsernameResource::~UserApiUserUsernameResource()
 {
 }
 
-void UserApiDeleteUserResource::DELETE_method_handler(const std::shared_ptr<restbed::Session> session) {
+void UserApiUserUsernameResource::DELETE_method_handler(const std::shared_ptr<restbed::Session> session) {
 
 	const auto request = session->get_request();
 			
@@ -246,7 +246,7 @@ void UserApiDeleteUserResource::DELETE_method_handler(const std::shared_ptr<rest
 
 }
 
-void UserApiDeleteUserResource::GET_method_handler(const std::shared_ptr<restbed::Session> session) {
+void UserApiUserUsernameResource::GET_method_handler(const std::shared_ptr<restbed::Session> session) {
 
 	const auto request = session->get_request();
 
@@ -277,7 +277,7 @@ void UserApiDeleteUserResource::GET_method_handler(const std::shared_ptr<restbed
 			}
 
 }
-void UserApiDeleteUserResource::PUT_method_handler(const std::shared_ptr<restbed::Session> session) {
+void UserApiUserUsernameResource::PUT_method_handler(const std::shared_ptr<restbed::Session> session) {
 
 	const auto request = session->get_request();
 	// Body params are present, therefore we have to fetch them
@@ -314,19 +314,19 @@ void UserApiDeleteUserResource::PUT_method_handler(const std::shared_ptr<restbed
 }
 
 
-UserApiLoginUserResource::UserApiLoginUserResource()
+UserApiUserLoginResource::UserApiUserLoginResource()
 {
 	this->set_path("/user/login/");
 	this->set_method_handler("GET",
-		std::bind(&UserApiLoginUserResource::GET_method_handler, this,
+		std::bind(&UserApiUserLoginResource::GET_method_handler, this,
 			std::placeholders::_1));
 }
 
-UserApiLoginUserResource::~UserApiLoginUserResource()
+UserApiUserLoginResource::~UserApiUserLoginResource()
 {
 }
 
-void UserApiLoginUserResource::GET_method_handler(const std::shared_ptr<restbed::Session> session) {
+void UserApiUserLoginResource::GET_method_handler(const std::shared_ptr<restbed::Session> session) {
 
 	const auto request = session->get_request();
 			
@@ -360,19 +360,19 @@ void UserApiLoginUserResource::GET_method_handler(const std::shared_ptr<restbed:
 
 
 
-UserApiLogoutUserResource::UserApiLogoutUserResource()
+UserApiUserLogoutResource::UserApiUserLogoutResource()
 {
 	this->set_path("/user/logout/");
 	this->set_method_handler("GET",
-		std::bind(&UserApiLogoutUserResource::GET_method_handler, this,
+		std::bind(&UserApiUserLogoutResource::GET_method_handler, this,
 			std::placeholders::_1));
 }
 
-UserApiLogoutUserResource::~UserApiLogoutUserResource()
+UserApiUserLogoutResource::~UserApiUserLogoutResource()
 {
 }
 
-void UserApiLogoutUserResource::GET_method_handler(const std::shared_ptr<restbed::Session> session) {
+void UserApiUserLogoutResource::GET_method_handler(const std::shared_ptr<restbed::Session> session) {
 
 	const auto request = session->get_request();
 			
diff --git a/samples/server/petstore/restbed/api/UserApi.h b/samples/server/petstore/restbed/api/UserApi.h
index ee24ffa2eff6..0b8da3504ac1 100644
--- a/samples/server/petstore/restbed/api/UserApi.h
+++ b/samples/server/petstore/restbed/api/UserApi.h
@@ -52,11 +52,11 @@ public:
 /// <remarks>
 /// This can only be done by the logged in user.
 /// </remarks>
-class  UserApiCreateUserResource: public restbed::Resource
+class  UserApiUserResource: public restbed::Resource
 {
 public:
-	UserApiCreateUserResource();
-    virtual ~UserApiCreateUserResource();
+	UserApiUserResource();
+    virtual ~UserApiUserResource();
     void POST_method_handler(const std::shared_ptr<restbed::Session> session);
 };
 
@@ -66,11 +66,11 @@ public:
 /// <remarks>
 /// 
 /// </remarks>
-class  UserApiCreateUsersWithArrayInputResource: public restbed::Resource
+class  UserApiUserCreateWithArrayResource: public restbed::Resource
 {
 public:
-	UserApiCreateUsersWithArrayInputResource();
-    virtual ~UserApiCreateUsersWithArrayInputResource();
+	UserApiUserCreateWithArrayResource();
+    virtual ~UserApiUserCreateWithArrayResource();
     void POST_method_handler(const std::shared_ptr<restbed::Session> session);
 };
 
@@ -80,11 +80,11 @@ public:
 /// <remarks>
 /// 
 /// </remarks>
-class  UserApiCreateUsersWithListInputResource: public restbed::Resource
+class  UserApiUserCreateWithListResource: public restbed::Resource
 {
 public:
-	UserApiCreateUsersWithListInputResource();
-    virtual ~UserApiCreateUsersWithListInputResource();
+	UserApiUserCreateWithListResource();
+    virtual ~UserApiUserCreateWithListResource();
     void POST_method_handler(const std::shared_ptr<restbed::Session> session);
 };
 
@@ -94,11 +94,11 @@ public:
 /// <remarks>
 /// This can only be done by the logged in user.
 /// </remarks>
-class  UserApiDeleteUserResource: public restbed::Resource
+class  UserApiUserUsernameResource: public restbed::Resource
 {
 public:
-	UserApiDeleteUserResource();
-    virtual ~UserApiDeleteUserResource();
+	UserApiUserUsernameResource();
+    virtual ~UserApiUserUsernameResource();
     void DELETE_method_handler(const std::shared_ptr<restbed::Session> session);
     void GET_method_handler(const std::shared_ptr<restbed::Session> session);
     void PUT_method_handler(const std::shared_ptr<restbed::Session> session);
@@ -110,11 +110,11 @@ public:
 /// <remarks>
 /// 
 /// </remarks>
-class  UserApiLoginUserResource: public restbed::Resource
+class  UserApiUserLoginResource: public restbed::Resource
 {
 public:
-	UserApiLoginUserResource();
-    virtual ~UserApiLoginUserResource();
+	UserApiUserLoginResource();
+    virtual ~UserApiUserLoginResource();
     void GET_method_handler(const std::shared_ptr<restbed::Session> session);
 };
 
@@ -124,11 +124,11 @@ public:
 /// <remarks>
 /// 
 /// </remarks>
-class  UserApiLogoutUserResource: public restbed::Resource
+class  UserApiUserLogoutResource: public restbed::Resource
 {
 public:
-	UserApiLogoutUserResource();
-    virtual ~UserApiLogoutUserResource();
+	UserApiUserLogoutResource();
+    virtual ~UserApiUserLogoutResource();
     void GET_method_handler(const std::shared_ptr<restbed::Session> session);
 };