//! At the moment, only B trees are implemented, as well as three
//! important traits:

//! At the moment, only B trees are implemented, as well as the
//! following general traits:

//! - [`Representable`] is the trait of types that can be written to
//! disk and read from the disk.

//!
//! Moreover, two other traits can be used to store things on pages:
//! [`Storable`] is a simple trait that all `Sized + Ord` types
//! without references can readily implement (the [`direct_repr!`]
//! macro does that). For types containing references to pages
//! allocated in the database, the comparison function can be
//! customised. Moreover, these types must supply an iterator over
//! these references, in order for reference-counting to work properly
//! when the datastructures referencing these types are forked.
//!
//! Dynamically-sized types, or types that need to be represented in a
//! dynamically-sized way, can use the [`UnsizedStorable`] format.

/// Types that can be stored on disk.

/// Types that can be stored on disk. This trait may be used in
/// conjunction with `Sized` in order to determine the on-disk size,
/// or with [`UnsizedStorable`] when special arrangements are needed.

    fn page_offsets(&self) -> Self::PageOffsets;

    fn page_references(&self) -> Self::PageReferences;

    type PageOffsets: Iterator<Item = u64>;

    type PageReferences: Iterator<Item = u64>;

/// A macro to implement [`Representable`] on "plain" types,

/// A macro to implement [`Storable`] on "plain" types,

            type PageOffsets = core::iter::Empty<u64>;
            fn page_offsets(&self) -> Self::PageOffsets {

            type PageReferences = core::iter::Empty<u64>;
            fn page_references(&self) -> Self::PageReferences {

    type PageOffsets = core::iter::Empty<u64>;
    fn page_offsets(&self) -> Self::PageOffsets {

    type PageReferences = core::iter::Empty<u64>;
    fn page_references(&self) -> Self::PageReferences {

/// Representation of a mutable or shared page.

/// Representation of a mutable or shared page. This is an owned page
/// (like `Vec` in Rust's std), but we do not know whether we can
/// mutate it or not.
///
/// The least-significant bit of the first byte of each page is 1 if
/// and only if the page was allocated by the current transaction (and
/// hence isn't visible to any other transaction, meaning we can write
/// on it).

/// Representation of a borrowed, or immutable page, like a slice in
/// Rust.

    /// Borrows the page.

        }
    }
    pub fn null() -> Self {
        CowPage {
            data: core::ptr::null_mut(),
            offset: 0,

/// The layout of pages is as follows: the LSB of the first byte is
/// "dirty".

/// An owned page on which we can write. This is just a wrapper around
/// `CowPage` to avoid checking the "dirty" bit at running time.

    /// Checks the dirty bit of a page.

/// Trait for loading a page and a root. Base trait to implement
/// "storage engines" under Sanakirja.

/// Trait for loading a page.

    /// RC
    fn rc(&self, off: u64) -> Result<u64, Self::Error>;

    /// Reference-counting. Since reference-counts are designed to be
    /// storable into B trees by external allocators, pages referenced
    /// once aren't stored, and hence are indistinguishable from pages
    /// that are never referenced. The default implementation returns
    /// 0.
    ///
    /// This has the extra benefit of requiring less disk space, and
    /// isn't more unsafe than storing the reference count, since we
    /// aren't supposed to hold a reference to a page with "logical
    /// RC" 0, so storing "1" for that page would be redundant anyway.
    fn rc(&self, _off: u64) -> Result<u64, Self::Error> {
        Ok(0)
    }

/// Trait for loading a page and a root. Base trait to implement
/// "storage engines" under Sanakirja.

/// Trait for allocating and freeing pages.

    /// Allocate a new page.

    // Returns the new RC.

    /// Increment the page's reference count.

    // Returns the new RC (0 if freed).

    /// Decrement the page's reference count, assuming the page was
    /// first allocated by another transaction. If the RC reaches 0,
    /// free the page. Must return the new RC (0 if freed).

    // Returns the new RC (0 if freed).

    /// Same as [`decr_rc`], but for pages allocated by the current
    /// transaction. This is an important distinction, as pages
    /// allocated by the current transaction can be reused immediately
    /// after being freed.

            for o in k.page_offsets().chain(v.page_offsets()) {

            for o in k.page_references().chain(v.page_references()) {

                for o in k.page_offsets().chain(v.page_offsets()) {

                for o in k.page_references().chain(v.page_references()) {

        for o in delk.page_offsets().chain(delv.page_offsets()) {

        for o in delk.page_references().chain(delv.page_references()) {

            for o in k.page_offsets().chain(v.page_offsets()) {

            for o in k.page_references().chain(v.page_references()) {

                for o in k.page_offsets().chain(v.page_offsets()) {

                for o in k.page_references().chain(v.page_references()) {

                for o in split_key.page_offsets().chain(split_value.page_offsets()) {

                for o in split_key
                    .page_references()
                    .chain(split_value.page_references())
                {

        for o in k.page_offsets().chain(v.page_offsets()) {

        for o in k.page_references().chain(v.page_references()) {

        for o in k.page_offsets().chain(v.page_offsets()) {

        for o in k.page_references().chain(v.page_references()) {

        for o in k.page_offsets().chain(v.page_offsets()) {

        for o in k.page_references().chain(v.page_references()) {

                for o in k.page_offsets().chain(v.page_offsets()) {

                for o in k.page_references().chain(v.page_references()) {