flexstr 0.11.7

A flexible, simple to use, clone-efficient string type for Rust
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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

#![allow(dead_code)]

use core::fmt;
use flexstr::{FlexStr, RefCounted};
use flexstr_support::StringToFromBytes;
use inline_flexstr::{INLINE_CAPACITY, InlineFlexStr};

/// Test variant query methods
pub fn test_variant_queries<S, R>(s: &'static S)
where
    S: ?Sized + StringToFromBytes + fmt::Debug + PartialEq,
    R: RefCounted<S>,
    Box<S>: From<S::Owned>,
    S::Owned: AsRef<S>,
{
    // Test borrowed variant
    let borrowed: FlexStr<'_, S, R> = FlexStr::from_borrowed(s);
    assert!(borrowed.is_borrowed());
    assert!(!borrowed.is_inlined());
    assert!(!borrowed.is_ref_counted());
    assert!(!borrowed.is_boxed());
    assert!(borrowed.is_off_heap());
    assert!(!borrowed.is_on_heap());

    // Test inlined variant (input should be small enough to inline)
    let inline_str =
        InlineFlexStr::try_from_type(s).expect("test input should be small enough to inline");
    let inlined: FlexStr<'_, S, R> = FlexStr::from_inline(inline_str);
    assert!(!inlined.is_borrowed());
    assert!(inlined.is_inlined());
    assert!(!inlined.is_ref_counted());
    assert!(!inlined.is_boxed());
    assert!(inlined.is_off_heap());
    assert!(!inlined.is_on_heap());

    // Test ref_counted variant
    let rc: R = s.into();
    let ref_counted: FlexStr<'_, S, R> = FlexStr::from_ref_counted(rc);
    assert!(!ref_counted.is_borrowed());
    assert!(!ref_counted.is_inlined());
    assert!(ref_counted.is_ref_counted());
    assert!(!ref_counted.is_boxed());
    assert!(!ref_counted.is_off_heap());
    assert!(ref_counted.is_on_heap());

    // Test boxed variant
    let boxed: FlexStr<'_, S, R> = FlexStr::from_boxed(Box::from(s.to_owned()));
    assert!(!boxed.is_borrowed());
    assert!(!boxed.is_inlined());
    assert!(!boxed.is_ref_counted());
    assert!(boxed.is_boxed());
    assert!(!boxed.is_off_heap());
    assert!(boxed.is_on_heap());
}

/// Test variant transitions: borrowed -> inlined
pub fn test_transition_borrowed_to_inlined<S, R>(s: &'static S)
where
    S: ?Sized + StringToFromBytes + fmt::Debug + PartialEq,
    R: RefCounted<S>,
{
    let borrowed: FlexStr<'_, S, R> = FlexStr::from_borrowed(s);
    let owned = borrowed.to_owned();

    // Input should be small enough to inline
    assert!(
        s.self_as_raw_bytes().len() <= INLINE_CAPACITY,
        "test input should be small enough to inline"
    );
    assert!(owned.is_inlined() || owned.is_borrowed());
    assert_eq!(owned.as_ref_type(), s);
}

/// Test variant transitions: borrowed -> ref_counted
/// Input must be too large to inline (> INLINE_CAPACITY)
pub fn test_transition_borrowed_to_ref_counted<S, R>(s: &'static S)
where
    S: ?Sized + StringToFromBytes + fmt::Debug + PartialEq,
    R: RefCounted<S>,
{
    assert!(
        s.self_as_raw_bytes().len() > INLINE_CAPACITY,
        "test input must be too large to inline"
    );

    let borrowed: FlexStr<'_, S, R> = FlexStr::from_borrowed(s);
    let owned = borrowed.to_owned();
    assert!(owned.is_ref_counted());
    assert_eq!(owned.as_ref_type(), s);
}

/// Test variant transitions: inlined -> ref_counted
/// Input should be small enough to inline
pub fn test_transition_inlined_to_ref_counted<S, R>(s: &'static S)
where
    S: ?Sized + StringToFromBytes + fmt::Debug + PartialEq,
    R: RefCounted<S>,
{
    let inline_str =
        InlineFlexStr::try_from_type(s).expect("test input should be small enough to inline");
    let inlined: FlexStr<'_, S, R> = FlexStr::from_inline(inline_str);
    let cloned = inlined.clone();

    // Cloning inlined should still be inlined
    assert!(cloned.is_inlined());
    assert_eq!(cloned.as_ref_type(), s);
}

/// Test variant transitions: boxed -> inlined/ref_counted
pub fn test_transition_boxed_to_optimized<S, R>(s: &'static S)
where
    S: ?Sized + StringToFromBytes + fmt::Debug + PartialEq,
    R: RefCounted<S>,
    Box<S>: From<S::Owned>,
    S::Owned: AsRef<S>,
{
    let boxed: FlexStr<'_, S, R> = FlexStr::from_boxed(Box::from(s.to_owned()));
    let optimized = boxed.optimize();

    // Should be inlined or ref_counted, not boxed
    assert!(matches!(
        optimized,
        FlexStr::Inlined(_) | FlexStr::RefCounted(_)
    ));
    assert_eq!(optimized.as_ref_type(), s);
}

/// Test storage optimization
pub fn test_storage_optimization<S, R>(s: &'static S)
where
    S: ?Sized + StringToFromBytes + fmt::Debug + PartialEq,
    R: RefCounted<S>,
    Box<S>: From<S::Owned>,
    S::Owned: AsRef<S>,
{
    // Test optimize on boxed (should convert to inlined or ref_counted)
    let boxed: FlexStr<'_, S, R> = FlexStr::from_boxed(Box::from(s.to_owned()));
    let optimized = boxed.optimize();
    assert!(matches!(
        optimized,
        FlexStr::Inlined(_) | FlexStr::RefCounted(_)
    ));
    assert_eq!(optimized.as_ref_type(), s);

    // Test optimize on borrowed (should stay borrowed)
    let borrowed: FlexStr<'_, S, R> = FlexStr::from_borrowed(s);
    let optimized = borrowed.optimize();
    assert!(optimized.is_borrowed());
    assert_eq!(optimized.as_ref_type(), s);

    // Test optimize on inlined (should stay inlined)
    // Input should be small enough to inline
    let inline_str =
        InlineFlexStr::try_from_type(s).expect("test input should be small enough to inline");
    let inlined: FlexStr<'_, S, R> = FlexStr::from_inline(inline_str);
    let optimized = inlined.optimize();
    assert!(optimized.is_inlined());
    assert_eq!(optimized.as_ref_type(), s);
}