strval

Check-in Differences
Login

Check-in Differences

Invert Patch Path Side-by-Side Diff

Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Difference From strval-0.1.1 To strval-0.2.0

2025-07-09
16:47
bacon sound experiments. check-in: c31ae1c29e user: jan tags: trunk
01:01
Release maintenance. check-in: 8e2b07e015 user: jan tags: strval-0.2.0, trunk
00:57
Add get_str_vals(). check-in: b50740496c user: jan tags: trunk
00:03
Release maintenance. check-in: 4db9183b11 user: jan tags: strval-0.1.1, trunk
2025-07-08
23:59
Add BinUsizeCount, BinUsizeSize, DecUsizeCount, DecUsizeSize. check-in: 27dde2c763 user: jan tags: trunk

Changes to Cargo.toml. 
1
2
3

4
5
6
7
8
9
10

1
2

3
4
5
6
7
8
9
10



-
+








[package]
name = "strval"
version = "0.1.1"
version = "0.2.0"
edition = "2024"
license = "0BSD"
# https://crates.io/category_slugs
categories = ["text-processing"]
keywords = ["parsing", "string", "rusqlite"]
repository = "https://repos.qrnch.tech/pub/strval"
description = "Parse strings into values"
︙
Changes to src/binu64count.rs.
︙
51
52
53
54
55
56
57






58
59
60
61
62
63
64

51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70








+
+
+
+
+
+








  fn get(&self) -> Self::Type {
    self.val
  }

  fn val_str(&self) -> Option<String> {
    Some(self.val.to_string())
  }

  fn get_str_vals(&self) -> (String, Option<String>) {
    let eval = self.val.to_string();
    let eval = (self.sval != eval).then_some(eval);
    (self.sval.clone(), eval)
  }
}

impl<C> AsRef<str> for BinU64Count<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}
︙
Changes to src/binu64size.rs.
︙
51
52
53
54
55
56
57






58
59
60
61
62
63
64

51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70








+
+
+
+
+
+








  fn get(&self) -> Self::Type {
    self.val
  }

  fn val_str(&self) -> Option<String> {
    Some(self.val.to_string())
  }

  fn get_str_vals(&self) -> (String, Option<String>) {
    let eval = self.val.to_string();
    let eval = (self.sval != eval).then_some(eval);
    (self.sval.clone(), eval)
  }
}

impl<C> AsRef<str> for BinU64Size<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}
︙
Changes to src/binusizecount.rs.
︙
51
52
53
54
55
56
57






58
59
60
61
62
63
64

51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70








+
+
+
+
+
+








  fn get(&self) -> Self::Type {
    self.val
  }

  fn val_str(&self) -> Option<String> {
    Some(self.val.to_string())
  }

  fn get_str_vals(&self) -> (String, Option<String>) {
    let eval = self.val.to_string();
    let eval = (self.sval != eval).then_some(eval);
    (self.sval.clone(), eval)
  }
}

impl<C> AsRef<str> for BinUsizeCount<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}
︙
Changes to src/binusizesize.rs.
︙
51
52
53
54
55
56
57






58
59
60
61
62
63
64

51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70








+
+
+
+
+
+








  fn get(&self) -> Self::Type {
    self.val
  }

  fn val_str(&self) -> Option<String> {
    Some(self.val.to_string())
  }

  fn get_str_vals(&self) -> (String, Option<String>) {
    let eval = self.val.to_string();
    let eval = (self.sval != eval).then_some(eval);
    (self.sval.clone(), eval)
  }
}

impl<C> AsRef<str> for BinUsizeSize<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}
︙
Changes to src/boolean.rs.
︙
45
46
47
48
49
50
51




52
53
54
55
56
57
58

45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62








+
+
+
+








  fn val_str(&self) -> Option<String> {
    if self.val {
      Some(String::from("true"))
    } else {
      Some(String::from("false"))
    }
  }

  fn get_str_vals(&self) -> (String, Option<String>) {
    (self.sval.clone(), None)
  }
}

impl AsRef<str> for Bool {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}
︙
Changes to src/decu64count.rs.
︙
51
52
53
54
55
56
57






58
59
60
61
62
63
64

51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70








+
+
+
+
+
+








  fn get(&self) -> Self::Type {
    self.val
  }

  fn val_str(&self) -> Option<String> {
    Some(self.val.to_string())
  }

  fn get_str_vals(&self) -> (String, Option<String>) {
    let eval = self.val.to_string();
    let eval = (self.sval != eval).then_some(eval);
    (self.sval.clone(), eval)
  }
}

impl<C> AsRef<str> for DecU64Count<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}
︙
Changes to src/decu64size.rs.
︙
50
51
52
53
54
55
56






57
58
59
60
61
62
63

50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69








+
+
+
+
+
+








  fn get(&self) -> Self::Type {
    self.val
  }

  fn val_str(&self) -> Option<String> {
    Some(self.val.to_string())
  }

  fn get_str_vals(&self) -> (String, Option<String>) {
    let eval = self.val.to_string();
    let eval = (self.sval != eval).then_some(eval);
    (self.sval.clone(), eval)
  }
}

impl<C> AsRef<str> for DecU64Size<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}
︙
Changes to src/decusizecount.rs.
︙
51
52
53
54
55
56
57






58
59
60
61
62
63
64

51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70








+
+
+
+
+
+








  fn get(&self) -> Self::Type {
    self.val
  }

  fn val_str(&self) -> Option<String> {
    Some(self.val.to_string())
  }

  fn get_str_vals(&self) -> (String, Option<String>) {
    let eval = self.val.to_string();
    let eval = (self.sval != eval).then_some(eval);
    (self.sval.clone(), eval)
  }
}

impl<C> AsRef<str> for DecUsizeCount<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}
︙
Changes to src/decusizesize.rs.
︙
50
51
52
53
54
55
56






57
58
59
60
61
62
63

50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69








+
+
+
+
+
+








  fn get(&self) -> Self::Type {
    self.val
  }

  fn val_str(&self) -> Option<String> {
    Some(self.val.to_string())
  }

  fn get_str_vals(&self) -> (String, Option<String>) {
    let eval = self.val.to_string();
    let eval = (self.sval != eval).then_some(eval);
    (self.sval.clone(), eval)
  }
}

impl<C> AsRef<str> for DecUsizeSize<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}
︙
Changes to src/dur.rs.
︙
58
59
60
61
62
63
64




65
66
67
68
69
70
71

58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75








+
+
+
+








  fn get(&self) -> Self::Type {
    self.val
  }

  fn val_str(&self) -> Option<String> {
    None
  }

  fn get_str_vals(&self) -> (String, Option<String>) {
    (self.sval.clone(), None)
  }
}

impl<C> AsRef<str> for Dur<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}
︙
Changes to src/lib.rs.
︙
73
74
75
76
77
78
79







80
81
82
83
84
85
86

73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93








+
+
+
+
+
+
+








  /// # 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;
︙
Changes to src/percent.rs.
︙
41
42
43
44
45
46
47




48
49
50
51
52
53
54

41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58








+
+
+
+








  fn get(&self) -> Self::Type {
    self.val
  }

  fn val_str(&self) -> Option<String> {
    Some(format!("{}%", self.val * 100.0))
  }

  fn get_str_vals(&self) -> (String, Option<String>) {
    (self.sval.clone(), None)
  }
}

impl AsRef<str> for Percent {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}
︙
Changes to src/relabslim.rs.
︙
89
90
91
92
93
94
95




96
97
98
99
100
101
102

89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106








+
+
+
+









  fn val_str(&self) -> Option<String> {
    match self.val {
      Lim::Rel(f) => Some(f.to_string()),
      Lim::Abs(v) => Some(v.to_string())
    }
  }

  fn get_str_vals(&self) -> (String, Option<String>) {
    (self.sval.clone(), None)
  }
}

impl<C> AsRef<str> for RelAbsLim<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}
︙
Changes to src/select.rs.
︙
43
44
45
46
47
48
49




50
51
52
53
54
55
56

43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60








+
+
+
+








  fn get(&self) -> Self::Type {
    self.val
  }

  fn val_str(&self) -> Option<String> {
    None
  }

  fn get_str_vals(&self) -> (String, Option<String>) {
    (self.sval.clone(), None)
  }
}

impl<E> AsRef<str> for Select<E> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}
︙
Changes to src/str.rs.
︙
50
51
52
53
54
55
56




57
58
59
60
61
62
63

50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67








+
+
+
+








  fn get(&self) -> Self::Type {
    self.val.clone()
  }

  fn val_str(&self) -> Option<String> {
    None
  }

  fn get_str_vals(&self) -> (String, Option<String>) {
    (self.val.clone(), None)
  }
}

impl<C> AsRef<str> for Str<C> {
  fn as_ref(&self) -> &str {
    &self.val
  }
}
︙
Changes to www/changelog.md. 
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

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







-
+








+
+
+
+
+
+
+
+
+
+



-
+








# Change Log

⚠️  indicates a breaking change.

## [Unreleased]

[Details](/vdiff?from=strval-0.1.0&to=trunk)
[Details](/vdiff?from=strval-0.2.0&to=trunk)

### Added

### Changed

### Removed

---

## [0.2.0] - 2025-07-09

[Details](/vdiff?from=strval-0.1.1&to=strval-0.2.0)

### Added

- ⚠️ Add trait method `StrVal::get_str_vals()`.

---

## [0.1.1] - 2025-07-09

[Details](/vdiff?from=strval-0.1.0&to=trunk)
[Details](/vdiff?from=strval-0.1.0&to=strval-0.1.1)

### Added

- `BinUsizeCount`, `BinUsizeSize`, `DecUsizeCount`, `DecUsizeSize`

---
︙