vatfluid 0.2.0

UTF-8 slice validation, with incomplete results to support byte streams.
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

// Copyright (c) 2016 vatfluid developers
//
// Licensed under the Apache License, Version 2.0
// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT
// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. All files in the project carrying such notice may not be copied,
// modified, or distributed except according to those terms.

//! UTF-8 Validation Errors
use std::error::Error;
use std::fmt;

#[derive(Copy, Clone, Debug, Eq, PartialEq)]
/// UTF-8 Validation Errors
pub enum UTF8Validation {
    /// The code point is larger thant the maximum allowed (U+10FFFF)
    MaximumCodePoint,
    /// The 2nd-byte in a 2-byte sequence in not a valid continuation sequence.
    TwoByteContinuation,
    /// Found a 2-byte sequence that could be represented as 1-byte.
    TwoByteOverlong,
    /// The xth-byte in a 3-byte sequence is not a valid continuation sequence.
    ThreeByteContinuation(u8),
    /// Found a 3-byte sequence that could be represented as 2 or 1-byte.
    ThreeByteOverlong,
    /// The xth-byte in a 4-byte sequence is not a valid continuation sequence.
    FourByteContinuation(u8),
    /// Found a 4-byte sequence that could be represented as 3, 2 or 1-byte.
    FourByteOverlong,
    /// Found an invalid first byte (0x80-0xbf)
    InvalidFirstByte(u8),
    /// Found a UTF-16 single surrogat3e
    UTF16Surrogate,
    /// Unknown Error
    Unknown,
}

impl fmt::Display for UTF8Validation {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            UTF8Validation::MaximumCodePoint => {
                write!(f,
                       "The code point is larger thant the maximum allowed (U+10FFFF)")
            }
            UTF8Validation::TwoByteContinuation => {
                write!(f,
                       "The 2nd byte in a 2 byte sequence in not a valid continuation sequence.")
            }
            UTF8Validation::TwoByteOverlong => {
                write!(f,
                       "Found a 2 byte sequence that could be represented as 1 byte.")
            }
            UTF8Validation::ThreeByteContinuation(b) => {
                write!(f,
                       "The xth-byte ({}) in a 3 byte sequence is not a valid continuation byte",
                       b)
            }
            UTF8Validation::ThreeByteOverlong => {
                write!(f,
                       "Found a 3 byte sequence that could be represented as 2 or 1 bytes.")
            }
            UTF8Validation::FourByteContinuation(b) => {
                write!(f,
                       "The xth-byte ({}) in a 4 byte sequence is not a valid continuation byte",
                       b)
            }
            UTF8Validation::FourByteOverlong => {
                write!(f,
                       "Found a 4 byte sequence that could be represented as 3, 2 or 1 bytes.")
            }
            UTF8Validation::InvalidFirstByte(b) => write!(f, "Found an invalid first byte ({})", b),
            UTF8Validation::UTF16Surrogate => write!(f, "Found a UTF-16 surrogate sequence"),
            UTF8Validation::Unknown => write!(f, "unknown UTF8Validation error"),
        }
    }
}

impl Error for UTF8Validation {
    fn description(&self) -> &str {
        match *self {
            UTF8Validation::MaximumCodePoint => {
                "The code point is larger thant the maximum allowed \
            (U+10FFFF)"
            }
            UTF8Validation::TwoByteContinuation => {
                "The 2nd byte in a 2 byte sequence in not a valid \
            continuation sequence"
            }
            UTF8Validation::TwoByteOverlong => {
                "Found a 2 byte sequence that could be represented as \
            1 byte."
            }
            UTF8Validation::ThreeByteContinuation(_) => {
                "The xth-byte in a 3 byte sequence is not a \
            valid continuation byte"
            }
            UTF8Validation::ThreeByteOverlong => {
                "Found a 3 byte sequence that could be represented as \
            2 or 1 bytes."
            }
            UTF8Validation::FourByteContinuation(_) => {
                "The xth-byte in a 4 byte sequence is not a \
            valid continuation byte"
            }
            UTF8Validation::FourByteOverlong => {
                "Found a 4 byte sequence that could be represented as \
            3, 2 or 1 bytes."
            }
            UTF8Validation::InvalidFirstByte(_) => "Found an invalid first byte",
            UTF8Validation::UTF16Surrogate => "Found a UTF-16 surrogate sequence",
            UTF8Validation::Unknown => "unknown UTF8Validation error",
        }
    }
}