strval 0.5.0

Parse strings into values
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

//! _strval_ is collection of types that keep values that can all be set from a
//! string value.  It can be thought of as a generalized version of the
//! `FromStr` trait.
//!
//! ```
//! use strval::{
//!   StrVal, Bool, BinU64Count, BinU64Size, DecU64Count, DecU64Size
//! };
//!
//! let v: Bool = "true".parse().unwrap();
//! assert!(v.get());
//! assert_eq!(v.val_str(), Some(String::from("true")));
//!
//! // "count" variant is assumed to not count bytes
//! let v: BinU64Count = "64k".parse().unwrap();
//! assert_eq!(v.get(), 65536);
//! assert_eq!(v.val_str(), Some(String::from("65536")));
//!
//! // "size" variant is assumed to be a byte size
//! let v: BinU64Size = "64kb".parse().unwrap();
//! assert_eq!(v.get(), 65536);
//! assert_eq!(v.val_str(), Some(String::from("65536")));
//!
//! // "count" variant is assumed to not count bytes
//! let v: DecU64Count = "64k".parse().unwrap();
//! assert_eq!(v.get(), 64000);
//! assert_eq!(v.val_str(), Some(String::from("64000")));
//!
//! // "size" variant is assumed to be a byte size
//! let v: DecU64Size = "64kb".parse().unwrap();
//! assert_eq!(v.get(), 64000);
//! assert_eq!(v.val_str(), Some(String::from("64000")));
//! ```
//!
//! # Features
//! | Feature    | Function
//! |------------|----------
//! | `rusqlite` | Implement `ToSql`/`FromSql` support for value types.

#![cfg_attr(docsrs, feature(doc_cfg))]

mod binu64count;
mod binu64size;
mod binusizecount;
mod binusizesize;
mod boolean;
mod decu64count;
mod decu64size;
mod decusizecount;
mod decusizesize;
mod dur;
mod err;
mod percent;
mod relabslim;
mod select;
mod str;

use std::str::FromStr;

pub use {
  binu64count::BinU64Count, binu64size::BinU64Size,
  binusizecount::BinUsizeCount, binusizesize::BinUsizeSize, boolean::Bool,
  decu64count::DecU64Count, decu64size::DecU64Size,
  decusizecount::DecUsizeCount, decusizesize::DecUsizeSize, dur::Dur,
  err::Error, percent::Percent, relabslim::RelAbsLim, select::Select,
  str::Str
};

/// Traits for values that can be set from strings.
pub trait StrVal: AsRef<str> + FromStr {
  type Type;

  /// # Errors
  fn set(&mut self, sval: &str) -> Result<Self::Type, Error>;

  fn get(&self) -> Self::Type;

  /// Return a string representation of the value.
  fn val_str(&self) -> Option<String>;

  /// Return a string representation of the configuration parameter's value,
  /// with an optional "evaluated" string.
  ///
  /// If the "evaluated" string is identical to the regular string
  /// representation, the second field will be `None`.
  fn get_str_vals(&self) -> (String, Option<String>);
}

/// Define a default (string) value and provide a value validator.
pub trait Controller {
  type Type;

  fn def() -> String;

  /// # Errors
  fn validate(val: &Self::Type) -> Result<(), Error>;
}


/// Accept any `u64`.
#[derive(Clone, Debug)]
pub struct AnyU64;

impl Controller for AnyU64 {
  type Type = u64;

  fn def() -> String {
    String::from("0")
  }

  fn validate(_val: &Self::Type) -> Result<(), Error> {
    Ok(())
  }
}

/// Accept any `usize`.
#[derive(Clone, Debug)]
pub struct AnyUsize;

impl Controller for AnyUsize {
  type Type = usize;

  fn def() -> String {
    String::from("0")
  }

  fn validate(_val: &Self::Type) -> Result<(), Error> {
    Ok(())
  }
}

// vim: set ft=rust et sw=2 ts=2 sts=2 cinoptions=2 tw=79 :