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

// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.

//! Common Parquet errors and macros.

use std::cell;
use std::convert;
use std::io;
use std::result;

use snap;
use thrift;

quick_error! {
  /// Set of errors that can be produced during different operations in Parquet.
  #[derive(Debug, PartialEq)]
  pub enum ParquetError {
    /// General Parquet error.
    /// Returned when code violates normal workflow of working with Parquet files.
    General(message: String) {
      display("Parquet error: {}", message)
      description(message)
      from(e: io::Error) -> (format!("underlying IO error: {}", e))
      from(e: snap::Error) -> (format!("underlying snap error: {}", e))
      from(e: thrift::Error) -> (format!("underlying Thrift error: {}", e))
      from(e: cell::BorrowMutError) -> (format!("underlying borrow error: {}", e))
    }
    /// "Not yet implemented" Parquet error.
    /// Returned when functionality is not yet available.
    NYI(message: String) {
      display("NYI: {}", message)
      description(message)
    }
    /// "End of file" Parquet error.
    /// Returned when IO related failures occur, e.g. when there are not enough bytes to
    /// decode.
    EOF(message: String) {
      display("EOF: {}", message)
      description(message)
    }
  }
}

/// A specialized `Result` for Parquet errors.
pub type Result<T> = result::Result<T, ParquetError>;

// ----------------------------------------------------------------------
// Conversion from `ParquetError` to other types of `Error`s

impl convert::From<ParquetError> for io::Error {
  fn from(e: ParquetError) -> Self {
    io::Error::new(io::ErrorKind::Other, e)
  }
}

// ----------------------------------------------------------------------
// Convenient macros for different errors

macro_rules! general_err {
  ($fmt:expr) => (ParquetError::General($fmt.to_owned()));
  ($fmt:expr, $($args:expr),*) => (ParquetError::General(format!($fmt, $($args),*)));
  ($e:expr, $fmt:expr) => (ParquetError::General($fmt.to_owned(), $e));
  ($e:ident, $fmt:expr, $($args:tt),*) => (
    ParquetError::General(&format!($fmt, $($args),*), $e));
}

macro_rules! nyi_err {
  ($fmt:expr) => (ParquetError::NYI($fmt.to_owned()));
  ($fmt:expr, $($args:expr),*) => (ParquetError::NYI(format!($fmt, $($args),*)));
}

macro_rules! eof_err {
  ($fmt:expr) => (ParquetError::EOF($fmt.to_owned()));
  ($fmt:expr, $($args:expr),*) => (ParquetError::EOF(format!($fmt, $($args),*)));
}