pareg_core 0.12.1

This library contains the implementation for the pareg 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
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

use std::{borrow::Cow, fmt::Display, ops::RangeBounds};

use crate::{ArgErrKind, ColorMode};

use super::{ArgErrCtx, Result};

/// Errors thrown when parsing arguments.
#[derive(Debug)]
pub struct ArgError(Box<ArgErrCtx>);

impl ArgError {
    pub fn new(ctx: ArgErrCtx) -> Self {
        Self(Box::new(ctx))
    }

    pub fn from_msg(
        kind: ArgErrKind,
        msg: impl Into<Cow<'static, str>>,
        arg: impl Into<String>,
    ) -> Self {
        Self(Box::new(ArgErrCtx::from_msg(kind, msg, arg.into())))
    }

    pub fn span_start(mut self, pos: usize) -> Self {
        self.0.span_start(pos);
        self
    }

    pub fn long_msg(mut self, msg: impl Into<Cow<'static, str>>) -> Self {
        self.0.long_msg(msg);
        self
    }

    pub fn err<T>(self) -> Result<T> {
        Err(self)
    }

    pub fn hint(mut self, msg: impl Into<Cow<'static, str>>) -> Self {
        self.0.hint(msg);
        self
    }

    pub fn shift_span(
        mut self,
        cnt: usize,
        new_arg: impl Into<String>,
    ) -> Self {
        self.0.shift_span(cnt, new_arg.into());
        self
    }

    pub fn spanned(mut self, span: impl RangeBounds<usize>) -> Self {
        self.0.spanned(span);
        self
    }

    pub fn inline_msg(mut self, msg: impl Into<Cow<'static, str>>) -> Self {
        self.0.inline_msg(msg);
        self
    }

    pub fn add_args(mut self, args: Vec<String>, idx: usize) -> Self {
        self.0.add_args(args, idx);
        self
    }

    pub fn part_of(mut self, arg: impl Into<String>) -> Self {
        self.0.part_of(arg.into());
        self
    }

    pub fn color_mode(mut self, mode: impl Into<ColorMode>) -> Self {
        self.0.color_mode(mode.into());
        self
    }

    pub fn no_color(mut self) -> Self {
        self.0.no_color();
        self
    }

    pub fn postfix_of(mut self, arg: impl Into<String>) -> Self {
        self.0.postfix_of(arg.into());
        self
    }

    pub fn anounce(mut self, anounce: bool) -> Self {
        self.0.anounce = anounce;
        self
    }

    pub fn invalid_value(
        msg: impl Into<Cow<'static, str>>,
        arg: impl Into<String>,
    ) -> Self {
        Self::from_msg(ArgErrKind::InvalidValue, msg, arg)
    }

    pub fn failed_to_parse(
        msg: impl Into<Cow<'static, str>>,
        arg: impl Into<String>,
    ) -> Self {
        Self::from_msg(ArgErrKind::FailedToParse, msg, arg)
    }

    pub fn too_many_arguments(
        msg: impl Into<Cow<'static, str>>,
        arg: impl Into<String>,
    ) -> Self {
        Self::from_msg(ArgErrKind::TooManyArguments, msg, arg)
    }

    pub fn invalid_number_of_arguments(
        msg: impl Into<Cow<'static, str>>,
    ) -> Self {
        Self::from_msg(ArgErrKind::InvalidNumberOfArguments, msg, "")
    }

    pub fn kind(&self) -> &ArgErrKind {
        &self.0.kind
    }

    pub fn map_ctx(mut self, f: impl FnOnce(&mut ArgErrCtx)) -> Self {
        f(&mut self.0);
        self
    }
}

impl std::error::Error for ArgError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        self.0.kind.source()
    }
}

impl Display for ArgError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.0.fmt(f)
    }
}

impl<T> From<T> for ArgError
where
    T: Into<ArgErrKind>,
{
    fn from(value: T) -> Self {
        Self(Box::new(ArgErrCtx::new(value)))
    }
}

impl From<Box<ArgErrCtx>> for ArgError {
    fn from(value: Box<ArgErrCtx>) -> Self {
        Self(value)
    }
}