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.3.0 To strval-0.3.1

2025-08-03
00:41
Some FromStr implementations were missing validation calls. check-in: 1fe47acddf user: jan tags: trunk
2025-07-30
00:47
Add missing date. check-in: 8cf0fe0bcc user: jan tags: strval-0.3.1, trunk
00:45
Implement Display for data types. check-in: e1141e3da7 user: jan tags: trunk
2025-07-28
23:53
Use rusqlite 0.37.0. check-in: ea24b44e08 user: jan tags: strval-0.3.0, trunk
2025-07-09
17:33
More ignore experimentation. check-in: d43ecc80f1 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.3.0"
version = "0.3.1"
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. 
1

2
3
4
5
6
7
8


1
2
3
4
5
6
7
8

-
+








use std::{marker::PhantomData, str::FromStr};
use std::{fmt, marker::PhantomData, str::FromStr};

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
};
︙
64
65
66
67
68
69
70






71
72
73
74
75
76
77

64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83








+
+
+
+
+
+








}

impl<C> AsRef<str> for BinU64Count<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}

impl<C> fmt::Display for BinU64Count<C> {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    write!(f, "{}", self.sval)
  }
}

impl<C> FromStr for BinU64Count<C> {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    let val = parse_size::Config::default()
      .with_binary()
︙
Changes to src/binu64size.rs. 
1

2
3
4
5
6
7
8


1
2
3
4
5
6
7
8

-
+








use std::{marker::PhantomData, str::FromStr};
use std::{fmt, marker::PhantomData, str::FromStr};

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
};
︙
64
65
66
67
68
69
70






71
72
73
74
75
76
77

64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83








+
+
+
+
+
+








}

impl<C> AsRef<str> for BinU64Size<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}

impl<C> fmt::Display for BinU64Size<C> {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    write!(f, "{}", self.sval)
  }
}

impl<C> FromStr for BinU64Size<C> {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    let val = parse_size::Config::default()
      .with_binary()
︙
Changes to src/binusizecount.rs. 
1

2
3
4
5
6
7
8


1
2
3
4
5
6
7
8

-
+








use std::{marker::PhantomData, str::FromStr};
use std::{fmt, marker::PhantomData, str::FromStr};

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
};
︙
64
65
66
67
68
69
70






71
72
73
74
75
76
77

64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83








+
+
+
+
+
+








}

impl<C> AsRef<str> for BinUsizeCount<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}

impl<C> fmt::Display for BinUsizeCount<C> {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    write!(f, "{}", self.sval)
  }
}

impl<C> FromStr for BinUsizeCount<C> {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    let val = parse_size::Config::default()
      .with_binary()
︙
Changes to src/binusizesize.rs. 
1

2
3
4
5
6
7
8


1
2
3
4
5
6
7
8

-
+








use std::{marker::PhantomData, str::FromStr};
use std::{fmt, marker::PhantomData, str::FromStr};

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
};
︙
64
65
66
67
68
69
70






71
72
73
74
75
76
77

64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83








+
+
+
+
+
+








}

impl<C> AsRef<str> for BinUsizeSize<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}

impl<C> fmt::Display for BinUsizeSize<C> {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    write!(f, "{}", self.sval)
  }
}

impl<C> FromStr for BinUsizeSize<C> {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    let val = parse_size::Config::default()
      .with_binary()
︙
Changes to src/boolean.rs. 
1

2
3
4
5
6
7
8


1
2
3
4
5
6
7
8

-
+








use std::str::FromStr;
use std::{fmt, str::FromStr};

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
};
︙
56
57
58
59
60
61
62






63
64
65
66
67
68
69

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








+
+
+
+
+
+








}

impl AsRef<str> for Bool {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}

impl fmt::Display for Bool {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    write!(f, "{}", self.sval)
  }
}

impl FromStr for Bool {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    let val = match s {
      "0" | "false" | "f" | "off" => false,
︙
Changes to src/decu64count.rs. 
1

2
3
4
5
6
7
8


1
2
3
4
5
6
7
8

-
+








use std::{marker::PhantomData, str::FromStr};
use std::{fmt, marker::PhantomData, str::FromStr};

use parse_size::ByteSuffix;

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
︙
64
65
66
67
68
69
70






71
72
73
74
75
76
77

64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83








+
+
+
+
+
+








}

impl<C> AsRef<str> for DecU64Count<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}

impl<C> fmt::Display for DecU64Count<C> {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    write!(f, "{}", self.sval)
  }
}

impl<C> FromStr for DecU64Count<C> {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    let val = parse_size::Config::default()
      .with_decimal()
︙
Changes to src/decu64size.rs. 
1

2
3
4
5
6
7
8


1
2
3
4
5
6
7
8

-
+








use std::{marker::PhantomData, str::FromStr};
use std::{fmt, marker::PhantomData, str::FromStr};

use parse_size::ByteSuffix;

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
︙
63
64
65
66
67
68
69






70
71
72
73
74
75
76

63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82








+
+
+
+
+
+








}

impl<C> AsRef<str> for DecU64Size<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}

impl<C> fmt::Display for DecU64Size<C> {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    write!(f, "{}", self.sval)
  }
}

impl<C> FromStr for DecU64Size<C> {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    let val = parse_size::Config::default()
      .with_decimal()
︙
Changes to src/decusizecount.rs. 
1

2
3
4
5
6
7
8


1
2
3
4
5
6
7
8

-
+








use std::{marker::PhantomData, str::FromStr};
use std::{fmt, marker::PhantomData, str::FromStr};

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
};
︙
64
65
66
67
68
69
70






71
72
73
74
75
76
77

64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83








+
+
+
+
+
+








}

impl<C> AsRef<str> for DecUsizeCount<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}

impl<C> fmt::Display for DecUsizeCount<C> {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    write!(f, "{}", self.sval)
  }
}

impl<C> FromStr for DecUsizeCount<C> {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    let val = parse_size::Config::default()
      .with_decimal()
︙
Changes to src/decusizesize.rs. 
1

2
3
4
5
6
7
8


1
2
3
4
5
6
7
8

-
+








use std::{marker::PhantomData, str::FromStr};
use std::{fmt, marker::PhantomData, str::FromStr};

use parse_size::ByteSuffix;

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
︙
63
64
65
66
67
68
69






70
71
72
73
74
75
76

63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82








+
+
+
+
+
+








}

impl<C> AsRef<str> for DecUsizeSize<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}

impl<C> fmt::Display for DecUsizeSize<C> {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    write!(f, "{}", self.sval)
  }
}

impl<C> FromStr for DecUsizeSize<C> {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    let val = parse_size::Config::default()
      .with_decimal()
︙
Changes to src/dur.rs. 
1

2
3
4
5
6
7
8


1
2
3
4
5
6
7
8

-
+








use std::{marker::PhantomData, str::FromStr, time::Duration};
use std::{fmt, marker::PhantomData, str::FromStr, time::Duration};

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
};
︙
69
70
71
72
73
74
75






76
77
78
79
80
81
82

69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88








+
+
+
+
+
+








}

impl<C> AsRef<str> for Dur<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}

impl<C> fmt::Display for Dur<C> {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    write!(f, "{}", self.sval)
  }
}

impl<C> FromStr for Dur<C> {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    let dur = s
      .parse::<jiff::SignedDuration>()
︙
Changes to src/percent.rs. 
1
2
3

4
5
6
7
8
9
10

1
2

3
4
5
6
7
8
9
10



-
+








//! Relative or absolute limit.

use std::str::FromStr;
use std::{fmt, str::FromStr};

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
};
︙
52
53
54
55
56
57
58






59
60
61
62
63
64
65

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








+
+
+
+
+
+








}

impl AsRef<str> for Percent {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}

impl fmt::Display for Percent {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    write!(f, "{}", self.sval)
  }
}

impl FromStr for Percent {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    if let Some(s) = s.strip_suffix("%") {
      let val = s.parse::<f32>().unwrap();
︙
Changes to src/relabslim.rs. 
1
2
3

4
5
6
7
8
9
10

1
2

3
4
5
6
7
8
9
10



-
+








//! Relative or absolute limit.

use std::{marker::PhantomData, str::FromStr};
use std::{fmt, marker::PhantomData, str::FromStr};

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
};
︙
100
101
102
103
104
105
106






107
108
109
110
111
112
113

100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119








+
+
+
+
+
+








}

impl<C> AsRef<str> for RelAbsLim<C> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}

impl<C> fmt::Display for RelAbsLim<C> {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    write!(f, "{}", self.sval)
  }
}

impl<C> FromStr for RelAbsLim<C> {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
    if let Some(s) = s.strip_suffix("%") {
      let f = s.parse::<f32>().unwrap();
︙
Changes to src/select.rs. 
1

2
3
4
5
6
7
8


1
2
3
4
5
6
7
8

-
+








use std::str::FromStr;
use std::{fmt, str::FromStr};

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
};
︙
54
55
56
57
58
59
60






61
62
63
64
65
66
67

54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73








+
+
+
+
+
+








}

impl<E> AsRef<str> for Select<E> {
  fn as_ref(&self) -> &str {
    &self.sval
  }
}

impl<E> fmt::Display for Select<E> {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    write!(f, "{}", self.sval)
  }
}

impl<E> FromStr for Select<E>
where
  E: FromStr
{
  type Err = Error;
︙
Changes to src/str.rs. 
1

2
3
4
5
6
7
8


1
2
3
4
5
6
7
8

-
+








use std::{marker::PhantomData, str::FromStr};
use std::{fmt, marker::PhantomData, str::FromStr};

#[cfg(feature = "rusqlite")]
use rusqlite::{
  ToSql,
  types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}
};
︙
61
62
63
64
65
66
67






68
69
70
71
72
73
74

61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80








+
+
+
+
+
+








}

impl<C> AsRef<str> for Str<C> {
  fn as_ref(&self) -> &str {
    &self.val
  }
}

impl<C> fmt::Display for Str<C> {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    write!(f, "{}", self.val)
  }
}

impl<C> FromStr for Str<C>
where
  C: Controller<Type = String>
{
  type Err = Error;
︙
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

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







-
+







+
+
+
+
+
+
+
+
+
+








# Change Log

⚠️  indicates a breaking change.

## [Unreleased]

[Details](/vdiff?from=strval-0.3.0&to=trunk)
[Details](/vdiff?from=strval-0.3.1&to=trunk)

### Added

### Changed

### Removed

---

## [0.3.1] - 2025-07-30

[Details](/vdiff?from=strval-0.3.0&to=strval-0.3.1)

### Added

- Implement `Display` for data types.  Returns the string representation.

---

## [0.3.0] - 2025-07-29

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

### Changed
︙