btypes 0.7.12

Better types (BTypes) for when you dislike normal types, I guess.
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

# btypes

A Rust library providing enhanced types with rich functionality for string manipulation and boolean state management, with more types coming soon.

## Key Features

### BetterString
A feature-rich string type offering:
- Validation for common formats:
  - Email addresses
  - URLs
  - IPv4 addresses
- Pattern matching with regex support
- Encoding/decoding:
  - Base64
  - URL encoding
- String operations:
  - Concatenation using `+` operator
  - Arithmetic operations:
    - `*` repeats a string N times
    - `/` counts occurrences
    - `-` removes a substring
    - `/=` keeps only the first occurrence
  - Case transformations
  - Pattern finding and replacement
  - Safe UTF-8 handling
  - Comprehensive iterator support
  - Rich comparison operations

### Boolean Types
Two main categories with multiple capacity options:

#### Named Boolean Types (Fixed Capacity)
- `BN128`: 128-bit capacity
- `BN64`: 64-bit capacity
- `BN32`: 32-bit capacity
- `BN16`: 16-bit capacity
- `BN8`: 8-bit capacity

#### Infinite Capacity Boolean Types
- `BNInf`: Effectively infinite capacity using dynamic allocation
- Custom types supported via `Nums` and `BitwiseOpsClone`/`BitwiseOpsCopy` traits

Features include:
- Named boolean state management
- Raw binary access and manipulation
- Mass operations with pattern-based flag setting
- Sorting capabilities
- Comprehensive error handling
- Safe and unsafe operation modes
- Iterator support
- Clone and Copy semantics where applicable

## Usage Examples

### String Operations
```rust
use btypes::bstring::BetterString;

fn main() {
    // Basic creation and manipulation
    let mut str1 = BetterString::new("Hello, World!");
    println!("Original: {}", str1);
    println!("Uppercase: {}", str1.to_uppercase());
    
    // Pattern matching and validation
    let email = BetterString::new("user@example.com");
    println!("Valid email: {}", email.is_valid_email());
    
    // Encoding operations
    let encoded = str1.to_base64();
    println!("Base64: {}", encoded);
    
    // Pattern matching and replacement
    let text = BetterString::new("The quick brown fox");
    let matches = text.find_all(r"\w+");
    println!("Words: {:?}", matches);
}
```

### Boolean State Management
```rust
use btypes::named_bools::BN128;

fn main() -> anyhow::Result<()> {
    let mut state = BN128::new();
    
    // Individual state management
    state.set("is_active", true)?;
    state.set("is_validated", false)?;
    
    // Mass operations
    state.mass_set(4, "flag_{n}", "true,false{r}")?;
    
    // State querying
    println!("Active: {}", state.get("is_active")?);
    println!("All states: {:?}", state.all()?);
    
    Ok(())
}
```

### Infinite Boolean Management
```rust
use btypes::inf_named_bools::BNInf;

fn main() -> anyhow::Result<()> {
    let mut state = BNInf::new();
    
    // Can handle very large numbers of flags
    state.mass_set(1000, "flag_{n}", "true,false{r}")?;
    
    // Efficient state management
    println!("States: {:?}", state.all()?);
    
    Ok(())
}
```

## Feature Flags
- `bools`: Basic boolean types
- `named_bools`: Enable named boolean types
- `strings`: String enhancement functionality
- `inf_bools`: Infinite capacity boolean types
- `inf_named_bools`: Named infinite capacity boolean types
- `all`: Enable all features

## Examples
Full working examples available in:
- `/examples/string_ex.rs`: String manipulation demonstrations
- `/examples/bool_ex.rs`: Advanced boolean operations
- `/examples/low_cap_bool_ex.rs`: Different capacity boolean types
- `/examples/inf_cap_bool_ex.rs`: Infinite capacity boolean operations

## License
Licensed under GPL-3.0

## Contributing
Contributions are welcome! Please feel free to submit:
- Pull requests
- Bug reports
- Feature suggestions
- Documentation improvements