add retry and transport options for services

services/autorust/codegen/src/codegen_operations.rs

@@ -83,33 +83,56 @@ pub fn create_client(modules: &[String], endpoint: Option<&str>) -> Result<Token
             credential: std::sync::Arc<dyn azure_core::auth::TokenCredential>,
             endpoint: Option<String>,
             scopes: Option<Vec<String>>,
+            options: azure_core::ClientOptions,
         }
 
         #default_endpoint_code
 
         impl ClientBuilder {
+            #[doc = "Create a new instance of `ClientBuilder`."]
+            #[must_use]
             pub fn new(credential: std::sync::Arc<dyn azure_core::auth::TokenCredential>) -> Self {
                 Self {
                     credential,
                     endpoint: None,
                     scopes: None,
+                    options: azure_core::ClientOptions::default(),
                 }
             }
 
+            #[doc = "Set the endpoint."]
+            #[must_use]
             pub fn endpoint(mut self, endpoint: impl Into<String>) -> Self {
                 self.endpoint = Some(endpoint.into());
                 self
             }
-
+            #[doc = "Set the scopes."]
+            #[must_use]
             pub fn scopes(mut self, scopes: &[&str]) -> Self {
                 self.scopes = Some(scopes.iter().map(|scope| (*scope).to_owned()).collect());
                 self
             }
 
+            #[doc = "Set the retry options."]
+            #[must_use]
+            pub fn retry(mut self, retry: impl Into<azure_core::RetryOptions>) -> Self {
+                self.options = self.options.retry(retry);
+                self
+            }
+
+            #[doc = "Set the transport options."]
+            #[must_use]
+            pub fn transport(mut self, transport: impl Into<azure_core::TransportOptions>) -> Self {
+                self.options = self.options.transport(transport);
+                self
+            }
+
+            #[doc = "Convert the builder into a `Client` instance."]
+            #[must_use]
             pub fn build(self) -> Client {
                 let endpoint = self.endpoint.unwrap_or_else(|| DEFAULT_ENDPOINT.to_owned());
                 let scopes = self.scopes.unwrap_or_else(|| vec![format!("{}/", endpoint)]);
-                Client::new(endpoint, self.credential, scopes)
+                Client::new(endpoint, self.credential, scopes, self.options)
             }
         }
 
@@ -127,12 +150,21 @@ pub fn create_client(modules: &[String], endpoint: Option<&str>) -> Result<Token
                 let mut context = azure_core::Context::default();
                 self.pipeline.send(&mut context, request).await
             }
-            pub fn new(endpoint: impl Into<String>, credential: std::sync::Arc<dyn azure_core::auth::TokenCredential>, scopes: Vec<String>) -> Self {
+
+            #[doc = "Create a new `ClientBuilder`."]
+            #[must_use]
+            pub fn builder(credential: std::sync::Arc<dyn azure_core::auth::TokenCredential>) -> ClientBuilder {
+                ClientBuilder::new(credential)
+            }
+
+            #[doc = "Create a new `Client`."]
+            #[must_use]
+            pub fn new(endpoint: impl Into<String>, credential: std::sync::Arc<dyn azure_core::auth::TokenCredential>, scopes: Vec<String>, options: azure_core::ClientOptions) -> Self {
                 let endpoint = endpoint.into();
                 let pipeline = azure_core::Pipeline::new(
                     option_env!("CARGO_PKG_NAME"),
                     option_env!("CARGO_PKG_VERSION"),
-                    azure_core::ClientOptions::default(),
+                    options,
                     Vec::new(),
                     Vec::new(),
                 );