more portions migrated [refs #19]

sslo_league/src/ndpc/coll_preset.rs

@@ -8,6 +8,12 @@ mod param_scoring;
 mod param_race_eval;
 mod coll_session;
 mod param_race_distance;
+mod coll_car_class;
+mod param_car_class;
+mod param_license;
+mod param_registration;
+mod coll_car_classes;
+mod param_car_class_count;
 
 use std::net::ToSocketAddrs;
 use axum::response::Html;
@@ -24,73 +30,6 @@ use crate::db2::DatabaseManager;
 use crate::ndpc::param_car_classes::{CarClassList, ParamCarClasses};
 use crate::user_grade::License;
 
-macro_rules! make_car_class {
-    ($parent_pc:expr, $car_classes_list:expr, $($n:expr),*) => {
-        $(
-            let mut pc = Collection::new(concat!("car_class_", $n), concat!("Car Class ", $n).to_string());
-
-            // collection enabled dependency
-            let enabled_values: Vec<String>;
-            if $n == 1 {
-                enabled_values = vec!["1".to_string(), "2".to_string(), "3".to_string(), "4".to_string()];
-            } else if $n == 2 {
-                enabled_values = vec!["2".to_string(), "3".to_string(), "4".to_string()];
-            } else if $n == 3 {
-                enabled_values = vec!["3".to_string(), "4".to_string()];
-            } else if $n == 4 {
-                enabled_values = vec!["4".to_string()];
-            } else {
-                unimplemented!("The macro is only implemented up to $n=4");
-            }
-            pc.enable_at_other_values("classes_count".to_string(), enabled_values);
-
-            // car class
-            let mut p = ParamCarClasses::new(concat!("carclass", $n), $car_classes_list.clone()).await;
-            p.meta_mut().label = "Car Class".to_string();
-            p.meta_mut().description = Some("Select here a car class to drive".to_string());
-            pc.add_parameter(p);
-
-            // license min
-            let mut p = ParamEnumSingle::new(concat!("CarClass", $n, "LicenseMin"));
-            for lic in License::list() {
-                p.add_enum_item(lic.title_str(), lic.title_str());
-            }
-            p.meta_mut().label = "Minim License".to_string();
-            p.meta_mut().description = Some("This defines the minimum license level for drivers to use drive class".to_string());
-            pc.add_parameter(p);
-
-            // license max
-            let mut p = ParamEnumSingle::new(concat!("CarClass", $n, "LicenseMax"));
-            for lic in License::list() {
-                p.add_enum_item(lic.title_str(), lic.title_str());
-                let ret = p.set_value_str_safe(lic.title_str().to_string());  // setting value to max license
-                debug_assert!(ret.is_ok());
-            }
-            p.meta_mut().label = "Maximum License".to_string();
-            p.meta_mut().description = Some("This defines the maximum license level of drivers to use drive class".to_string());
-            pc.add_parameter(p);
-
-            // registration
-            let mut p = ParamEnumSingle::new(concat!("CarClass", $n, "Registration"));
-            p.add_enum_item("NoReg", "No Registration");
-            p.add_enum_item("RegTime", "Registration: first come, first served");
-            p.add_enum_item("RegQuali", "Registration: qualify in free practice");
-            p.meta_mut().label = "Registration".to_string();
-            p.meta_mut().description = Some("No registration means that drivers cannot register at all (only spontaneous joining\nRegistration allows drivers to occupy seats (and preserve skins)\nIf more drivers register than pits are available, it is possible to use the free practice as qualification".to_string());
-            pc.add_parameter(p);
-
-            // free cars
-            let mut p = ParamEnumSingle::new(concat!("CarClass", $n, "FreeCars"));
-            p.add_enum_item("yes", "Yes");
-            p.add_enum_item("no", "No");
-            p.meta_mut().label = "Free Cars".to_string();
-            p.meta_mut().description = Some("If activated, the server will provide free, unoccupied cars in this class for spontaneously joining drivers".to_string());
-            pc.add_parameter(p);
-
-            $parent_pc.add_collection(pc);
-        )*
-    };
-}
 
 macro_rules! make_weather {
     ($parent_pc:expr, $($n:expr),*) => {
@@ -209,17 +148,20 @@ pub struct CollPreset {
     coll_general: coll_general::CollPresetGeneral,
     coll_rating: coll_rating::CollRating,
     coll_session: coll_session::CollSession,
+    coll_classes: coll_car_classes::CollCarClasses,
 }
 
 impl CollPreset {
 
     pub async fn new(db: Option<DatabaseManager>, label: String) -> Self {
+
         Self {
             meta: NdpcParameterMetaData::new(),
             label,
             coll_general: coll_general::CollPresetGeneral::new(),
             coll_rating: coll_rating::CollRating::new(),
             coll_session: coll_session::CollSession::new(),
+            coll_classes: coll_car_classes::CollCarClasses::new(db).await,
         }
     }
 
@@ -249,40 +191,14 @@ impl NdpcCollection for CollPreset {
     }
 
     fn child_collections(&self) -> Vec<&dyn NdpcCollection> {
-        vec![&self.coll_general, &self.coll_rating, &self.coll_session]
+        vec![&self.coll_general, &self.coll_rating, &self.coll_session, &self.coll_classes]
     }
     fn child_collections_mut(&mut self) -> Vec<&mut dyn NdpcCollection> {
-        vec![&mut self.coll_general, &mut self.coll_rating, &mut self.coll_session]
+        vec![&mut self.coll_general, &mut self.coll_rating, &mut self.coll_session, &mut self.coll_classes]
     }
 }
 
 
-
-
-
-async fn get_car_classes(db: Option<DatabaseManager>) -> Box<Collection> {
-    let mut pc = Collection::new("car_classes", "Car Classes".to_string());
-
-    // count
-    let mut p = ParamEnumSingle::new("classes_count");
-    p.add_enum_item("1", "1 Class");
-    p.add_enum_item("2", "2 Classes");
-    p.add_enum_item("3", "3 Classes");
-    p.add_enum_item("4", "4 Classes");
-    p.meta_mut().label = "Car Class Count".to_string();
-    p.meta_mut().description = Some("How many car classes shall be available".to_string());
-    pc.add_parameter(p);
-
-    let ccl = match db {
-        None => CarClassList::new_empty(),
-        Some(db) => CarClassList::new(db.db_content().await.tbl_classes().await).await,
-    };
-    make_car_class!(&mut pc, ccl, 1,2,3,4);
-
-    return pc;
-}
-
-
 fn get_weather() -> Box<Collection> {
     let mut pc = Collection::new("weather", "Weather".to_string());
 

sslo_league/src/ndpc/coll_preset/coll_car_class.rs

@@ -0,0 +1,63 @@
+use sslo_lib::ndpc2::collection::NdpcCollection;
+use sslo_lib::ndpc2::param_bool::ParamBool;
+use sslo_lib::ndpc2::parameter::NdpcParameter;
+use crate::ndpc::coll_preset::param_car_class::{CarClassList, ParamCarClass};
+use crate::ndpc::coll_preset::param_license::ParamLicense;
+use crate::ndpc::coll_preset::param_registration::ParamRegistration;
+use crate::user_grade::License;
+
+pub struct CollCarClass {
+    upid: &'static str,
+    label: &'static str,
+    class: ParamCarClass,
+    license_min: ParamLicense,
+    license_max: ParamLicense,
+    registration: ParamRegistration,
+    fill_cars: ParamBool,
+}
+impl CollCarClass {
+    pub fn new(upid: &'static str, label: &'static str, available_classes: CarClassList) -> Self {
+
+        let license_min = ParamLicense::new(
+            "license_min", "Minimum Driver License",
+            "This defines the minimum license level for drivers to use drive class",
+            License::Green,
+        );
+
+        let license_max = ParamLicense::new(
+            "license_max", "Maximum Driver License",
+            "This defines the maximum license level of drivers to use drive class",
+            License::Green,
+        );
+
+        let fill_cars = ParamBool::new(
+        "fill_cars", "Free Cars".to_string(),
+        true,
+        "If activated, the server will provide free, unoccupied cars in this class for spontaneously joining drivers".to_string(),
+        );
+
+        Self {
+            upid,
+            label,
+            class: ParamCarClass::new(available_classes),
+            license_min,
+            license_max,
+            registration: ParamRegistration::new(),
+            fill_cars,
+        }
+    }
+}
+impl NdpcCollection for CollCarClass {
+    fn ucid(&self) -> &'static str { self.upid }
+    fn label(&self) -> &str { self.label }
+
+    fn child_parameters(&self) -> Vec<&dyn NdpcParameter> {
+        vec![&self.class, &self.license_min, &self.license_max, &self.registration, &self.fill_cars]
+    }
+    fn child_parameters_mut(&mut self) -> Vec<&mut dyn NdpcParameter> {
+        vec![&mut self.class, &mut self.license_min, &mut self.license_max, &mut self.registration, &mut self.fill_cars]
+    }
+
+    fn child_collections(&self) -> Vec<&dyn NdpcCollection> { vec![] }
+    fn child_collections_mut(&mut self) -> Vec<&mut dyn NdpcCollection> { vec![] }
+}

sslo_league/src/ndpc/coll_preset/coll_car_classes.rs

@@ -0,0 +1,54 @@
+use sslo_lib::ndpc2::collection::NdpcCollection;
+use sslo_lib::ndpc2::parameter::NdpcParameter;
+use crate::db2::DatabaseManager;
+use crate::ndpc::coll_preset::param_car_class;
+use crate::ndpc::coll_preset::coll_car_class::CollCarClass;
+use crate::ndpc::coll_preset::param_car_class_count::ParamCarClassCount;
+
+pub struct CollCarClasses {
+    classes_count: ParamCarClassCount,
+    class_1: CollCarClass,
+    class_2: CollCarClass,
+    class_3: CollCarClass,
+    class_4: CollCarClass,
+}
+
+impl CollCarClasses {
+    pub async fn new(db: Option<DatabaseManager>) -> Self {
+
+        let available_car_classes = match db {
+            None => param_car_class::CarClassList::new_empty(),
+            Some(db) => {
+                let tbl = db.db_content().await.tbl_classes().await;
+                param_car_class::CarClassList::new(tbl).await
+            }
+        };
+
+        Self {
+            classes_count: ParamCarClassCount::new(),
+            class_1: CollCarClass::new("class1", "Car Class 1", available_car_classes.clone()),
+            class_2: CollCarClass::new("class2", "Car Class 2", available_car_classes.clone()),
+            class_3: CollCarClass::new("class3", "Car Class 3", available_car_classes.clone()),
+            class_4: CollCarClass::new("class4", "Car Class 4", available_car_classes.clone()),
+        }
+    }
+}
+
+impl NdpcCollection for CollCarClasses {
+    fn ucid(&self) -> &'static str { "car_classes" }
+    fn label(&self) -> &str { "Car Classes" }
+
+    fn child_parameters(&self) -> Vec<&dyn NdpcParameter> {
+        vec![&self.classes_count]
+    }
+    fn child_parameters_mut(&mut self) -> Vec<&mut dyn NdpcParameter> {
+        vec![&mut self.classes_count]
+    }
+
+    fn child_collections(&self) -> Vec<&dyn NdpcCollection> {
+        vec![&self.class_1, &self.class_2, &self.class_3, &self.class_4]
+    }
+    fn child_collections_mut(&mut self) -> Vec<&mut dyn NdpcCollection> {
+        vec![&mut self.class_1, &mut self.class_2, &mut self.class_3, &mut self.class_4]
+    }
+}

sslo_league/src/ndpc/coll_preset/param_car_class.rs

@@ -0,0 +1,80 @@
+use axum::response::IntoResponse;
+use strum::{AsRefStr, EnumIter, EnumString, IntoEnumIterator};
+use sslo_lib::error::SsloError;
+use sslo_lib::ndpc2::parameter::{NdpcParameter, NdpcParameterMetaData};
+use crate::db2::content::classes::ClassesTable;
+
+#[derive(Clone)]
+pub struct CarClassList (Vec<(i64, String)>);
+
+impl CarClassList {
+
+    /// Create an object with only one invalid element inside.
+    /// This can be used as fallback when no database is available.
+    pub fn new_empty() -> Self { Self(vec![(0, "?".to_string())]) }
+
+    pub async fn new(tbl: ClassesTable) -> Self {
+        let class_items = tbl.list_all().await;
+
+        let futures_ids = class_items.iter().map(|ci| ci.id());
+        let futures_names = class_items.iter().map(|ci| ci.name());
+        let ids: Vec<i64> = futures::future::join_all(futures_ids).await;
+        let names: Vec<String> = futures::future::join_all(futures_names).await;
+
+        Self(ids.into_iter().zip(names.into_iter()).collect())
+    }
+}
+
+
+pub struct ParamCarClass {
+    meta: NdpcParameterMetaData,
+    available_classes: CarClassList,
+    selected_class: i64,
+}
+
+impl ParamCarClass {
+    pub fn new(classes: CarClassList) -> Self { Self {
+        meta: NdpcParameterMetaData::new(),
+        selected_class: classes.0.get(0).unwrap_or(&(0i64, "?".to_string())).0,
+        available_classes: classes,
+    } }
+    pub fn value_class_id(&self) -> i64 { self.selected_class }
+}
+
+impl NdpcParameter for ParamCarClass {
+    fn upid(&self) -> &'static str { "car_class" }
+    fn label(&self) -> &str { "Car Class" }
+    fn description(&self) -> &str {"Select here a car class to drive"}
+    fn unit(&self) -> Option<&str> { None }
+    fn meta(&self) -> &NdpcParameterMetaData { &self.meta }
+    fn meta_mut(&mut self) -> &mut NdpcParameterMetaData { &mut self.meta }
+
+    fn value_from_string(&mut self, value: &str) -> Result<(), SsloError> {
+        for item in &self.available_classes.0 {
+            if item.1 == value {
+                self.selected_class = item.0;
+                return Ok(());
+            }
+        }
+        Err(SsloError::NdpcValueMismatch(self.upid().to_string(), value.to_string()))
+    }
+
+    fn value2str(&self) -> String {
+        for item in &self.available_classes.0 {
+            if item.0 == self.selected_class {
+                return item.1.clone()
+            }
+        }
+        "".to_string()
+    }
+
+    fn html_input(&self) -> String {
+        let options: Vec<String> = self.available_classes.0.iter()
+            .map(|item| {
+                let selected = match item.0 == self.selected_class {true => " selected=\"true\"", false => ""};
+                format!("<option value=\"{0}\"{1}/>{0}</option>", item.1, selected)
+            }).collect();
+
+        format!("<select>{}</select>", options.join(""))
+    }
+}

sslo_league/src/ndpc/coll_preset/param_car_class_count.rs

@@ -0,0 +1,54 @@
+use axum::response::IntoResponse;
+use strum::{AsRefStr, EnumIter, EnumString, IntoEnumIterator};
+use sslo_lib::error::SsloError;
+use sslo_lib::ndpc2::parameter::{NdpcParameter, NdpcParameterMetaData};
+
+#[derive(AsRefStr, EnumIter, EnumString, PartialEq, Clone)]
+enum CarClassCount {
+    OneClass,
+    TwoClasses,
+    ThreeCLasses,
+    FourClasses,
+}
+
+
+pub struct ParamCarClassCount {
+    meta: NdpcParameterMetaData,
+    value: CarClassCount,
+}
+impl NdpcParameter for ParamCarClassCount {
+    fn upid(&self) -> &'static str { "classes_count" }
+    fn label(&self) -> &str { "Car Class Count" }
+    fn description(&self) -> &str {"How many car classes shall be available"}
+    fn unit(&self) -> Option<&str> { None }
+    fn meta(&self) -> &NdpcParameterMetaData { &self.meta }
+    fn meta_mut(&mut self) -> &mut NdpcParameterMetaData { &mut self.meta }
+
+    fn value_from_string(&mut self, value: &str) -> Result<(), SsloError> {
+        self.value = match value.parse() {
+            Ok(value) => value,
+            Err(e) => {
+                log::warn!("Failed to convert value='{}' for upid={}: {}", value, self.upid(), e);
+                return Err(SsloError::NdpcValueMismatch(self.upid().to_string(), value.to_string()));
+            }
+        };
+        Ok(())
+    }
+
+    fn value2str(&self) -> String { self.value.as_ref().to_string() }
+
+    fn html_input(&self) -> String {
+        let options : Vec<String> = CarClassCount::iter().map(|item| {
+            let selected = if self.value == item {"selected=\"true\""} else {""};
+            format!("<option value=\"{0}\"{1}>{0}</option>", item.as_ref(), selected)
+        }).collect();
+        format!("<select>{}</select>", options.join(""))
+    }
+}
+impl ParamCarClassCount {
+    pub fn new() -> Self { Self {
+        meta: NdpcParameterMetaData::new(),
+        value: CarClassCount::OneClass,
+    } }
+    pub fn value(&self) -> CarClassCount { self.value.clone() }
+}

sslo_league/src/ndpc/coll_preset/param_license.rs

@@ -0,0 +1,56 @@
+use sslo_lib::error::SsloError;
+use sslo_lib::ndpc2::parameter::{NdpcParameter, NdpcParameterMetaData};
+use sslo_lib::parameters::SupportedSim;
+use strum::IntoEnumIterator;
+use crate::user_grade::License;
+
+pub struct ParamLicense {
+    meta: NdpcParameterMetaData,
+    value: License,
+    upid: &'static str,
+    label: &'static str,
+    description: &'static str,
+}
+
+impl ParamLicense {
+    pub fn new(upid: &'static str, label: &'static str, description: &'static str,
+               default_value: License) -> Self { Self {
+        meta: NdpcParameterMetaData::new(),
+        value: default_value,
+        upid,
+        label,
+        description,
+    } }
+
+    pub fn value(&self) -> License { self.value.clone() }
+}
+
+impl NdpcParameter for ParamLicense {
+    fn upid(&self) -> &'static str { self.upid }
+    fn label(&self) -> &str { self.label }
+    fn description(&self) -> &str { self.description }
+    fn unit(&self) -> Option<&str> { None }
+    fn meta(&self) -> &NdpcParameterMetaData { &self.meta }
+    fn meta_mut(&mut self) -> &mut NdpcParameterMetaData { &mut self.meta }
+
+    fn value_from_string(&mut self, value: &str) -> Result<(), SsloError> {
+        self.value = match value.parse() {
+            Ok(value) => value,
+            Err(e) => {
+                log::warn!("Failed to convert value='{}' for upid={}: {}", value, self.upid(), e);
+                return Err(SsloError::NdpcValueMismatch(self.upid().to_string(), value.to_string()));
+            }
+        };
+        Ok(())
+    }
+
+    fn value2str(&self) -> String { self.value.as_ref().to_string() }
+
+    fn html_input(&self) -> String {
+        let options : Vec<String> = License::iter().map(|item| {
+            let selected = if self.value == item {"selected=\"true\""} else {""};
+            format!("<option value=\"{0}\"{1}>{0}</option>", item.as_ref(), selected)
+        }).collect();
+        format!("<select>{}</select>", options.join(""))
+    }
+}

sslo_league/src/ndpc/coll_preset/param_penalties.rs

@@ -3,7 +3,7 @@ use strum::{AsRefStr, EnumIter, EnumString, IntoEnumIterator};
 use sslo_lib::error::SsloError;
 use sslo_lib::ndpc2::parameter::{NdpcParameter, NdpcParameterMetaData};
 
-#[derive(AsRefStr, EnumIter, EnumString, PartialEq)]
+#[derive(AsRefStr, EnumIter, EnumString, PartialEq, Clone)]
 enum Penalties {
     None,
     Tolerant,
@@ -50,5 +50,5 @@ impl ParamPenalties {
         meta: NdpcParameterMetaData::new(),
         value: Penalties::None,
     } }
-    pub fn value(&self) -> &Penalties { &self.value }
+    pub fn value(&self) -> Penalties { self.value.clone() }
 }

sslo_league/src/ndpc/coll_preset/param_registration.rs

@@ -0,0 +1,54 @@
+use axum::response::IntoResponse;
+use strum::{AsRefStr, EnumIter, EnumString, IntoEnumIterator};
+use sslo_lib::error::SsloError;
+use sslo_lib::ndpc2::parameter::{NdpcParameter, NdpcParameterMetaData};
+
+#[derive(AsRefStr, EnumIter, EnumString, PartialEq, Clone)]
+enum Registration {
+    None,
+    FirstComeFirstServed,
+    ByQualification,
+}
+
+pub struct ParamRegistration {
+    meta: NdpcParameterMetaData,
+    value: Registration,
+}
+
+impl NdpcParameter for ParamRegistration {
+    fn upid(&self) -> &'static str { "registration" }
+    fn label(&self) -> &str { "Registration" }
+    fn description(&self) -> &str {"No registration means that drivers cannot register at all (only spontaneous joining\nRegistration allows drivers to occupy seats (and preserve skins)\nIf more drivers register than pits are available, it is possible to use the free practice as qualification"}
+    fn unit(&self) -> Option<&str> { None }
+    fn meta(&self) -> &NdpcParameterMetaData { &self.meta }
+    fn meta_mut(&mut self) -> &mut NdpcParameterMetaData { &mut self.meta }
+
+    fn value_from_string(&mut self, value: &str) -> Result<(), SsloError> {
+        self.value = match value.parse() {
+            Ok(value) => value,
+            Err(e) => {
+                log::warn!("Failed to convert value='{}' for upid={}: {}", value, self.upid(), e);
+                return Err(SsloError::NdpcValueMismatch(self.upid().to_string(), value.to_string()));
+            }
+        };
+        Ok(())
+    }
+
+    fn value2str(&self) -> String { self.value.as_ref().to_string() }
+
+    fn html_input(&self) -> String {
+        let options : Vec<String> = Registration::iter().map(|item| {
+            let selected = if self.value == item {"selected=\"true\""} else {""};
+            format!("<option value=\"{0}\"{1}>{0}</option>", item.as_ref(), selected)
+        }).collect();
+        format!("<select>{}</select>", options.join(""))
+    }
+}
+
+impl ParamRegistration {
+    pub fn new() -> Self { Self {
+        meta: NdpcParameterMetaData::new(),
+        value: Registration::None,
+    } }
+    pub fn value(&self) -> Registration { self.value.clone() }
+}

sslo_league/src/ndpc/coll_preset/param_sim.rs

@@ -42,5 +42,5 @@ impl ParamSim {
         value: SupportedSim::NoSim,
     } }
 
-    pub fn value(&self) -> &SupportedSim { &self.value }
+    pub fn value(&self) -> SupportedSim { self.value.clone() }
 }

sslo_league/src/user_grade.rs

@@ -1,12 +1,12 @@
 use std::cmp::PartialEq;
 use std::ops::Sub;
 use chrono::{DateTime, Utc};
-use strum::{AsRefStr, EnumIter, IntoStaticStr};
+use strum::{AsRefStr, EnumIter, EnumString, IntoStaticStr};
 use enum_primitive_derive::Primitive;
 use num_traits::{FromPrimitive, ToPrimitive};
 use crate::user_permissions::PermissionContainer;
 
-#[derive(PartialEq,Clone,AsRefStr)]
+#[derive(Debug, PartialEq, Primitive, Clone, AsRefStr, EnumIter, EnumString)]
 pub enum License {
     Green = 0,
     Bronze = 1,

sslo_lib/src/ndpc2.rs

@@ -4,6 +4,7 @@ pub mod param_str;
 pub mod param_i64;
 pub mod param_enum;
 pub mod param_time;
+pub mod param_bool;
 
 use crate::error::SsloError;
 use crate::ndpc2::parameter::{NdpcParameterMetaData, NdpcParameter, NdpcParameterIO};

sslo_lib/src/ndpc2/param_bool.rs

@@ -0,0 +1,50 @@
+use crate::error::SsloError;
+use crate::ndpc2::parameter::{NdpcParameter, NdpcParameterMetaData};
+
+pub struct ParamBool {
+    upid: &'static str,
+    label: String,
+    description: String,
+    meta: NdpcParameterMetaData,
+    value: bool,
+}
+
+impl ParamBool {
+    pub fn new(upid: &'static str, label: String, default: bool, description: String) -> Self { Self {
+        upid,
+        label,
+        description,
+        meta: NdpcParameterMetaData::new(),
+        value: default,
+    } }
+
+    pub fn value(&self) -> bool { self.value }
+}
+
+impl NdpcParameter for ParamBool {
+    fn upid(&self) -> &'static str { self.upid}
+    fn label(&self) -> &str { &self.label}
+    fn description(&self) -> &str { &self.description }
+    fn unit(&self) -> Option<&str> { None }
+    fn meta(&self) -> &NdpcParameterMetaData { &self.meta}
+    fn meta_mut(&mut self) -> &mut NdpcParameterMetaData { &mut self.meta }
+
+    fn value_from_string(&mut self, value: &str) -> Result<(), SsloError> {
+        match value.parse::<bool>() {
+            Ok(value) => {
+                self.value = value; Ok(())
+            },
+            Err(e) => {
+                Err(SsloError::NdpcValueMismatch(self.upid.to_string(), value.to_string()))
+            }
+        }
+    }
+
+    fn value2str(&self) -> String {
+        self.value.to_string()
+    }
+
+    fn html_input(&self) -> String {
+        format!("<input type=\"checkbox\" {}>", if self.value { "checked=\"true\"" } else { "" })
+    }
+}