Fix doc links

Author: rklaehn

src/api/blobs.rs

@@ -577,7 +577,7 @@ pub struct AddPathOptions {
 /// It also implements [`IntoFuture`], so you can await it to get the [`TempTag`] that
 /// contains the hash of the added content and also protects the content.
 ///
-/// If you want access to the stream, you can use the [`AddResult::stream`] method.
+/// If you want access to the stream, you can use the [`AddProgress::stream`] method.
 pub struct AddProgress<'a> {
     blobs: &'a Blobs,
     inner: stream::Boxed<AddProgressItem>,
@@ -643,9 +643,6 @@ impl<'a> AddProgress<'a> {
 ///
 /// Calling [`ObserveProgress::stream`] will return a stream of updates, where
 /// the first item is the current state and subsequent items are updates.
-///
-/// Calling [`ObserveProgress::aggregated`] will return a stream of states,
-/// where each state is the current state at the time of the update.
 pub struct ObserveProgress {
     inner: future::Boxed<irpc::Result<mpsc::Receiver<Bitfield>>>,
 }
@@ -826,7 +823,7 @@ impl BlobsListProgress {
 /// is often inconvenient, so there are a number of higher level methods to
 /// process the stream.
 ///
-/// You can get access to the underlying stream using the [`ExportBaoResult::stream`] method.
+/// You can get access to the underlying stream using the [`ExportBaoProgress::stream`] method.
 pub struct ExportRangesProgress {
     ranges: RangeSet2<u64>,
     inner: future::Boxed<irpc::Result<mpsc::Receiver<ExportRangesItem>>>,
@@ -907,7 +904,7 @@ impl ExportRangesProgress {
 /// is often inconvenient, so there are a number of higher level methods to
 /// process the stream.
 ///
-/// You can get access to the underlying stream using the [`ExportBaoResult::stream`] method.
+/// You can get access to the underlying stream using the [`ExportBaoProgress::stream`] method.
 pub struct ExportBaoProgress {
     inner: future::Boxed<irpc::Result<mpsc::Receiver<EncodedItem>>>,
 }

src/api/proto.rs

@@ -574,7 +574,7 @@ impl From<Leaf> for ExportRangesItem {
 /// Progress events for exporting to a local file.
 ///
 /// Exporting does not involve outboard computation, so the events are simpler
-/// than [`ImportProgress`].
+/// than [`AddProgressItem`].
 ///
 /// Size -> CopyProgress(*n) -> Done
 ///

src/api/remote.rs

@@ -1,6 +1,6 @@
 //! API for downloading blobs from a single remote node.
 //!
-//! The entry point is the [`Download`] struct.
+//! The entry point is the [`Remote`] struct.
 use genawaiter::sync::{Co, Gen};
 use iroh::endpoint::SendStream;
 use irpc::util::{AsyncReadVarintExt, WriteVarintExt};
@@ -24,18 +24,18 @@ use crate::{
 /// API to compute request and to download from remote nodes.
 ///
 /// Usually you want to first find out what, if any, data you have locally.
-/// This can be done using [`Download::local`], which inspects the local store
+/// This can be done using [`Remote::local`], which inspects the local store
 /// and returns a [`LocalInfo`].
 ///
 /// From this you can compute various values such as the number of locally present
 /// bytes. You can also compute a request to get the missing data using [`LocalInfo::missing`].
 ///
-/// Once you have a request, you can execute it using [`Download::execute`].
+/// Once you have a request, you can execute it using [`Remote::execute_get`].
 /// Executing a request will store to the local store, but otherwise does not take
 /// the available data into account.
 ///
 /// If you are not interested in the details and just want your data, you can use
-/// [`Download::fetch`]. This will internally do the dance described above.
+/// [`Remote::fetch`]. This will internally do the dance described above.
 #[derive(Debug, Clone, RefCast)]
 #[repr(transparent)]
 pub struct Remote {

src/get.rs

@@ -1,8 +1,8 @@
 //! The low level client side API
 //!
 //! Note that while using this API directly is fine, a simpler way to get data
-//! to a store is to use the [`crate::api::download`] API, in particular the
-//! [`crate::api::download::Download::fetch`] function to download data to your
+//! to a store is to use the [`crate::api::remote`] API, in particular the
+//! [`crate::api::remote::Remote::fetch`] function to download data to your
 //! local store.
 //!
 //! To get data, create a connection using an [`iroh::Endpoint`].
@@ -592,8 +592,8 @@ pub mod fsm {
     /// provider should never do this, so this is an indication that the provider is
     /// not behaving correctly.
     ///
-    /// The [`DecodeError::Io`] variant is just a fallback for any other io error that
-    /// is not actually a [`ReadError`].
+    /// The [`DecodeError::DecodeIo`] variant is just a fallback for any other io error that
+    /// is not actually a [`DecodeError::Read`].
     ///
     /// [`ReadError`]: endpoint::ReadError
     #[common_fields({

src/get/request.rs

@@ -1,10 +1,10 @@
 //! Utilities to generate or execute complex get requests without persisting to a store.
 //!
 //! Any complex request can be executed with downloading to a store, using the
-//! [`crate::api::download::Download::execute`] method. But for some requests it
+//! [`crate::api::remote::Remote::execute_get`] method. But for some requests it
 //! is useful to just get the data without persisting it to a store.
 //!
-//! In addition to these utilities, there are also constructors in [`crate::protocol::RangeSpecSeq`]
+//! In addition to these utilities, there are also constructors in [`crate::protocol::ChunkRangesSeq`]
 //! to construct complex requests.
 use std::{
     pin::Pin,

src/protocol.rs

@@ -109,7 +109,7 @@
 //! want the entire blob, no matter how many chunks it has.
 //!
 //! Since this is a very common case, there is a convenience method
-//! [`GetRequest::single`] that only requires the hash of the blob.
+//! [`GetRequest::blob`] that only requires the hash of the blob.
 //!
 //! ```rust
 //! # use iroh_blobs::protocol::GetRequest;
@@ -285,7 +285,7 @@
 //! let request = GetRequest::blob(child_hash);
 //! ```
 //!
-//! ### Why RangeSpec and RangeSpecSeq?
+//! ### Why ChunkRanges and ChunkRangesSeq?
 //!
 //! You might wonder why we have [`ChunkRangesSeq`], when a simple
 //! sequence of [`ChunkRanges`] might also do.
@@ -416,7 +416,7 @@ pub enum Request {
     Push(PushRequest),
     /// Get multiple blobs in a single request, from a single provider
     ///
-    /// This is identical to a [`GetRequest`] for a [`HashSeq`], but the provider
+    /// This is identical to a [`GetRequest`] for a [`crate::hashseq::HashSeq`], but the provider
     /// does not need to have the hash seq.
     GetMany(GetManyRequest),
 }
@@ -971,15 +971,15 @@ mod tests {
                 r"
                     00 # enum variant for GetRequest
                     dadadadadadadadadadadadadadadadadadadadadadadadadadadadadadadada # the hash
-                    020001000100 # the RangeSpecSeq
+                    020001000100 # the ChunkRangesSeq
             ",
             ),
             (
                 Request::from(GetRequest::all(hash)),
                 r"
                     00 # enum variant for GetRequest
                     dadadadadadadadadadadadadadadadadadadadadadadadadadadadadadadada # the hash
-                    01000100 # the RangeSpecSeq
+                    01000100 # the ChunkRangesSeq
             ",
             ),
         ];

src/protocol/range_spec.rs

@@ -1,9 +1,9 @@
 //! Specifications for ranges selection in blobs and sequences of blobs.
 //!
-//! The [`RangeSpec`] allows specifying which BAO chunks inside a single blob should be
+//! The [`ChunkRanges`] allows specifying which BAO chunks inside a single blob should be
 //! selected.
 //!
-//! The [`RangeSpecSeq`] builds on top of this to select blob chunks in an entire
+//! The [`ChunkRangesSeq`] builds on top of this to select blob chunks in an entire
 //! collection.
 use std::{fmt, sync::OnceLock};
 
@@ -62,37 +62,37 @@ impl ChunkRangesSeq {
         Self(inner)
     }
 
-    /// A [`RangeSpecSeq`] containing all chunks from all blobs.
+    /// A [`ChunkRangesSeq`] containing all chunks from all blobs.
     ///
-    /// [`RangeSpecSeq::iter`], will return a full range forever.
+    /// [`ChunkRangesSeq::iter`], will return a full range forever.
     pub fn all() -> Self {
         let mut inner = SmallVec::new();
         inner.push((0, ChunkRanges::all()));
         Self(inner)
     }
 
-    /// A [`RangeSpecSeq`] getting the verified size for the first blob.
+    /// A [`ChunkRangesSeq`] getting the verified size for the first blob.
     pub fn verified_size() -> Self {
         let mut inner = SmallVec::new();
         inner.push((0, ChunkRanges::last_chunk()));
         inner.push((1, ChunkRanges::empty()));
         Self(inner)
     }
 
-    /// A [`RangeSpecSeq`] getting the entire first blob and verified sizes for all others.
+    /// A [`ChunkRangesSeq`] getting the entire first blob and verified sizes for all others.
     pub fn verified_child_sizes() -> Self {
         let mut inner = SmallVec::new();
         inner.push((0, ChunkRanges::all()));
         inner.push((1, ChunkRanges::last_chunk()));
         Self(inner)
     }
 
-    /// Checks if this [`RangeSpec`] does not select any chunks in the blob.
+    /// Checks if this [`ChunkRangesSeq`] does not select any chunks in the blob.
     pub fn is_empty(&self) -> bool {
         self.0.is_empty()
     }
 
-    /// Checks if this [`RangeSpec`] selects all chunks in the blob.
+    /// Checks if this [`ChunkRangesSeq`] selects all chunks in the blob.
     pub fn is_all(&self) -> bool {
         if self.0.len() != 1 {
             return false;
@@ -155,7 +155,7 @@ impl ChunkRangesSeq {
     /// This iterator will only yield items for blobs which have at least one chunk
     /// selected.
     ///
-    /// This iterator is infinite if the [`RangeSpecSeq`] ends on a non-empty [`RangeSpec`],
+    /// This iterator is infinite if the [`ChunkRangesSeq`] ends on a non-empty [`ChunkRanges`],
     /// that is all further blobs have selected chunks spans.
     pub fn iter_non_empty_infinite(&self) -> NonEmptyRequestRangeSpecIter<'_> {
         NonEmptyRequestRangeSpecIter::new(self.iter_infinite())
@@ -339,6 +339,9 @@ impl<'a> Iterator for NonEmptyRequestRangeSpecIter<'a> {
 
 /// A chunk range specification as a sequence of chunk offsets.
 ///
+/// This is just the wire encoding of a [`ChunkRanges`]. You should rarely have to
+/// interact with this directly.
+///
 /// Offsets encode alternating spans starting on 0, where the first span is always
 /// deselected.
 ///

src/store/fs/import.rs

@@ -195,7 +195,7 @@ async fn import_bytes_tiny_impl(
 ) -> io::Result<ImportEntry> {
     let size = cmd.data.len() as u64;
     // send the required progress events
-    // ImportProgress::Done will be sent when finishing the import!
+    // AddProgressItem::Done will be sent when finishing the import!
     tx.send(AddProgressItem::Size(size))
         .await
         .map_err(|_e| io::Error::other("error"))?;