splitter 0.2.0

A string and slice splitter library
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

# Splitter


[![API](https://docs.rs/splitter/badge.svg)](https://docs.rs/splitter) [![Crate](https://img.shields.io/crates/v/splitter.svg)](https://crates.io/crates/splitter)

### A string and slice splitter library


## String Example

```rust
use splitter::StrSplitter;

let sp = StrSplitter::new("bytes example", " ");
assert_eq!(
    sp.collect::<Vec<_>>(),
    vec!["bytes", " ", "example"],
);
```

## Slice Example

```rust
use splitter::Splitter;

let sp = Splitter::new(&[1, 2, 3, 3, 4], [[2], [4]]);
let re: Vec<&[usize]> = vec![&[1], &[2], &[3, 3], &[4]];
assert_eq!(sp.collect::<Vec<_>>(), re);
```

## Custom Info

```rust
use std::ops::Range;
use splitter::{StrInfo, StrSplitter};

#[derive(Default)]

struct CustomCtx {
    cursor: usize,
}

#[derive(Debug, PartialEq)]

struct Custom<'a> {
    content: &'a str,
    span: Range<usize>,
}

impl<'a> StrInfo<'a> for Custom<'a> {
    type Context = CustomCtx;
    fn generate(ctx: &mut Self::Context, ts: &'a str) -> Self {
        let start = ctx.cursor;
        ctx.cursor += ts.len();
        Custom { content: ts, span: start..ctx.cursor }
    }
}

let sp = StrSplitter::new("bytes example", " ").with_info::<Custom>();
assert_eq!(
    sp.collect::<Vec<_>>(),
    vec![
        Custom { content: "bytes", span: 0..5 },
        Custom { content: " ", span: 5..6 },
        Custom { content: "example", span: 6..13 },
    ],
);
```

## Derive Example (`derive` and `impls` - feature)

```rust
use std::ops::Range;
use splitter::{StrInfo, StrSplitter};

#[derive(Debug, PartialEq, StrInfo)]

struct Custom<'a> {
    content: &'a str,
    span: Range<usize>,
}

let sp = StrSplitter::new("bytes example", " ").with_info::<Custom>();
assert_eq!(
    sp.collect::<Vec<_>>(),
    vec![
        Custom { content: "bytes", span: 0..5 },
        Custom { content: " ", span: 5..6 },
        Custom { content: "example", span: 6..13 },
    ],
);
```

## Derive Info

When using the derive macro, and lifetimes are provided, the first lifetime
has to be the lifetime of the slice or of the string.

Same with generic type parameters, the first generic type parameter
has to be the the type of the slice elements.

## Features

- `std` - enables the standard library (currently only used with `impls` - feature)
- `impls` - automatically implements `Info` and `StrInfo` for usefull types from `core` or `std`
- `infos` - adds pre-defined usefull `Info` and `StrInfo` types
- `derive` - enables the `Info` and `StrInfo` derive macro
- `full` - enables all features

## Automatic Implementations


### `impls` - feature

- `core::pin::Pin`
- `core::marker::PhantomData`
- `core::marker::PhantomPinned`
- `core::mem::ManuallyDrop`
- `core::cell::Cell`
- `core::cell::RefCell`
- `core::cell::UnsafeCell`
- `core::ops::Range`
- `core::ops::RangeInclusive`

### `impls` and `std` - feature

- `std::boxed::Box`
- `std::rc::Rc`
- `std::sync::Arc`
- `std::sync::Mutex`
- `std::sync::RwLock`
- `std::vec::Vec` (only for slices)
- `std::path::PathBuf` (only for strings)
- `std::string::String` (only for strings)