use std::{

    collections::BTreeMap,

    marker::PhantomData,

    ops::{Deref, DerefMut},

};

use arc_bytes::serde::Bytes;

use async_trait::async_trait;

use futures::{future::BoxFuture, Future, FutureExt};

use serde::{Deserialize, Serialize};

#[cfg(feature = "multiuser")]

use zeroize::Zeroize;

#[cfg(feature = "multiuser")]

use crate::schema::NamedReference;

use crate::{

    document::{CollectionDocument, Document, Header, OwnedDocument},

    permissions::Permissions,

    schema::{

        self,

        view::{self, map::MappedDocuments},

        Key, Map, MappedValue, Schema, SchemaName, SerializedCollection,

    },

    transaction::{self, OperationResult, Transaction},

    Error,

};

/// Defines all interactions with a [`schema::Schema`], regardless of whether it

/// is local or remote.

///

/// ## Interacting with [`Collection`s](schema::Collection)

///

/// At its core, each document is just a unique ID and an array of bytes. The

/// low-level interface works with [`OwnedDocument`], which leaves you in charge

/// of deserializing data.

///

/// For most standard use cases, you will be happy to leverage

/// [Serde](https://serde.rs/) / [Transmog](https://github.com/khonsulabs/transmog) and

/// [`CollectionDocument<T>`][cd]/[`SerializedCollection`].

///

/// These examples all use this basic collection type definition:

///

/// ```rust

/// use bonsaidb_core::{

///     schema::{Collection, CollectionName, DefaultSerialization, Schematic},

///     Error,

/// };

/// use serde::{Deserialize, Serialize};

///

/// #[derive(Debug, Serialize, Deserialize, Default)]

/// pub struct MyCollection {

///     pub rank: u32,

///     pub score: f32,

/// }

///

/// impl Collection for MyCollection {

///     fn collection_name() -> CollectionName {

///         CollectionName::new("MyAuthority", "MyCollection")

///     }

///

///     fn define_views(schema: &mut Schematic) -> Result<(), Error> {

///         // ...

///         Ok(())

///     }

/// }

///

/// impl DefaultSerialization for MyCollection {}

/// ```

///

/// ### Using `Connection` with `OwnedDocument`

///

/// #### Inserting a document with an automatically assigned ID

///

/// ```rust

/// # bonsaidb_core::__doctest_prelude!();

/// # fn test_fn<C: Connection>(db: &C) -> Result<(), Error> {

/// # tokio::runtime::Runtime::new().unwrap().block_on(async {

/// let inserted_header = db.collection::<MyCollection>().push_bytes(vec![]).await?;

/// println!(

///     "Inserted id {} with revision {}",

///     inserted_header.id, inserted_header.revision

/// );

/// # Ok(())

/// # })

/// # }

/// ```

///

/// #### Inserting a document with a specific ID

///

/// ```rust

/// # bonsaidb_core::__doctest_prelude!();

/// # fn test_fn<C: Connection>(db: &C) -> Result<(), Error> {

/// # tokio::runtime::Runtime::new().unwrap().block_on(async {

/// let inserted_header = db

///     .collection::<MyCollection>()

///     .insert_bytes(42, vec![])

///     .await?;

/// println!(

///     "Inserted id {} with revision {}",

///     inserted_header.id, inserted_header.revision

/// );

/// # Ok(())

/// # })

/// # }

/// ```

///

/// #### Retrieving a document by ID

///

/// ```rust

/// # bonsaidb_core::__doctest_prelude!();

/// # fn test_fn<C: Connection>(db: &C) -> Result<(), Error> {

/// # tokio::runtime::Runtime::new().unwrap().block_on(async {

/// if let Some(doc) = db.collection::<MyCollection>().get(42).await? {

///     println!(

///         "Retrieved bytes {:?} with revision {}",

///         doc.contents, doc.header.revision

///     );

///     let deserialized = doc.contents::<MyCollection>()?;

///     println!("Deserialized contents: {:?}", deserialized);

/// }

/// # Ok(())

/// # })

/// # }

/// ```

///

/// #### Retreiving multiple documents by IDs

///

/// ```rust

/// # bonsaidb_core::__doctest_prelude!();

/// # fn test_fn<C: Connection>(db: &C) -> Result<(), Error> {

/// # tokio::runtime::Runtime::new().unwrap().block_on(async {

/// for doc in db

///     .collection::<MyCollection>()

///     .get_multiple(&[42, 43])

///     .await?

/// {

///     println!("Retrieved #{} with bytes {:?}", doc.header.id, doc.contents);

///     let deserialized = doc.contents::<MyCollection>()?;

///     println!("Deserialized contents: {:?}", deserialized);

/// }

/// # Ok(())

/// # })

/// # }

/// ```

///

/// #### Retreiving all documents

///

/// ```rust

/// # bonsaidb_core::__doctest_prelude!();

/// # fn test_fn<C: Connection>(db: &C) -> Result<(), Error> {

/// # tokio::runtime::Runtime::new().unwrap().block_on(async {

/// for doc in db.collection::<MyCollection>().list(..).await? {

///     println!("Retrieved #{} with bytes {:?}", doc.header.id, doc.contents);

///     let deserialized = doc.contents::<MyCollection>()?;

///     println!("Deserialized contents: {:?}", deserialized);

/// }

/// # Ok(())

/// # })

/// # }

/// ```

///

/// #### Listing a limited amount of documents in reverse order

///

/// ```rust

/// # bonsaidb_core::__doctest_prelude!();

/// # fn test_fn<C: Connection>(db: &C) -> Result<(), Error> {

/// # tokio::runtime::Runtime::new().unwrap().block_on(async {

/// for doc in db

///     .collection::<MyCollection>()

///     .list(..)

///     .descending()

///     .limit(20)

///     .await?

/// {

///     println!("Retrieved #{} with bytes {:?}", doc.header.id, doc.contents);

///     let deserialized = doc.contents::<MyCollection>()?;

///     println!("Deserialized contents: {:?}", deserialized);

/// }

/// # Ok(())

/// # })

/// # }

/// ```

///

/// ### Using `Connection` with `CollectionDocument<T>`

///

/// #### Inserting a document with an automatically assigned ID

///

/// ```rust

/// # bonsaidb_core::__doctest_prelude!();

/// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

/// # tokio::runtime::Runtime::new().unwrap().block_on(async {

/// let document = MyCollection::default().push_into(&db).await?;

/// println!(

///     "Inserted {:?} with id {} with revision {}",

///     document.contents, document.header.id, document.header.revision

/// );

/// # Ok(())

/// # })

/// # }

/// ```

///

/// #### Inserting a document with a specific ID

///

/// ```rust

/// # bonsaidb_core::__doctest_prelude!();

/// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

/// # tokio::runtime::Runtime::new().unwrap().block_on(async {

/// let document = MyCollection::default().insert_into(42, &db).await?;

/// println!(

///     "Inserted {:?} with id {} with revision {}",

///     document.contents, document.header.id, document.header.revision

/// );

/// # Ok(())

/// # })

/// # }

/// ```

///

/// #### Retrieving a document by ID

///

/// ```rust

/// # bonsaidb_core::__doctest_prelude!();

/// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

/// # tokio::runtime::Runtime::new().unwrap().block_on(async {

/// if let Some(doc) = MyCollection::get(42, &db).await? {

///     println!(

///         "Retrieved revision {} with deserialized contents: {:?}",

///         doc.header.revision, doc.contents

///     );

/// }

/// # Ok(())

/// # })

/// # }

/// ```

///

/// #### Retreiving multiple documents by IDs

///

/// ```rust

/// # bonsaidb_core::__doctest_prelude!();

/// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

/// # tokio::runtime::Runtime::new().unwrap().block_on(async {

/// for doc in MyCollection::get_multiple(&[42, 43], &db).await? {

///     println!(

///         "Retrieved #{} with deserialized contents: {:?}",

///         doc.header.id, doc.contents

///     );

/// }

/// # Ok(())

/// # })

/// # }

/// ```

///

/// #### Retreiving all documents

///

/// ```rust

/// # bonsaidb_core::__doctest_prelude!();

/// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

/// # tokio::runtime::Runtime::new().unwrap().block_on(async {

/// for doc in MyCollection::list(.., &db).await? {

///     println!(

///         "Retrieved #{} with deserialized contents: {:?}",

///         doc.header.id, doc.contents

///     );

/// }

/// # Ok(())

/// # })

/// # }

/// ```

///

/// #### Listing a limited amount of documents in reverse order

///

/// ```rust

/// # bonsaidb_core::__doctest_prelude!();

/// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

/// # tokio::runtime::Runtime::new().unwrap().block_on(async {

/// for doc in MyCollection::list(.., &db).descending().limit(20).await? {

///     println!(

///         "Retrieved #{} with deserialized contents: {:?}",

///         doc.header.id, doc.contents

///     );

/// }

/// # Ok(())

/// # })

/// # }

/// ```

///

/// ## Querying Views

///

/// The examples use this view definition:

///

/// ```rust

/// # mod collection {

/// # bonsaidb_core::__doctest_prelude!();

/// # }

/// # use collection::MyCollection;

/// use bonsaidb_core::{

///     define_basic_unique_mapped_view,

///     document::CollectionDocument,

///     schema::{

///         CollectionViewSchema, DefaultViewSerialization, Name, ReduceResult, View,

///         ViewMapResult, ViewMappedValue,

///     },

/// };

///

/// #[derive(Debug)]

/// pub struct ScoresByRank;

///

/// impl View for ScoresByRank {

///     type Collection = MyCollection;

///     type Key = u32;

///     type Value = f32;

///

///     fn name(&self) -> Name {

///         Name::new("scores-by-rank")

///     }

/// }

///

/// impl CollectionViewSchema for ScoresByRank {

///     type View = Self;

///     fn map(

///         &self,

///         document: CollectionDocument<<Self::View as View>::Collection>,

///     ) -> ViewMapResult<Self::View> {

///         Ok(document

///             .header

///             .emit_key_and_value(document.contents.rank, document.contents.score))

///     }

///

///     fn reduce(

///         &self,

///         mappings: &[ViewMappedValue<Self::View>],

///         rereduce: bool,

///     ) -> ReduceResult<Self::View> {

///         if mappings.is_empty() {

///             Ok(0.)

///         } else {

///             Ok(mappings.iter().map(|map| map.value).sum::<f32>() / mappings.len() as f32)

///         }

///     }

/// }

///

/// impl DefaultViewSerialization for ScoresByRank {}

/// ```

///

/// ### Retrieving all view entries

///

/// ```rust

/// # bonsaidb_core::__doctest_prelude!();

/// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

/// # tokio::runtime::Runtime::new().unwrap().block_on(async {

/// for mapping in db.view::<ScoresByRank>().query().await? {

///     println!(

///         "Mapping from #{} with rank: {} and score: {}",

///         mapping.source.id, mapping.key, mapping.value

///     );

/// }

/// # Ok(())

/// # })

/// # }

/// ```

///

/// ### Retrieving all mappings with the same key

///

/// ```rust

/// # bonsaidb_core::__doctest_prelude!();

/// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

/// # tokio::runtime::Runtime::new().unwrap().block_on(async {

/// for mapping in db.view::<ScoresByRank>().with_key(42).query().await? {

///     println!(

///         "Mapping from #{} with rank: {} and score: {}",

///         mapping.source.id, mapping.key, mapping.value

///     );

/// }

/// # Ok(())

/// # })

/// # }

/// ```

///

/// ### Retrieving all mappings with a range of keys

///

/// ```rust

/// # bonsaidb_core::__doctest_prelude!();

/// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

/// # tokio::runtime::Runtime::new().unwrap().block_on(async {

/// for mapping in db

///     .view::<ScoresByRank>()

///     .with_key_range(42..=44)

///     .query()

///     .await?

/// {

///     println!(

///         "Mapping from #{} with rank: {} and score: {}",

///         mapping.source.id, mapping.key, mapping.value

///     );

/// }

/// # Ok(())

/// # })

/// # }

/// ```

///

/// ### Retrieving the associated documents with a view query

///

/// With [`OwnedDocument`]:

///

/// ```rust

/// # bonsaidb_core::__doctest_prelude!();

/// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

/// # tokio::runtime::Runtime::new().unwrap().block_on(async {

/// for mapping in &db

///     .view::<ScoresByRank>()

///     .with_key_range(42..=44)

///     .query_with_docs()

///     .await?

/// {

///     println!(

///         "Mapping from #{} with rank: {} and score: {}. Document bytes: {:?}",

///         mapping.document.header.id, mapping.key, mapping.value, mapping.document.contents

///     );

/// }

/// # Ok(())

/// # })

/// # }

/// ```

///

/// With [`CollectionDocument<T>`][cd]:

///

/// ```rust

/// # bonsaidb_core::__doctest_prelude!();

/// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

/// # tokio::runtime::Runtime::new().unwrap().block_on(async {

/// for mapping in &db

///     .view::<ScoresByRank>()

///     .with_key_range(42..=44)

///     .query_with_collection_docs()

///     .await?

/// {

///     println!(

///         "Mapping from #{} with rank: {} and score: {}. Deserialized Contents: {:?}",

///         mapping.document.header.id, mapping.key, mapping.value, mapping.document.contents

///     );

/// }

/// # Ok(())

/// # })

/// # }

/// ```

///

/// ### Customizing view query parameters

///

/// ```rust

/// # bonsaidb_core::__doctest_prelude!();

/// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

/// # tokio::runtime::Runtime::new().unwrap().block_on(async {

/// for mapping in db

///     .view::<ScoresByRank>()

///     .with_key_range(42..=44)

///     .descending()

///     .limit(10)

///     .query()

///     .await?

/// {

///     println!(

///         "Mapping from #{} with rank: {} and score: {}",

///         mapping.source.id, mapping.key, mapping.value

///     );

/// }

/// # Ok(())

/// # })

/// # }

/// ```

///

/// ### Reducing a view to its value type

///

/// All of the ways of filtering a view can be used in conjunction with [`reduce()`](View::reduce()).

///

/// ```rust

/// # bonsaidb_core::__doctest_prelude!();

/// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

/// # tokio::runtime::Runtime::new().unwrap().block_on(async {

/// // score is an f32 in this example

/// let score = db.view::<ScoresByRank>().reduce().await?;

/// println!("Average score: {:3}", score);

/// # Ok(())

/// # })

/// # }

/// ```

///

/// ### Reducing a view to its value type, grouping by key

///

/// All of the ways of filtering a view can be used in conjunction with [`reduce()`](View::reduce()).

///

/// ```rust

/// # bonsaidb_core::__doctest_prelude!();

/// # fn test_fn<C: Connection>(db: C) -> Result<(), Error> {

/// # tokio::runtime::Runtime::new().unwrap().block_on(async {

/// // score is an f32 in this example

/// for mapping in db.view::<ScoresByRank>().reduce_grouped().await? {

///     println!(

///         "Rank {} has an average score of {:3}",

///         mapping.key, mapping.value

///     );

/// }

/// # Ok(())

/// # })

/// # }

/// ```

///

/// [cd]: crate::document::CollectionDocument

#[async_trait]

pub trait Connection: Send + Sync {

    /// Accesses a collection for the connected [`schema::Schema`].

    /// Inserts a newly created document into the connected [`schema::Schema`]

    /// for the [`Collection`] `C`. If `id` is `None` a unique id will be

    /// generated. If an id is provided and a document already exists with that

    /// id, a conflict error will be returned.

        } else {

        }

    /// Updates an existing document in the connected [`schema::Schema`] for the

    /// [`Collection`] `C`. Upon success, `doc.revision` will be updated with

    /// the new revision.

        } else {

        }

    /// Retrieves a stored document from [`Collection`] `C` identified by `id`.

    async fn get<C: schema::Collection>(&self, id: u64) -> Result<Option<OwnedDocument>, Error>;

    /// Retrieves all documents matching `ids`. Documents that are not found

    /// are not returned, but no error will be generated.

    async fn get_multiple<C: schema::Collection>(

        &self,

        ids: &[u64],

    ) -> Result<Vec<OwnedDocument>, Error>;

    /// Retrieves all documents within the range of `ids`. Documents that are

    /// not found are not returned, but no error will be generated. To retrieve

    /// all documents, pass in `..` for `ids`.

    async fn list<C: schema::Collection, R: Into<Range<u64>> + Send>(

        &self,

        ids: R,

        order: Sort,

        limit: Option<usize>,

    ) -> Result<Vec<OwnedDocument>, Error>;

    /// Removes a `Document` from the database.

        } else {

        }

    /// Initializes [`View`] for [`schema::View`] `V`.

    #[must_use]

    /// Queries for view entries matching [`View`].

    #[must_use]

    async fn query<V: schema::SerializedView>(

        &self,

        key: Option<QueryKey<V::Key>>,

        order: Sort,

        limit: Option<usize>,

        access_policy: AccessPolicy,

    ) -> Result<Vec<Map<V::Key, V::Value>>, Error>

    where

        Self: Sized;

    /// Queries for view entries matching [`View`] with their source documents.

    #[must_use]

    async fn query_with_docs<V: schema::SerializedView>(

        &self,

        key: Option<QueryKey<V::Key>>,

        order: Sort,

        limit: Option<usize>,

        access_policy: AccessPolicy,

    ) -> Result<MappedDocuments<OwnedDocument, V>, Error>

    where

        Self: Sized;

    /// Queries for view entries matching [`View`] with their source documents, deserialized.

    #[must_use]

        }

    /// Reduces the view entries matching [`View`].

    #[must_use]

    async fn reduce<V: schema::SerializedView>(

        &self,

        key: Option<QueryKey<V::Key>>,

        access_policy: AccessPolicy,

    ) -> Result<V::Value, Error>

    where

        Self: Sized;

    /// Reduces the view entries matching [`View`], reducing the values by each

    /// unique key.

    #[must_use]

    async fn reduce_grouped<V: schema::SerializedView>(

        &self,

        key: Option<QueryKey<V::Key>>,

        access_policy: AccessPolicy,

    ) -> Result<Vec<MappedValue<V::Key, V::Value>>, Error>

    where

        Self: Sized;

    /// Deletes all of the documents associated with this view.

    #[must_use]

    async fn delete_docs<V: schema::SerializedView>(

        &self,

        key: Option<QueryKey<V::Key>>,

        access_policy: AccessPolicy,

    ) -> Result<u64, Error>

    where

        Self: Sized;

    /// Applies a [`Transaction`] to the [`schema::Schema`]. If any operation in the

    /// [`Transaction`] fails, none of the operations will be applied to the

    /// [`schema::Schema`].

    async fn apply_transaction(

        &self,

        transaction: Transaction,

    ) -> Result<Vec<OperationResult>, Error>;

    /// Lists executed [`Transaction`]s from this [`schema::Schema`]. By default, a maximum of

    /// 1000 entries will be returned, but that limit can be overridden by

    /// setting `result_limit`. A hard limit of 100,000 results will be

    /// returned. To begin listing after another known `transaction_id`, pass

    /// `transaction_id + 1` into `starting_id`.

    async fn list_executed_transactions(

        &self,

        starting_id: Option<u64>,

        result_limit: Option<usize>,

    ) -> Result<Vec<transaction::Executed>, Error>;

    /// Fetches the last transaction id that has been committed, if any.

    async fn last_transaction_id(&self) -> Result<Option<u64>, Error>;

    /// Compacts the entire database to reclaim unused disk space.

    ///

    /// This process is done by writing data to a new file and swapping the file

    /// once the process completes. This ensures that if a hardware failure,

    /// power outage, or crash occurs that the original collection data is left

    /// untouched.

    ///

    /// ## Errors

    ///

    /// * [`Error::Io`]: an error occurred while compacting the database.

    async fn compact(&self) -> Result<(), crate::Error>;

    /// Compacts the collection to reclaim unused disk space.

    ///

    /// This process is done by writing data to a new file and swapping the file

    /// once the process completes. This ensures that if a hardware failure,

    /// power outage, or crash occurs that the original collection data is left

    /// untouched.

    ///

    /// ## Errors

    ///

    /// * [`Error::CollectionNotFound`]: database `name` does not exist.

    /// * [`Error::Io`]: an error occurred while compacting the database.

    async fn compact_collection<C: schema::Collection>(&self) -> Result<(), crate::Error>;

    /// Compacts the key value store to reclaim unused disk space.

    ///

    /// This process is done by writing data to a new file and swapping the file

    /// once the process completes. This ensures that if a hardware failure,

    /// power outage, or crash occurs that the original collection data is left

    /// untouched.

    ///

    /// ## Errors

    ///

    /// * [`Error::Io`]: an error occurred while compacting the database.

    async fn compact_key_value_store(&self) -> Result<(), crate::Error>;

}

/// Interacts with a collection over a `Connection`.

pub struct Collection<'a, Cn, Cl> {

    connection: &'a Cn,

    _phantom: PhantomData<Cl>, /* allows for extension traits to be written for collections of specific types */

}

impl<'a, Cn, Cl> Clone for Collection<'a, Cn, Cl> {

}

impl<'a, Cn, Cl> Collection<'a, Cn, Cl>

where

    Cn: Connection,

    Cl: schema::Collection,

{

    /// Creates a new instance using `connection`.

    /// Adds a new `Document<Cl>` with the contents `item`.

    /// Adds a new `Document<Cl>` with the `contents`.

    /// Adds a new `Document<Cl>` with the given `id` and contents `item`.

    /// Adds a new `Document<Cl>` with the the given `id` and `contents`.

    /// Retrieves a `Document<Cl>` with `id` from the connection.

    /// Retrieves all documents matching `ids`. Documents that are not found

    /// are not returned, but no error will be generated.

    /// Retrieves all documents matching `ids`. Documents that are not found

    /// are not returned, but no error will be generated.

    /// Removes a `Document` from the database.

}

pub(crate) struct ListBuilder<'a, Cn, Cl> {

    collection: PossiblyOwned<'a, Collection<'a, Cn, Cl>>,

    range: Range<u64>,

    sort: Sort,

    limit: Option<usize>,

}

pub(crate) enum PossiblyOwned<'a, Cl> {

    Owned(Cl),

    Borrowed(&'a Cl),

}

impl<'a, Cl> Deref for PossiblyOwned<'a, Cl> {

    type Target = Cl;

        }

}

pub(crate) enum ListState<'a, Cn, Cl> {

    Pending(Option<ListBuilder<'a, Cn, Cl>>),

    Executing(BoxFuture<'a, Result<Vec<OwnedDocument>, Error>>),

}

/// Executes [`Connection::list()`] when awaited. Also offers methods to

/// customize the options for the operation.

#[must_use]

pub struct List<'a, Cn, Cl> {

    state: ListState<'a, Cn, Cl>,

}

impl<'a, Cn, Cl> List<'a, Cn, Cl> {

        } else {

        }

    /// Lists documents by id in ascending order.

    /// Lists documents by id in descending order.

    /// Sets the maximum number of results to return.

}

impl<'a, Cn, Cl> Future for List<'a, Cn, Cl>

where

    Cn: Connection,

    Cl: schema::Collection + Unpin,

{

    type Output = Result<Vec<OwnedDocument>, Error>;

            }

        }

}

/// Parameters to query a `schema::View`.

pub struct View<'a, Cn, V: schema::SerializedView> {

    connection: &'a Cn,

    /// Key filtering criteria.

    pub key: Option<QueryKey<V::Key>>,

    /// The view's data access policy. The default value is [`AccessPolicy::UpdateBefore`].

    pub access_policy: AccessPolicy,

    /// The sort order of the query.

    pub sort: Sort,

    /// The maximum number of results to return.

    pub limit: Option<usize>,

}

impl<'a, Cn, V> View<'a, Cn, V>

where

    V: schema::SerializedView,

    Cn: Connection,

{

    /// Filters for entries in the view with `key`.

    #[must_use]

    /// Filters for entries in the view with `keys`.

    #[must_use]

    /// Filters for entries in the view with the range `keys`.

    #[must_use]

    /// Sets the access policy for queries.

    /// Queries the view in ascending order.

    /// Queries the view in descending order.

    /// Sets the maximum number of results to return.

    /// Executes the query and retrieves the results.

    /// Executes the query and retrieves the results with the associated [`Document`s](crate::document::OwnedDocument).

    /// Executes the query and retrieves the results with the associated [`CollectionDocument`s](crate::document::CollectionDocument).

    /// Executes a reduce over the results of the query

    /// Executes a reduce over the results of the query

    /// Deletes all of the associated documents that match this view query.

}

/// A sort order.

pub enum Sort {

    /// Sort ascending (A -> Z).

    Ascending,

    /// Sort descending (Z -> A).

    Descending,

}

/// Filters a [`View`] by key.

pub enum QueryKey<K> {

    /// Matches all entries with the key provided.

    Matches(K),

    /// Matches all entires with keys in the range provided.

    Range(Range<K>),

    /// Matches all entries that have keys that are included in the set provided.

    Multiple(Vec<K>),

}

#[allow(clippy::use_self)] // clippy is wrong, Self is different because of generic parameters

impl<K: for<'a> Key<'a>> QueryKey<K> {

    /// Converts this key to a serialized format using the [`Key`] trait.

            }

        }

}

#[allow(clippy::use_self)] // clippy is wrong, Self is different because of generic parameters

impl<'a, T> QueryKey<T>

where

    T: AsRef<[u8]>,

{

    /// Deserializes the bytes into `K` via the [`Key`] trait.

            }

        }

}

/// A range type that can represent all std range types and be serialized.

pub struct Range<T> {

    /// The start of the range.

    pub start: Bound<T>,

    /// The end of the range.

    pub end: Bound<T>,

}

/// A range bound that can be serialized.

pub enum Bound<T> {

    /// No bound.

    Unbounded,

    /// Bounded by the contained value (inclusive).

    Included(T),

    /// Bounded by the contained value (exclusive).

    Excluded(T),

}

impl<T> Range<T> {

    /// Maps each contained value with the function provided.

    /// Maps each contained value as a reference.

}

impl<'a, T: Key<'a>> Range<T> {

    /// Serializes the range's contained values to big-endian bytes.

        })

}

impl<'a, B> Range<B>

where

    B: AsRef<[u8]>,

{

    /// Deserializes the range's contained values from big-endian bytes.

        })

}

impl<T> Bound<T> {

    /// Maps the contained value, if any, and returns the resulting `Bound`.

        }

    /// Maps each contained value as a reference.

        }

}

impl<'a, T: Key<'a>> Bound<T> {

    /// Serializes the contained value to big-endian bytes.

            ))),

            ))),

        }

}

impl<'a, B> Bound<B>

where

    B: AsRef<[u8]>,

{

    /// Deserializes the bound's contained value from big-endian bytes.

            }

            }

        }

}

impl<T> std::ops::RangeBounds<T> for Range<T> {

}

impl<'a, T> From<&'a Bound<T>> for std::ops::Bound<&'a T> {

        }

}

impl<T> From<std::ops::Range<T>> for Range<T> {

}

impl<T> From<std::ops::RangeFrom<T>> for Range<T> {

}

impl<T> From<std::ops::RangeTo<T>> for Range<T> {