Implement solution

Author: Mubelotix

src/settings.rs

@@ -1,5 +1,5 @@
 use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
+use std::{collections::HashMap, convert, hash::Hash};
 use crate::{indexes::Index, errors::Error, request::{request, Method}, progress::{Progress, ProgressJson}};
 
 /// Struct reprensenting a set of settings.
@@ -52,6 +52,75 @@ pub struct Settings {
     pub displayed_attributes: Option<Vec<String>>,
 }
 
+pub trait IntoVecString {
+    fn convert(self) -> Vec<String>;
+}
+
+impl IntoVecString for &[&str] {
+    #[inline]
+    fn convert(self) -> Vec<String> {
+        let mut vec = Vec::new();
+        for item in self {
+            vec.push((*item).into())
+        }
+        vec
+    }
+}
+
+impl IntoVecString for Vec<&str> {
+    #[inline]
+    fn convert(self) -> Vec<String> {
+        let mut vec = Vec::new();
+        for item in self {
+            vec.push((*item).into())
+        }
+        vec
+    }
+}
+
+impl IntoVecString for Vec<String> {
+    #[inline]
+    fn convert(self) -> Vec<String> {
+        self
+    }
+}
+
+impl IntoVecString for &[String] {
+    #[inline]
+    fn convert(self) -> Vec<String> {
+        let mut vec = Vec::new();
+        for item in self {
+            vec.push(item.clone())
+        }
+        vec
+    }
+}
+
+impl IntoVecString for &[&String] {
+    #[inline]
+    fn convert(self) -> Vec<String> {
+        let mut vec = Vec::new();
+        for item in self {
+            vec.push((*item).clone())
+        }
+        vec
+    }
+}
+
+/*
+TODO: Implement IntoVecString trought const generics as soon as they are stable.
+
+impl<const N: usize> IntoVecString for &[String; N] {
+    fn convert(self) -> Vec<String> {
+        let mut vec = Vec::new();
+        for item in self {
+            vec.push((*item).clone())
+        }
+        vec
+    }
+}
+*/
+
 #[allow(missing_docs)]
 impl Settings {
     /// Create undefined settings
@@ -66,45 +135,53 @@ impl Settings {
             displayed_attributes: None,
         }
     }
-    pub fn with_synonyms(self, synonyms: HashMap<String, Vec<String>>) -> Settings {
+    pub fn with_synonyms<T: Into<String>, U: IntoVecString>(self, synonyms: HashMap<T, U>) -> Settings {
+        let mut converted_synonyms = HashMap::new();
+        for (key, array) in synonyms {
+            let key: String = key.into();
+            let array: Vec<String> = array.convert();
+            converted_synonyms.insert(key, array);
+        }
+
         Settings {
-            synonyms: Some(synonyms),
+            synonyms: Some(converted_synonyms),
             ..self
         }
     }
-    pub fn with_stop_words(self, stop_words: Vec<String>) -> Settings {
+    pub fn with_stop_words(self, stop_words: impl IntoVecString) -> Settings {
         Settings {
-            stop_words: Some(stop_words),
+            stop_words: Some(stop_words.convert()),
             ..self
         }
     }
-    pub fn with_ranking_rules(self, ranking_rules: Vec<String>) -> Settings {
+    pub fn with_ranking_rules<T: IntoVecString>(self, ranking_rules: T) -> Settings
+    {
         Settings {
-            ranking_rules: Some(ranking_rules),
+            ranking_rules: Some(ranking_rules.convert()),
             ..self
         }
     }
-    pub fn with_attributes_for_faceting(self, attributes_for_faceting: Vec<String>) -> Settings {
+    pub fn with_attributes_for_faceting<T: IntoVecString>(self, attributes_for_faceting: T) -> Settings {
         Settings {
-            attributes_for_faceting: Some(attributes_for_faceting),
+            attributes_for_faceting: Some(attributes_for_faceting.convert()),
             ..self
         }
     }
-    pub fn with_distinct_attribute(self, distinct_attribute: String) -> Settings {
+    pub fn with_distinct_attribute<T: Into<String>>(self, distinct_attribute: T) -> Settings {
         Settings {
-            distinct_attribute: Some(distinct_attribute),
+            distinct_attribute: Some(distinct_attribute.into()),
             ..self
         }
     }
-    pub fn with_searchable_attributes(self, searchable_attributes: Vec<String>) -> Settings {
+    pub fn with_searchable_attributes<T: IntoVecString>(self, searchable_attributes: T) -> Settings {
         Settings {
-            searchable_attributes: Some(searchable_attributes),
+            searchable_attributes: Some(searchable_attributes.convert()),
             ..self
         }
     }
-    pub fn with_displayed_attributes(self, displayed_attributes: Vec<String>) -> Settings {
+    pub fn with_displayed_attributes<T: IntoVecString>(self, displayed_attributes: T) -> Settings {
         Settings {
-            displayed_attributes: Some(displayed_attributes),
+            displayed_attributes: Some(displayed_attributes.convert()),
             ..self
         }
     }