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

//! AMF error.
use std::error;
use std::fmt;
use std::io;
use std::string;

/// AMF Decoding Error.
#[derive(Debug)]
pub enum DecodeError {
    /// I/O error.
    Io(io::Error),

    /// Invalid UTF-8 error.
    String(string::FromUtf8Error),

    /// Unknown marker.
    Unknown {
        /// Unknown marker.
        marker: u8,
    },

    /// Unsupported type.
    Unsupported {
        /// The marker of the unsupported type.
        marker: u8,
    },

    /// Unexpected object end marker (only AMF0).
    UnexpectedObjectEnd,

    /// Circular reference.
    ///
    /// Note that circular references are allowed in the specification,
    /// but limited by the current implementation.
    CircularReference {
        /// Circular reference index.
        index: usize,
    },

    /// Out-of-range reference index.
    OutOfRangeReference {
        /// Out-of-range index.
        index: usize,
    },

    /// Unsupported non-zero time zone (only AMF0).
    NonZeroTimeZone {
        /// Time zone offset (non zero).
        offset: i16,
    },

    /// Invalid unix-time.
    InvalidDate {
        /// Invalid unix-time (e.g., infiniy, minus).
        millis: f64,
    },

    /// Unsupported externalizable type.
    ExternalizableType {
        /// The name of the externalizable type.
        name: String,
    },
}
impl error::Error for DecodeError {
    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
        use self::DecodeError::*;
        match *self {
            Io(ref x) => x.source(),
            String(ref x) => x.source(),
            _ => None,
        }
    }
}
impl fmt::Display for DecodeError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        use self::DecodeError::*;
        match *self {
            Io(ref x) => write!(f, "I/O Error: {}", x),
            String(ref x) => write!(f, "Invalid String: {}", x),
            Unknown { marker } => write!(f, "Unknown marker: {}", marker),
            Unsupported { marker } => write!(f, "Unsupported type: maker={}", marker),
            UnexpectedObjectEnd => write!(f, "Unexpected occurrence of object-end-marker"),
            CircularReference { index } => {
                write!(f, "Circular references are unsupported: index={}", index)
            }
            OutOfRangeReference { index } => write!(f, "Reference index {} is out-of-range", index),
            NonZeroTimeZone { offset } => {
                write!(f, "Non zero time zone offset {} is unsupported", offset)
            }
            InvalidDate { millis } => write!(f, "Invalid date value {}", millis),
            ExternalizableType { ref name } => {
                write!(f, "Externalizable type {:?} is unsupported", name)
            }
        }
    }
}
impl PartialEq for DecodeError {
    fn eq(&self, other: &Self) -> bool {
        use self::DecodeError::*;
        match (self, other) {
            (&Unknown { marker: x }, &Unknown { marker: y }) => x == y,
            (&Unsupported { marker: x }, &Unsupported { marker: y }) => x == y,
            (&UnexpectedObjectEnd, &UnexpectedObjectEnd) => true,
            (&CircularReference { index: x }, &CircularReference { index: y }) => x == y,
            (&OutOfRangeReference { index: x }, &OutOfRangeReference { index: y }) => x == y,
            (&NonZeroTimeZone { offset: x }, &NonZeroTimeZone { offset: y }) => x == y,
            (&InvalidDate { millis: x }, &InvalidDate { millis: y }) => x == y,
            (&ExternalizableType { name: ref x }, &ExternalizableType { name: ref y }) => x == y,
            _ => false,
        }
    }
}
impl From<io::Error> for DecodeError {
    fn from(f: io::Error) -> Self {
        DecodeError::Io(f)
    }
}
impl From<string::FromUtf8Error> for DecodeError {
    fn from(f: string::FromUtf8Error) -> Self {
        DecodeError::String(f)
    }
}