sel-rs 0.2.2

Select slices from text files by line numbers, ranges, positions, or regex
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

//! Typed builder for a ready-to-run pipeline.
//!
//! Encodes the invariant that positional selectors cannot be paired with stdin.

use crate::context::Expander;
use crate::format::Formatter;
use crate::matcher::Matcher;
use crate::sink::Sink;
use crate::source::Source;

/// Type-level marker: any source.
pub trait SourceKind {}
/// Type-level marker: sources that allow positional selectors.
pub trait Seekable: SourceKind {}

pub struct Seek;
pub struct NonSeek;

impl SourceKind for Seek {}
impl SourceKind for NonSeek {}
impl Seekable for Seek {}

pub struct App<K: SourceKind> {
    pub source: Box<dyn Source>,
    pub matcher: Box<dyn Matcher>,
    pub expander: Box<dyn Expander>,
    pub formatter: Box<dyn Formatter>,
    pub sink: Box<dyn Sink>,
    _k: std::marker::PhantomData<K>,
}

/// Stage 1: pick a source.
pub struct Stage1;

impl Stage1 {
    pub fn with_seekable_source(source: Box<dyn Source>) -> Stage2<Seek> {
        Stage2 {
            source,
            _k: std::marker::PhantomData,
        }
    }
    pub fn with_nonseekable_source(source: Box<dyn Source>) -> Stage2<NonSeek> {
        Stage2 {
            source,
            _k: std::marker::PhantomData,
        }
    }
}

/// Stage 2: pick a matcher. Positional only allowed on `Seek`.
pub struct Stage2<K: SourceKind> {
    source: Box<dyn Source>,
    _k: std::marker::PhantomData<K>,
}

impl<K: SourceKind> Stage2<K> {
    pub fn with_matcher(self, matcher: Box<dyn Matcher>) -> Stage3<K> {
        Stage3 {
            source: self.source,
            matcher,
            _k: std::marker::PhantomData,
        }
    }
}

impl Stage2<Seek> {
    /// Positional matcher — only available on seekable sources.
    pub fn with_position_matcher(self, matcher: crate::matcher::PositionMatcher) -> Stage3<Seek> {
        Stage3 {
            source: self.source,
            matcher: Box::new(matcher),
            _k: std::marker::PhantomData,
        }
    }
}

pub struct Stage3<K: SourceKind> {
    source: Box<dyn Source>,
    matcher: Box<dyn Matcher>,
    _k: std::marker::PhantomData<K>,
}

impl<K: SourceKind> Stage3<K> {
    pub fn with_expander(self, expander: Box<dyn Expander>) -> Stage4<K> {
        Stage4 {
            source: self.source,
            matcher: self.matcher,
            expander,
            _k: std::marker::PhantomData,
        }
    }
}

pub struct Stage4<K: SourceKind> {
    source: Box<dyn Source>,
    matcher: Box<dyn Matcher>,
    expander: Box<dyn Expander>,
    _k: std::marker::PhantomData<K>,
}

impl<K: SourceKind> Stage4<K> {
    pub fn with_formatter(self, formatter: Box<dyn Formatter>) -> Stage5<K> {
        Stage5 {
            source: self.source,
            matcher: self.matcher,
            expander: self.expander,
            formatter,
            _k: std::marker::PhantomData,
        }
    }
}

pub struct Stage5<K: SourceKind> {
    source: Box<dyn Source>,
    matcher: Box<dyn Matcher>,
    expander: Box<dyn Expander>,
    formatter: Box<dyn Formatter>,
    _k: std::marker::PhantomData<K>,
}

impl<K: SourceKind> Stage5<K> {
    pub fn with_sink(self, sink: Box<dyn Sink>) -> App<K> {
        App {
            source: self.source,
            matcher: self.matcher,
            expander: self.expander,
            formatter: self.formatter,
            sink,
            _k: std::marker::PhantomData,
        }
    }
}