loafle/openapi-generator
3
0
Fork 0
forked from loafle/openapi-generator-original
Code Pull Requests Activity

update samples

Browse Source
This commit is contained in:
William Cheng 2019-04-22 13:57:59 +08:00
parent f14bac8d7d
commit fab980cf79
20 changed files with 87 additions and 293 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
docs/generators/aspnetcore.md
View File

@ -23,11 +23,7 @@ sidebar_label: aspnetcore
|useCollection|Deserialize array types to Collection<T> instead of List<T>.| |false|
|returnICollection|Return ICollection<T> instead of the concrete type.| |false|
|useSwashbuckle|Uses the Swashbuckle.AspNetCore NuGet package for documentation.| |true|
|isLibrary|Is the build a library| |false|
|classModifier|Class Modifier can be empty, abstract| ||
|operationModifier|Operation Modifier can be virtual, abstract or partial| |virtual|
|buildTarget|Target to build an application or library| |program|
|generateBody|Generates method body.| |true|
|operationIsAsync|Set methods to async or sync.| |false|
|operationResultTask|Set methods result to Task<>.| |false|
|modelClassModifier|Model Class Modifier can be nothing or partial| |partial|

2
samples/server/petstore/rust-server/output/openapi-v3/README.md
View File

@ -122,11 +122,9 @@ Method | HTTP request | Description
## Documentation For Models
- [AnotherXmlArray](docs/AnotherXmlArray.md)
- [AnotherXmlInner](docs/AnotherXmlInner.md)
- [AnotherXmlObject](docs/AnotherXmlObject.md)
- [DuplicateXmlObject](docs/DuplicateXmlObject.md)
- [XmlArray](docs/XmlArray.md)
- [XmlInner](docs/XmlInner.md)
- [XmlObject](docs/XmlObject.md)

1
samples/server/petstore/rust-server/output/openapi-v3/api/openapi.yaml
View File

@ -84,7 +84,6 @@ components:
innerString:
type: string
other_inner_rename:
format: int32
type: integer
title: an XML object
type: object

2
samples/server/petstore/rust-server/output/openapi-v3/docs/XmlObject.md
View File

@ -4,7 +4,7 @@
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**inner_string** | **String** | | [optional] [default to None]
**other_inner_rename** | **i32** | | [optional] [default to None]
**other_inner_rename** | **isize** | | [optional] [default to None]
[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

4
samples/server/petstore/rust-server/output/openapi-v3/examples/client.rs
View File

@ -88,12 +88,12 @@ fn main() {
},
Some("XmlOtherPut") => {
let result = core.run(client.xml_other_put(None));
let result = core.run(client.xml_other_put(Some(&Vec::new())));
println!("{:?} (X-Span-ID: {:?})", result, (client.context() as &Has<XSpanIdString>).get().clone());
},
Some("XmlPost") => {
let result = core.run(client.xml_post(None));
let result = core.run(client.xml_post(Some(&Vec::new())));
println!("{:?} (X-Span-ID: {:?})", result, (client.context() as &Has<XSpanIdString>).get().clone());
},

4
samples/server/petstore/rust-server/output/openapi-v3/examples/server_lib/server.rs
View File

@ -47,14 +47,14 @@ impl<C> Api<C> for Server<C> where C: Has<XSpanIdString>{
}
fn xml_other_put(&self, string: Option<models::AnotherXmlArray>, context: &C) -> Box<Future<Item=XmlOtherPutResponse, Error=ApiError>> {
fn xml_other_put(&self, string: Option<&Vec<models::AnotherXmlInner>>, context: &C) -> Box<Future<Item=XmlOtherPutResponse, Error=ApiError>> {
let context = context.clone();
println!("xml_other_put({:?}) - X-Span-ID: {:?}", string, context.get().0.clone());
Box::new(futures::failed("Generic failure".into()))
}
/// Post an array
fn xml_post(&self, string: Option<models::XmlArray>, context: &C) -> Box<Future<Item=XmlPostResponse, Error=ApiError>> {
fn xml_post(&self, string: Option<&Vec<models::XmlInner>>, context: &C) -> Box<Future<Item=XmlPostResponse, Error=ApiError>> {
let context = context.clone();
println!("xml_post({:?}) - X-Span-ID: {:?}", string, context.get().0.clone());
Box::new(futures::failed("Generic failure".into()))

49
samples/server/petstore/rust-server/output/openapi-v3/src/client/mod.rs
View File

@ -256,6 +256,15 @@ impl<F, C> Api<C> for Client<F> where
self.base_path
);
let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => return Box::new(futures::done(Err(ApiError(format!("Unable to build URI: {}", err))))),
@ -329,6 +338,15 @@ if let Some(body) = body {
self.base_path
);
let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => return Box::new(futures::done(Err(ApiError(format!("Unable to build URI: {}", err))))),
@ -394,12 +412,21 @@ if let Some(body) = body {
}
fn xml_other_put(&self, param_string: Option<models::AnotherXmlArray>, context: &C) -> Box<Future<Item=XmlOtherPutResponse, Error=ApiError>> {
fn xml_other_put(&self, param_string: Option<&Vec<models::AnotherXmlInner>>, context: &C) -> Box<Future<Item=XmlOtherPutResponse, Error=ApiError>> {
let mut uri = format!(
"{}/xml_other",
self.base_path
);
let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => return Box::new(futures::done(Err(ApiError(format!("Unable to build URI: {}", err))))),
@ -465,12 +492,21 @@ if let Some(body) = body {
}
fn xml_post(&self, param_string: Option<models::XmlArray>, context: &C) -> Box<Future<Item=XmlPostResponse, Error=ApiError>> {
fn xml_post(&self, param_string: Option<&Vec<models::XmlInner>>, context: &C) -> Box<Future<Item=XmlPostResponse, Error=ApiError>> {
let mut uri = format!(
"{}/xml",
self.base_path
);
let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => return Box::new(futures::done(Err(ApiError(format!("Unable to build URI: {}", err))))),
@ -542,6 +578,15 @@ if let Some(body) = body {
self.base_path
);
let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => return Box::new(futures::done(Err(ApiError(format!("Unable to build URI: {}", err))))),

12
samples/server/petstore/rust-server/output/openapi-v3/src/lib.rs
View File

@ -90,10 +90,10 @@ pub trait Api<C> {
fn xml_other_post(&self, another_xml_object: Option<models::AnotherXmlObject>, context: &C) -> Box<Future<Item=XmlOtherPostResponse, Error=ApiError>>;
fn xml_other_put(&self, string: Option<models::AnotherXmlArray>, context: &C) -> Box<Future<Item=XmlOtherPutResponse, Error=ApiError>>;
fn xml_other_put(&self, string: Option<&Vec<models::AnotherXmlInner>>, context: &C) -> Box<Future<Item=XmlOtherPutResponse, Error=ApiError>>;
/// Post an array
fn xml_post(&self, string: Option<models::XmlArray>, context: &C) -> Box<Future<Item=XmlPostResponse, Error=ApiError>>;
fn xml_post(&self, string: Option<&Vec<models::XmlInner>>, context: &C) -> Box<Future<Item=XmlPostResponse, Error=ApiError>>;
fn xml_put(&self, xml_object: Option<models::XmlObject>, context: &C) -> Box<Future<Item=XmlPutResponse, Error=ApiError>>;
@ -110,10 +110,10 @@ pub trait ApiNoContext {
fn xml_other_post(&self, another_xml_object: Option<models::AnotherXmlObject>) -> Box<Future<Item=XmlOtherPostResponse, Error=ApiError>>;
fn xml_other_put(&self, string: Option<models::AnotherXmlArray>) -> Box<Future<Item=XmlOtherPutResponse, Error=ApiError>>;
fn xml_other_put(&self, string: Option<&Vec<models::AnotherXmlInner>>) -> Box<Future<Item=XmlOtherPutResponse, Error=ApiError>>;
/// Post an array
fn xml_post(&self, string: Option<models::XmlArray>) -> Box<Future<Item=XmlPostResponse, Error=ApiError>>;
fn xml_post(&self, string: Option<&Vec<models::XmlInner>>) -> Box<Future<Item=XmlPostResponse, Error=ApiError>>;
fn xml_put(&self, xml_object: Option<models::XmlObject>) -> Box<Future<Item=XmlPutResponse, Error=ApiError>>;
@ -145,12 +145,12 @@ impl<'a, T: Api<C>, C> ApiNoContext for ContextWrapper<'a, T, C> {
}
fn xml_other_put(&self, string: Option<models::AnotherXmlArray>) -> Box<Future<Item=XmlOtherPutResponse, Error=ApiError>> {
fn xml_other_put(&self, string: Option<&Vec<models::AnotherXmlInner>>) -> Box<Future<Item=XmlOtherPutResponse, Error=ApiError>> {
self.api().xml_other_put(string, &self.context())
}
/// Post an array
fn xml_post(&self, string: Option<models::XmlArray>) -> Box<Future<Item=XmlPostResponse, Error=ApiError>> {
fn xml_post(&self, string: Option<&Vec<models::XmlInner>>) -> Box<Future<Item=XmlPostResponse, Error=ApiError>> {
self.api().xml_post(string, &self.context())
}

160
samples/server/petstore/rust-server/output/openapi-v3/src/models.rs
View File

@ -10,85 +10,6 @@ use models;
use swagger;
// Utility function for wrapping list elements when serializing xml
fn wrap_another_xml_array_in_xml_name<S>(item: &Vec<String>, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_xml_rs::wrap_primitives(item, serializer, "snake_another_xml_inner")
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AnotherXmlArray(#[serde(serialize_with = "wrap_another_xml_array_in_xml_name")]Vec<String>);
impl ::std::convert::From<Vec<String>> for AnotherXmlArray {
fn from(x: Vec<String>) -> Self {
AnotherXmlArray(x)
}
}
impl ::std::convert::From<AnotherXmlArray> for Vec<String> {
fn from(x: AnotherXmlArray) -> Self {
x.0
}
}
impl ::std::iter::FromIterator<String> for AnotherXmlArray {
fn from_iter<U: IntoIterator<Item=String>>(u: U) -> Self {
AnotherXmlArray(Vec::<String>::from_iter(u))
}
}
impl ::std::iter::IntoIterator for AnotherXmlArray {
type Item = String;
type IntoIter = ::std::vec::IntoIter<String>;
fn into_iter(self) -> Self::IntoIter {
self.0.into_iter()
}
}
impl<'a> ::std::iter::IntoIterator for &'a AnotherXmlArray {
type Item = &'a String;
type IntoIter = ::std::slice::Iter<'a, String>;
fn into_iter(self) -> Self::IntoIter {
(&self.0).into_iter()
}
}
impl<'a> ::std::iter::IntoIterator for &'a mut AnotherXmlArray {
type Item = &'a mut String;
type IntoIter = ::std::slice::IterMut<'a, String>;
fn into_iter(self) -> Self::IntoIter {
(&mut self.0).into_iter()
}
}
impl ::std::ops::Deref for AnotherXmlArray {
type Target = Vec<String>;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl ::std::ops::DerefMut for AnotherXmlArray {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl AnotherXmlArray {
/// Helper function to allow us to convert this model to an XML string.
/// Will panic if serialisation fails.
#[allow(dead_code)]
pub(crate) fn to_xml(&self) -> String {
serde_xml_rs::to_string(&self).expect("impossible to fail to serialize")
}
}
#[derive(Debug, Clone, PartialEq, PartialOrd, Serialize, Deserialize)]
#[serde(rename = "snake_another_xml_inner")]
pub struct AnotherXmlInner(String);
@ -204,85 +125,6 @@ impl DuplicateXmlObject {
}
}
// Utility function for wrapping list elements when serializing xml
fn wrap_xml_array_in_xml_name<S>(item: &Vec<String>, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serde_xml_rs::wrap_primitives(item, serializer, "camelXmlInner")
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct XmlArray(#[serde(serialize_with = "wrap_xml_array_in_xml_name")]Vec<String>);
impl ::std::convert::From<Vec<String>> for XmlArray {
fn from(x: Vec<String>) -> Self {
XmlArray(x)
}
}
impl ::std::convert::From<XmlArray> for Vec<String> {
fn from(x: XmlArray) -> Self {
x.0
}
}
impl ::std::iter::FromIterator<String> for XmlArray {
fn from_iter<U: IntoIterator<Item=String>>(u: U) -> Self {
XmlArray(Vec::<String>::from_iter(u))
}
}
impl ::std::iter::IntoIterator for XmlArray {
type Item = String;
type IntoIter = ::std::vec::IntoIter<String>;
fn into_iter(self) -> Self::IntoIter {
self.0.into_iter()
}
}
impl<'a> ::std::iter::IntoIterator for &'a XmlArray {
type Item = &'a String;
type IntoIter = ::std::slice::Iter<'a, String>;
fn into_iter(self) -> Self::IntoIter {
(&self.0).into_iter()
}
}
impl<'a> ::std::iter::IntoIterator for &'a mut XmlArray {
type Item = &'a mut String;
type IntoIter = ::std::slice::IterMut<'a, String>;
fn into_iter(self) -> Self::IntoIter {
(&mut self.0).into_iter()
}
}
impl ::std::ops::Deref for XmlArray {
type Target = Vec<String>;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl ::std::ops::DerefMut for XmlArray {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl XmlArray {
/// Helper function to allow us to convert this model to an XML string.
/// Will panic if serialisation fails.
#[allow(dead_code)]
pub(crate) fn to_xml(&self) -> String {
serde_xml_rs::to_string(&self).expect("impossible to fail to serialize")
}
}
#[derive(Debug, Clone, PartialEq, PartialOrd, Serialize, Deserialize)]
#[serde(rename = "camelXmlInner")]
pub struct XmlInner(String);
@ -332,7 +174,7 @@ pub struct XmlObject {
#[serde(rename = "other_inner_rename")]
#[serde(skip_serializing_if="Option::is_none")]
pub other_inner_rename: Option<i32>,
pub other_inner_rename: Option<isize>,
}

8
samples/server/petstore/rust-server/output/openapi-v3/src/server/mod.rs
View File

@ -309,7 +309,7 @@ where
Ok(body) => {
let mut unused_elements = Vec::new();
let param_string: Option<models::AnotherXmlArray> = if !body.is_empty() {
let param_string: Option<Vec<models::AnotherXmlInner>> = if !body.is_empty() {
let deserializer = &mut serde_xml_rs::de::Deserializer::new_from_reader(&*body);
match serde_ignored::deserialize(deserializer, |path| {
@ -326,7 +326,7 @@ where
};
Box::new(api_impl.xml_other_put(param_string, &context)
Box::new(api_impl.xml_other_put(param_string.as_ref(), &context)
.then(move |result| {
let mut response = Response::new();
response.headers_mut().set(XSpanId((&context as &Has<XSpanIdString>).get().0.to_string()));
@ -391,7 +391,7 @@ where
Ok(body) => {
let mut unused_elements = Vec::new();
let param_string: Option<models::XmlArray> = if !body.is_empty() {
let param_string: Option<Vec<models::XmlInner>> = if !body.is_empty() {
let deserializer = &mut serde_xml_rs::de::Deserializer::new_from_reader(&*body);
match serde_ignored::deserialize(deserializer, |path| {
@ -408,7 +408,7 @@ where
};
Box::new(api_impl.xml_post(param_string, &context)
Box::new(api_impl.xml_post(param_string.as_ref(), &context)
.then(move |result| {
let mut response = Response::new();
response.headers_mut().set(XSpanId((&context as &Has<XSpanIdString>).get().0.to_string()));

1
samples/server/petstore/rust-server/output/petstore-with-fake-endpoints-models-for-testing/README.md
View File

@ -178,7 +178,6 @@ Method | HTTP request | Description
- [AdditionalPropertiesClass](docs/AdditionalPropertiesClass.md)
- [Animal](docs/Animal.md)
- [AnimalFarm](docs/AnimalFarm.md)
- [ApiResponse](docs/ApiResponse.md)
- [ArrayOfArrayOfNumberOnly](docs/ArrayOfArrayOfNumberOnly.md)
- [ArrayOfNumberOnly](docs/ArrayOfNumberOnly.md)

6
samples/server/petstore/rust-server/output/petstore-with-fake-endpoints-models-for-testing/docs/fake_api.md
View File

@ -33,7 +33,7 @@ Optional parameters are passed through a map[string]interface{}.
Name | Type | Description | Notes
------------- | ------------- | ------------- | -------------
**body** | [**boolean**](boolean.md)| Input boolean as post body |
**body** | **bool**| Input boolean as post body |
### Return type
@ -101,7 +101,7 @@ Optional parameters are passed through a map[string]interface{}.
Name | Type | Description | Notes
------------- | ------------- | ------------- | -------------
**body** | [**number**](number.md)| Input number as post body |
**body** | **f64**| Input number as post body |
### Return type
@ -135,7 +135,7 @@ Optional parameters are passed through a map[string]interface{}.
Name | Type | Description | Notes
------------- | ------------- | ------------- | -------------
**body** | [**string**](string.md)| Input string as post body |
**body** | **String**| Input string as post body |
### Return type

6
samples/server/petstore/rust-server/output/petstore-with-fake-endpoints-models-for-testing/examples/client.rs
View File

@ -128,7 +128,7 @@ fn main() {
// },
Some("FakeOuterBooleanSerialize") => {
let result = core.run(client.fake_outer_boolean_serialize(None));
let result = core.run(client.fake_outer_boolean_serialize(Some(true)));
println!("{:?} (X-Span-ID: {:?})", result, (client.context() as &Has<XSpanIdString>).get().clone());
},
@ -138,12 +138,12 @@ fn main() {
},
Some("FakeOuterNumberSerialize") => {
let result = core.run(client.fake_outer_number_serialize(None));
let result = core.run(client.fake_outer_number_serialize(Some(8.14)));
println!("{:?} (X-Span-ID: {:?})", result, (client.context() as &Has<XSpanIdString>).get().clone());
},
Some("FakeOuterStringSerialize") => {
let result = core.run(client.fake_outer_string_serialize(None));
let result = core.run(client.fake_outer_string_serialize(Some("body_example".to_string())));
println!("{:?} (X-Span-ID: {:?})", result, (client.context() as &Has<XSpanIdString>).get().clone());
},

6
samples/server/petstore/rust-server/output/petstore-with-fake-endpoints-models-for-testing/examples/server_lib/server.rs
View File

@ -67,7 +67,7 @@ impl<C> Api<C> for Server<C> where C: Has<XSpanIdString>{
}
fn fake_outer_boolean_serialize(&self, body: Option<models::OuterBoolean>, context: &C) -> Box<Future<Item=FakeOuterBooleanSerializeResponse, Error=ApiError>> {
fn fake_outer_boolean_serialize(&self, body: Option<bool>, context: &C) -> Box<Future<Item=FakeOuterBooleanSerializeResponse, Error=ApiError>> {
let context = context.clone();
println!("fake_outer_boolean_serialize({:?}) - X-Span-ID: {:?}", body, context.get().0.clone());
Box::new(futures::failed("Generic failure".into()))
@ -81,14 +81,14 @@ impl<C> Api<C> for Server<C> where C: Has<XSpanIdString>{
}
fn fake_outer_number_serialize(&self, body: Option<models::OuterNumber>, context: &C) -> Box<Future<Item=FakeOuterNumberSerializeResponse, Error=ApiError>> {
fn fake_outer_number_serialize(&self, body: Option<f64>, context: &C) -> Box<Future<Item=FakeOuterNumberSerializeResponse, Error=ApiError>> {
let context = context.clone();
println!("fake_outer_number_serialize({:?}) - X-Span-ID: {:?}", body, context.get().0.clone());
Box::new(futures::failed("Generic failure".into()))
}
fn fake_outer_string_serialize(&self, body: Option<models::OuterString>, context: &C) -> Box<Future<Item=FakeOuterStringSerializeResponse, Error=ApiError>> {
fn fake_outer_string_serialize(&self, body: Option<String>, context: &C) -> Box<Future<Item=FakeOuterStringSerializeResponse, Error=ApiError>> {
let context = context.clone();
println!("fake_outer_string_serialize({:?}) - X-Span-ID: {:?}", body, context.get().0.clone());
Box::new(futures::failed("Generic failure".into()))

6
samples/server/petstore/rust-server/output/petstore-with-fake-endpoints-models-for-testing/src/client/mod.rs
View File

@ -357,7 +357,7 @@ impl<F, C> Api<C> for Client<F> where
}
fn fake_outer_boolean_serialize(&self, param_body: Option<models::OuterBoolean>, context: &C) -> Box<Future<Item=FakeOuterBooleanSerializeResponse, Error=ApiError>> {
fn fake_outer_boolean_serialize(&self, param_body: Option<bool>, context: &C) -> Box<Future<Item=FakeOuterBooleanSerializeResponse, Error=ApiError>> {
let mut uri = format!(
"{}/v2/fake/outer/boolean",
self.base_path
@ -521,7 +521,7 @@ if let Some(body) = body {
}
fn fake_outer_number_serialize(&self, param_body: Option<models::OuterNumber>, context: &C) -> Box<Future<Item=FakeOuterNumberSerializeResponse, Error=ApiError>> {
fn fake_outer_number_serialize(&self, param_body: Option<f64>, context: &C) -> Box<Future<Item=FakeOuterNumberSerializeResponse, Error=ApiError>> {
let mut uri = format!(
"{}/v2/fake/outer/number",
self.base_path
@ -602,7 +602,7 @@ if let Some(body) = body {
}
fn fake_outer_string_serialize(&self, param_body: Option<models::OuterString>, context: &C) -> Box<Future<Item=FakeOuterStringSerializeResponse, Error=ApiError>> {
fn fake_outer_string_serialize(&self, param_body: Option<String>, context: &C) -> Box<Future<Item=FakeOuterStringSerializeResponse, Error=ApiError>> {
let mut uri = format!(
"{}/v2/fake/outer/string",
self.base_path

18
samples/server/petstore/rust-server/output/petstore-with-fake-endpoints-models-for-testing/src/lib.rs
View File

@ -273,16 +273,16 @@ pub trait Api<C> {
fn test_special_tags(&self, body: models::Client, context: &C) -> Box<Future<Item=TestSpecialTagsResponse, Error=ApiError>>;
fn fake_outer_boolean_serialize(&self, body: Option<models::OuterBoolean>, context: &C) -> Box<Future<Item=FakeOuterBooleanSerializeResponse, Error=ApiError>>;
fn fake_outer_boolean_serialize(&self, body: Option<bool>, context: &C) -> Box<Future<Item=FakeOuterBooleanSerializeResponse, Error=ApiError>>;
fn fake_outer_composite_serialize(&self, body: Option<models::OuterComposite>, context: &C) -> Box<Future<Item=FakeOuterCompositeSerializeResponse, Error=ApiError>>;
fn fake_outer_number_serialize(&self, body: Option<models::OuterNumber>, context: &C) -> Box<Future<Item=FakeOuterNumberSerializeResponse, Error=ApiError>>;
fn fake_outer_number_serialize(&self, body: Option<f64>, context: &C) -> Box<Future<Item=FakeOuterNumberSerializeResponse, Error=ApiError>>;
fn fake_outer_string_serialize(&self, body: Option<models::OuterString>, context: &C) -> Box<Future<Item=FakeOuterStringSerializeResponse, Error=ApiError>>;
fn fake_outer_string_serialize(&self, body: Option<String>, context: &C) -> Box<Future<Item=FakeOuterStringSerializeResponse, Error=ApiError>>;
fn test_body_with_query_params(&self, query: String, body: models::User, context: &C) -> Box<Future<Item=TestBodyWithQueryParamsResponse, Error=ApiError>>;
@ -374,16 +374,16 @@ pub trait ApiNoContext {
fn test_special_tags(&self, body: models::Client) -> Box<Future<Item=TestSpecialTagsResponse, Error=ApiError>>;
fn fake_outer_boolean_serialize(&self, body: Option<models::OuterBoolean>) -> Box<Future<Item=FakeOuterBooleanSerializeResponse, Error=ApiError>>;
fn fake_outer_boolean_serialize(&self, body: Option<bool>) -> Box<Future<Item=FakeOuterBooleanSerializeResponse, Error=ApiError>>;
fn fake_outer_composite_serialize(&self, body: Option<models::OuterComposite>) -> Box<Future<Item=FakeOuterCompositeSerializeResponse, Error=ApiError>>;
fn fake_outer_number_serialize(&self, body: Option<models::OuterNumber>) -> Box<Future<Item=FakeOuterNumberSerializeResponse, Error=ApiError>>;
fn fake_outer_number_serialize(&self, body: Option<f64>) -> Box<Future<Item=FakeOuterNumberSerializeResponse, Error=ApiError>>;
fn fake_outer_string_serialize(&self, body: Option<models::OuterString>) -> Box<Future<Item=FakeOuterStringSerializeResponse, Error=ApiError>>;
fn fake_outer_string_serialize(&self, body: Option<String>) -> Box<Future<Item=FakeOuterStringSerializeResponse, Error=ApiError>>;
fn test_body_with_query_params(&self, query: String, body: models::User) -> Box<Future<Item=TestBodyWithQueryParamsResponse, Error=ApiError>>;
@ -488,7 +488,7 @@ impl<'a, T: Api<C>, C> ApiNoContext for ContextWrapper<'a, T, C> {
}
fn fake_outer_boolean_serialize(&self, body: Option<models::OuterBoolean>) -> Box<Future<Item=FakeOuterBooleanSerializeResponse, Error=ApiError>> {
fn fake_outer_boolean_serialize(&self, body: Option<bool>) -> Box<Future<Item=FakeOuterBooleanSerializeResponse, Error=ApiError>> {
self.api().fake_outer_boolean_serialize(body, &self.context())
}
@ -498,12 +498,12 @@ impl<'a, T: Api<C>, C> ApiNoContext for ContextWrapper<'a, T, C> {
}
fn fake_outer_number_serialize(&self, body: Option<models::OuterNumber>) -> Box<Future<Item=FakeOuterNumberSerializeResponse, Error=ApiError>> {
fn fake_outer_number_serialize(&self, body: Option<f64>) -> Box<Future<Item=FakeOuterNumberSerializeResponse, Error=ApiError>> {
self.api().fake_outer_number_serialize(body, &self.context())
}
fn fake_outer_string_serialize(&self, body: Option<models::OuterString>) -> Box<Future<Item=FakeOuterStringSerializeResponse, Error=ApiError>> {
fn fake_outer_string_serialize(&self, body: Option<String>) -> Box<Future<Item=FakeOuterStringSerializeResponse, Error=ApiError>> {
self.api().fake_outer_string_serialize(body, &self.context())
}

71
samples/server/petstore/rust-server/output/petstore-with-fake-endpoints-models-for-testing/src/models.rs
View File

@ -69,77 +69,6 @@ impl Animal {
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AnimalFarm(Vec<Animal>);
impl ::std::convert::From<Vec<Animal>> for AnimalFarm {
fn from(x: Vec<Animal>) -> Self {
AnimalFarm(x)
}
}
impl ::std::convert::From<AnimalFarm> for Vec<Animal> {
fn from(x: AnimalFarm) -> Self {
x.0
}
}
impl ::std::iter::FromIterator<Animal> for AnimalFarm {
fn from_iter<U: IntoIterator<Item=Animal>>(u: U) -> Self {
AnimalFarm(Vec::<Animal>::from_iter(u))
}
}
impl ::std::iter::IntoIterator for AnimalFarm {
type Item = Animal;
type IntoIter = ::std::vec::IntoIter<Animal>;
fn into_iter(self) -> Self::IntoIter {
self.0.into_iter()
}
}
impl<'a> ::std::iter::IntoIterator for &'a AnimalFarm {
type Item = &'a Animal;
type IntoIter = ::std::slice::Iter<'a, Animal>;
fn into_iter(self) -> Self::IntoIter {
(&self.0).into_iter()
}
}
impl<'a> ::std::iter::IntoIterator for &'a mut AnimalFarm {
type Item = &'a mut Animal;
type IntoIter = ::std::slice::IterMut<'a, Animal>;
fn into_iter(self) -> Self::IntoIter {
(&mut self.0).into_iter()
}
}
impl ::std::ops::Deref for AnimalFarm {
type Target = Vec<Animal>;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl ::std::ops::DerefMut for AnimalFarm {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl AnimalFarm {
/// Helper function to allow us to convert this model to an XML string.
/// Will panic if serialisation fails.
#[allow(dead_code)]
pub(crate) fn to_xml(&self) -> String {
serde_xml_rs::to_string(&self).expect("impossible to fail to serialize")
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ApiResponse {
#[serde(rename = "code")]

6
samples/server/petstore/rust-server/output/petstore-with-fake-endpoints-models-for-testing/src/server/mod.rs
View File

@ -313,7 +313,7 @@ where
Ok(body) => {
let mut unused_elements = Vec::new();
let param_body: Option<models::OuterBoolean> = if !body.is_empty() {
let param_body: Option<bool> = if !body.is_empty() {
let deserializer = &mut serde_json::Deserializer::from_slice(&*body);
@ -481,7 +481,7 @@ where
Ok(body) => {
let mut unused_elements = Vec::new();
let param_body: Option<models::OuterNumber> = if !body.is_empty() {
let param_body: Option<f64> = if !body.is_empty() {
let deserializer = &mut serde_json::Deserializer::from_slice(&*body);
@ -565,7 +565,7 @@ where
Ok(body) => {
let mut unused_elements = Vec::new();
let param_body: Option<models::OuterString> = if !body.is_empty() {
let param_body: Option<String> = if !body.is_empty() {
let deserializer = &mut serde_json::Deserializer::from_slice(&*body);

1
samples/server/petstore/rust-server/output/rust-server-test/README.md
View File

@ -123,7 +123,6 @@ Method | HTTP request | Description
## Documentation For Models
- [ANullableContainer](docs/ANullableContainer.md)
- [AdditionalPropertiesObject](docs/AdditionalPropertiesObject.md)
- [InlineObject](docs/InlineObject.md)
- [ObjectOfObjects](docs/ObjectOfObjects.md)
- [ObjectOfObjectsInner](docs/ObjectOfObjectsInner.md)

13
samples/server/petstore/rust-server/output/rust-server-test/src/models.rs
View File

@ -32,19 +32,6 @@ impl ANullableContainer {
}
/// An additionalPropertiesObject
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AdditionalPropertiesObject {
}
impl AdditionalPropertiesObject {
pub fn new() -> AdditionalPropertiesObject {
AdditionalPropertiesObject {
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct InlineObject {
#[serde(rename = "id")]