Adding upstream version 115.8.0esr.upstream/115.8.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 150 insertions, 0 deletions

diff --git a/third_party/rust/rkv/src/error.rs b/third_party/rust/rkv/src/error.rs
new file mode 100644
index 0000000000..f50dda73e4
--- /dev/null
+++ b/third_party/rust/rkv/src/error.rs
@@ -0,0 +1,150 @@
+// Copyright 2018-2019 Mozilla
+//
+// Licensed 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.
+
+use std::{io, path::PathBuf, sync, thread, thread::ThreadId};
+
+use thiserror::Error;
+
+pub use crate::backend::SafeModeError;
+use crate::value::Type;
+
+#[derive(Debug, Error)]
+pub enum DataError {
+    #[error("unknown type tag: {0}")]
+    UnknownType(u8),
+
+    #[error("unexpected type tag: expected {expected}, got {actual}")]
+    UnexpectedType { expected: Type, actual: Type },
+
+    #[error("empty data; expected tag")]
+    Empty,
+
+    #[error("invalid value for type {value_type}: {err}")]
+    DecodingError {
+        value_type: Type,
+        err: Box<bincode::ErrorKind>,
+    },
+
+    #[error("couldn't encode value: {0}")]
+    EncodingError(#[from] Box<bincode::ErrorKind>),
+
+    #[error("invalid uuid bytes")]
+    InvalidUuid,
+}
+
+#[derive(Debug, Error)]
+pub enum StoreError {
+    #[error("manager poisoned")]
+    ManagerPoisonError,
+
+    #[error("database corrupted")]
+    DatabaseCorrupted,
+
+    #[error("key/value pair not found")]
+    KeyValuePairNotFound,
+
+    #[error("unsupported size of key/DB name/data")]
+    KeyValuePairBadSize,
+
+    #[error("file is not a valid database")]
+    FileInvalid,
+
+    #[error("environment mapsize reached")]
+    MapFull,
+
+    #[error("environment maxdbs reached")]
+    DbsFull,
+
+    #[error("environment maxreaders reached")]
+    ReadersFull,
+
+    #[error("I/O error: {0:?}")]
+    IoError(#[from] io::Error),
+
+    #[error("environment path does not exist or not the right type: {0:?}")]
+    UnsuitableEnvironmentPath(PathBuf),
+
+    #[error("data error: {0:?}")]
+    DataError(#[from] DataError),
+
+    #[cfg(feature = "lmdb")]
+    #[error("lmdb backend error: {0}")]
+    LmdbError(lmdb::Error),
+
+    #[error("safe mode backend error: {0}")]
+    SafeModeError(SafeModeError),
+
+    #[error("read transaction already exists in thread {0:?}")]
+    ReadTransactionAlreadyExists(ThreadId),
+
+    #[error("attempted to open DB during transaction in thread {0:?}")]
+    OpenAttemptedDuringTransaction(ThreadId),
+}
+
+impl StoreError {
+    pub fn open_during_transaction() -> StoreError {
+        StoreError::OpenAttemptedDuringTransaction(thread::current().id())
+    }
+
+    pub fn read_transaction_already_exists() -> StoreError {
+        StoreError::ReadTransactionAlreadyExists(thread::current().id())
+    }
+}
+
+impl<T> From<sync::PoisonError<T>> for StoreError {
+    fn from(_: sync::PoisonError<T>) -> StoreError {
+        StoreError::ManagerPoisonError
+    }
+}
+
+#[derive(Debug, Error)]
+pub enum CloseError {
+    #[error("manager poisoned")]
+    ManagerPoisonError,
+
+    #[error("close attempted while manager has an environment still open")]
+    EnvironmentStillOpen,
+
+    #[error("close attempted while an environment not known to the manager is still open")]
+    UnknownEnvironmentStillOpen,
+
+    #[error("I/O error: {0:?}")]
+    IoError(#[from] io::Error),
+}
+
+impl<T> From<sync::PoisonError<T>> for CloseError {
+    fn from(_: sync::PoisonError<T>) -> CloseError {
+        CloseError::ManagerPoisonError
+    }
+}
+
+#[derive(Debug, Error)]
+pub enum MigrateError {
+    #[error("store error: {0}")]
+    StoreError(#[from] StoreError),
+
+    #[error("close error: {0}")]
+    CloseError(#[from] CloseError),
+
+    #[error("manager poisoned")]
+    ManagerPoisonError,
+
+    #[error("source is empty")]
+    SourceEmpty,
+
+    #[error("destination is not empty")]
+    DestinationNotEmpty,
+}
+
+impl<T> From<sync::PoisonError<T>> for MigrateError {
+    fn from(_: sync::PoisonError<T>) -> MigrateError {
+        MigrateError::ManagerPoisonError
+    }
+}