ages_ice_archive

https://docs.rs/ages-ice-archive/latest/ages_ice_archive/
Admin
ages_ice_archive is a Rust crate providing operations to read and write SEGA ICE archives used in...
Tokens:43,321
Snippets:311
Trust Score:9.1
Update:12 hours ago
Show doc for...
Tokens:
Raw
### fn step_by(self, step: usize) -> StepBy<Self>

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceGroupIter.html

Creates an iterator starting at the same point, but stepping by the given amount at each iteration.

```APIDOC
## fn step_by(self, step: usize) -> StepBy<Self>

### Description
Creates an iterator starting at the same point, but stepping by the given amount at each iteration.

### Method
step_by

### Signature
fn step_by(self, step: usize) -> StepBy<Self>
where Self: Sized

### Parameters
- **step** (usize) - The step size between iterations.

### Returns
- **StepBy<Self>** - An iterator that steps by the given amount.

### Notes
- Available since Rust 1.0.0.
```

--------------------------------

### IceWriter::new

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceWriter.html

Begins a new ICE archive with the specified version, compression, encryption, and Oodle settings. Returns a Result with an IceWriter or an UnsupportedVersion error.

```APIDOC
## IceWriter::new

### Description
Begins a new ICE archive with the specified version, compression, encryption, and Oodle settings.

### Method
new

### Signature
pub fn new(version: u32, compress: bool, encrypt: bool, oodle: bool) -> Result<IceWriter, UnsupportedVersion>

### Parameters
- **version** (u32) - Required - The archive version.
- **compress** (bool) - Required - Whether to compress the archive.
- **encrypt** (bool) - Required - Whether to encrypt the archive.
- **oodle** (bool) - Required - Whether to use Oodle compression.

### Returns
- **Ok(IceWriter)** - A new IceWriter instance.
- **Err(UnsupportedVersion)** - If the version is not supported.
```

--------------------------------

### IceArchive::load

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceArchive.html

Opens an IO source as an IceArchive, parsing the header and reading group data into memory.

```APIDOC
## load<R: Read + Seek>(src: R) -> Result<IceArchive, LoadError>

### Description
Opens an IO source as an `IceArchive`, parsing the header from the start of the source and reading group data into local memory.

### Parameters
- `src` (R) - Required - The IO source to read from, must implement `Read` and `Seek`.

### Returns
- `Result<IceArchive, LoadError>` - The parsed archive or a load error.
```

--------------------------------

### IceWriter::begin_file

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceWriter.html

Begins a file within the archive. Returns an IceFileWriter that must be finished to add the file to the archive.

```APIDOC
## IceWriter::begin_file

### Description
Begins a file in the archive. The returned IceFileWriter must have its `finish` method called to add the file to the archive.

### Method
begin_file

### Signature
pub fn begin_file<'a>(&'a mut self, name: &AsciiStr, ext: &AsciiStr, group: Group) -> IceFileWriter<'a>

### Parameters
- **name** (&AsciiStr) - Required - The file name.
- **ext** (&AsciiStr) - Required - The file extension.
- **group** (Group) - Required - The file group.

### Returns
- **IceFileWriter<'a>** - A writer for the file.
```

--------------------------------

### by_ref

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceFileWriter.html

Creates a 'by reference' adapter for this instance of Write.

```APIDOC
## by_ref

### Description
Creates a “by reference” adapter for this instance of `Write`.

### Method
`fn by_ref(&mut self) -> &mut Self where Self: Sized`

### Parameters
None.

### Returns
- `&mut Self` - A mutable reference to the writer.
```

--------------------------------

### Writing an ICE file with IceWriter

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/

Creates a new ICE archive (version 4) and writes a single file 'hello.txt' into Group1. The writer is finished into a Vec<u8> buffer, but any Write sink is acceptable.

```rust
use std::io::Write;
use ages_ice_archive::{Group, IceWriter};
use ascii::AsciiStr;

let mut ice_writer = IceWriter::new(4, true, true, false).unwrap();
{
    let mut file = ice_writer.begin_file(
        AsciiStr::from_ascii("hello.txt").unwrap(),
        AsciiStr::from_ascii("txt").unwrap(),
        Group::Group1,
    );
    file.write_all(b"hello world");
    file.finish();
}
let mut buf = Vec::new(); // any Write sink is acceptable
ice_writer.finish(&mut buf).unwrap();
```

--------------------------------

### Reading an ICE file with IceArchive::load and IceGroupIter

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/

Loads an ICE file from disk, decompresses both groups, and prints the names of files in each group. Requires the file path 'ice_file.ice' to exist and be a valid ICE archive.

```rust
use std::fs::File;
use ages_ice_archive::{Group, IceArchive, IceGroupIter};

let ice_archive = IceArchive::load(
    File::open("ice_file.ice").unwrap()
).unwrap();
let g1_data = ice_archive.decompress_group(Group::Group1).unwrap();
let g2_data = ice_archive.decompress_group(Group::Group2).unwrap();

println!("Group 1:");
let g1_iter = IceGroupIter::new(&g1_data[..], ice_archive.group_count(Group::Group1)).unwrap();
for f in g1_iter {
    println!("\t{}", f.name().unwrap());
}

println!("Group 2:");
let g2_iter = IceGroupIter::new(&g2_data[..], ice_archive.group_count(Group::Group2)).unwrap();
for f in g2_iter {
    println!("\t{}", f.name().unwrap());
}
```

--------------------------------

### IceArchive::load

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/

Loads an ICE archive from a readable source. This is the primary entry point for reading ICE files.

```APIDOC
## IceArchive::load

### Description
Loads an ICE archive from a readable source. This is the primary entry point for reading ICE files.

### Method
`IceArchive::load(reader: R) -> Result<IceArchive, Error>`

### Parameters
- **reader** (R: Read) - Required - The source to read the ICE archive from.

### Returns
- **Result<IceArchive, Error>** - The loaded ICE archive or an error.

### Example
```rust
use std::fs::File;
use ages_ice_archive::IceArchive;

let ice_archive = IceArchive::load(File::open("ice_file.ice").unwrap()).unwrap();
```
```

--------------------------------

### IceGroupIter::next

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/

Advances the iterator and returns the next file entry, or None if exhausted.

```APIDOC
## IceGroupIter::next

### Description
Advances the iterator and returns the next file entry, or None if exhausted.

### Method
`IceGroupIter::next(&mut self) -> Option<IceFile>`

### Returns
- **Option<IceFile>** - The next file entry, or None if the iterator is exhausted.

### Example
```rust
for f in g1_iter {
    println!("\t{}", f.name().unwrap());
}
```
```

--------------------------------

### IceFileWriter::finish

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/

Completes the file insertion into the in-progress ICE group.

```APIDOC
## IceFileWriter::finish

### Description
Completes the file insertion into the in-progress ICE group.

### Method
`IceFileWriter::finish(&mut self) -> Result<(), Error>`

### Returns
- **Result<(), Error>** - Ok if successful, or an error.

### Example
```rust
file.finish();
```
```

--------------------------------

### fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceGroupIter.html

Advances the iterator by n elements. This is a nightly-only experimental API.

```APIDOC
## fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

### Description
Advances the iterator by `n` elements.

### Method
advance_by

### Signature
fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

### Parameters
- **n** (usize) - The number of elements to advance by.

### Returns
- **Result<(), NonZero<usize>>** - Ok(()) if the iterator advanced by exactly n elements, or Err(NonZero<usize>) with the remaining number of elements if the iterator ended early.

### Notes
- This is a nightly-only experimental API (`iter_advance_by`).
```

--------------------------------

### write_all

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceFileWriter.html

Attempts to write an entire buffer into this writer. This method is part of the Write trait.

```APIDOC
## write_all

### Description
Attempts to write an entire buffer into this writer. This method is part of the `Write` trait.

### Method
`fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>`

### Parameters
- `buf` (`&[u8]`) - The buffer to write.

### Returns
- `Result<(), Error>` - Returns `Ok(())` if the entire buffer was written successfully, or an `Error` otherwise.
```

--------------------------------

### IceFileWriter::write_all

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/

Writes all bytes to the file being written.

```APIDOC
## IceFileWriter::write_all

### Description
Writes all bytes to the file being written.

### Method
`IceFileWriter::write_all(&mut self, buf: &[u8]) -> Result<(), Error>`

### Parameters
- **buf** (&[u8]) - Required - The bytes to write.

### Returns
- **Result<(), Error>** - Ok if successful, or an error.

### Example
```rust
file.write_all(b"hello world");
```
```

--------------------------------

### write_all_vectored

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceFileWriter.html

Attempts to write multiple buffers into this writer. This is a nightly-only experimental API.

```APIDOC
## write_all_vectored

### Description
Attempts to write multiple buffers into this writer. This is a nightly-only experimental API.

### Method
`fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>`

### Parameters
- `bufs` (`&mut [IoSlice<'_>]`) - A mutable slice of `IoSlice` buffers to write.

### Returns
- `Result<(), Error>` - Returns `Ok(())` if all buffers were written successfully, or an `Error` otherwise.

### Notes
- Nightly-only experimental API (`write_all_vectored`).
```

--------------------------------

### write_fmt

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceFileWriter.html

Writes a formatted string into this writer, returning any error encountered.

```APIDOC
## write_fmt

### Description
Writes a formatted string into this writer, returning any error encountered.

### Method
`fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>`

### Parameters
- `args` (`Arguments<'_>`) - The formatted arguments to write.

### Returns
- `Result<(), Error>` - Returns `Ok(())` if the formatted string was written successfully, or an `Error` otherwise.
```

--------------------------------

### IceFile::ext

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceFile.html

Returns the reported ASCII extension of the file entry as a Result<&str, AsciiError>.

```APIDOC
## IceFile::ext

### Description
Get the reported ASCII extension of the file entry.

### Method
pub fn ext(&self) -> Result<&str, AsciiError>

### Parameters
None

### Returns
- `Result<&str, AsciiError>` - The ASCII extension or an AsciiError if the extension is not valid ASCII.

```

--------------------------------

### map_windows

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceGroupIter.html

Calls the given function f for each contiguous window of size N over self and returns an iterator over the outputs of f.

```APIDOC
## map_windows

### Description
Calls the given function f for each contiguous window of size N over self and returns an iterator over the outputs of f. Like slice::windows(), the windows during mapping overlap as well.

### Method
map_windows

### Signature
fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
where Self: Sized, F: FnMut(&[Self::Item; N]) -> R

### Parameters
- **f** (F) - Required - A closure that takes a reference to an array of N items and returns R.

### Returns
- **MapWindows<Self, F, N>** - An iterator over the outputs of f for each window.

### Notes
- This is a nightly-only experimental API (iter_map_windows).
```

--------------------------------

### IceGroupIter::new

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/

Creates an iterator over the file entries in a decompressed group data buffer.

```APIDOC
## IceGroupIter::new

### Description
Creates an iterator over the file entries in a decompressed group data buffer.

### Method
`IceGroupIter::new(data: &[u8], count: usize) -> Result<IceGroupIter, Error>`

### Parameters
- **data** (&[u8]) - Required - The decompressed group data.
- **count** (usize) - Required - The number of files in the group.

### Returns
- **Result<IceGroupIter, Error>** - An iterator over the file entries.

### Example
```rust
use ages_ice_archive::{IceGroupIter, IceArchive, Group};

let g1_iter = IceGroupIter::new(&g1_data[..], ice_archive.group_count(Group::Group1)).unwrap();
```
```

--------------------------------

### write_i64

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceFileWriter.html

Writes a signed 64-bit integer to the underlying writer. Returns a Result indicating success or an I/O error.

```APIDOC
## write_i64

### Description
Writes a signed 64-bit integer to the underlying writer.

### Method
write_i64

### Signature
fn write_i64<T>(&mut self, n: i64) -> Result<(), Error> where T: ByteOrder

### Parameters
- **n** (i64) - Required - The signed 64-bit integer to write.

### Return Value
- **Result<(), Error>** - Ok(()) on success, or an I/O error.
```

--------------------------------

### write_i32

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceFileWriter.html

Writes a signed 32-bit integer to the underlying writer.

```APIDOC
## write_i32

### Description
Writes a signed 32-bit integer to the underlying writer.

### Method
write_i32

### Signature
fn write_i32<T>(&mut self, n: i32) -> Result<(), Error>
where T: ByteOrder

### Parameters
- **n** (i32) - Required - The signed 32-bit integer to write.

### Return Value
Result<(), Error> - Ok(()) on success, or an I/O error.
```

--------------------------------

### enumerate

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceGroupIter.html

Creates an iterator that yields the current iteration count along with each item.

```APIDOC
## fn enumerate(self) -> Enumerate<Self>

### Description
Creates an iterator which gives the current iteration count as well as the next value.

### Method
fn

### Signature
fn enumerate(self) -> Enumerate<Self>

### Parameters
- **self** - The iterator to enumerate.

### Returns
- **Enumerate<Self>** - An iterator that yields (index, item) pairs.

### Constraints
- Self: Sized

### Notes
- Available since Rust 1.0.0.
- Const version is unstable.
```

--------------------------------

### IceGroupIter::new

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceGroupIter.html

Creates a new IceGroupIter instance from a byte slice and a count. Returns a Result that yields the iterator or a GroupIterError on failure.

```APIDOC
## IceGroupIter::new

### Description
Creates a new IceGroupIter instance from a byte slice and a count. Returns a Result that yields the iterator or a GroupIterError on failure.

### Method
`pub fn new(data: &'a [u8], count: u32) -> Result<IceGroupIter<'a>, GroupIterError>`

### Parameters
- **data** (`&'a [u8]`) - Required - The byte slice containing the ice group data.
- **count** (`u32`) - Required - The number of ice groups to iterate over.

### Returns
- **Result<IceGroupIter<'a>, GroupIterError>** - On success, returns an `IceGroupIter` instance; on failure, returns a `GroupIterError`.

### Example
```rust
let data: &[u8] = ...;
let count: u32 = ...;
let iter = IceGroupIter::new(data, count)?;
```
```

--------------------------------

### fn product<P>(self) -> P

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceGroupIter.html

Iterates over the entire iterator, multiplying all the elements. This method is part of the Iterator trait implementation for IceGroupIter.

```APIDOC
## fn product<P>(self) -> P

### Description
Iterates over the entire iterator, multiplying all the elements.

### Method
product

### Signature
fn product<P>(self) -> P
where Self: Sized, P: Product<Self::Item>

### Parameters
- **self** - The iterator to multiply.

### Returns
- **P** - The product of all elements.

### Example
```rust
let product: i32 = vec![1, 2, 3].into_iter().product();
```
```

--------------------------------

### fn nth(&mut self, n: usize) -> Option<Self::Item>

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceGroupIter.html

Returns the nth element of the iterator.

```APIDOC
## fn nth(&mut self, n: usize) -> Option<Self::Item>

### Description
Returns the `n`th element of the iterator.

### Method
nth

### Signature
fn nth(&mut self, n: usize) -> Option<Self::Item>

### Parameters
- **n** (usize) - The index of the element to return (0-based).

### Returns
- **Option<Self::Item>** - The nth element, or None if n is out of bounds.

### Notes
- Available since Rust 1.28.0.
```

--------------------------------

### IceArchive::version

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceArchive.html

Returns the version of the ICE archive.

```APIDOC
## version(&self) -> u32

### Description
The version of this ICE archive.

### Returns
- `u32` - The version number.
```

--------------------------------

### fold

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceGroupIter.html

Folds every element into an accumulator by applying an operation, returning the final result.

```APIDOC
## fold

### Description
Folds every element into an accumulator by applying an operation, returning the final result.

### Method
`fn fold<B, F>(self, init: B, f: F) -> B`

### Parameters
- **init** (B) - The initial accumulator value.
- **f** (F) - A closure that takes the accumulator and an item, returning a new accumulator.

### Returns
- **B** - The final accumulator value.

### Constraints
- `Self: Sized`
- `F: FnMut(B, Self::Item) -> B`
```

--------------------------------

### write_i24

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceFileWriter.html

Writes a signed 24-bit integer to the underlying writer.

```APIDOC
## write_i24

### Description
Writes a signed 24-bit integer to the underlying writer.

### Method
write_i24

### Signature
fn write_i24<T>(&mut self, n: i32) -> Result<(), Error>
where T: ByteOrder

### Parameters
- **n** (i32) - Required - The signed 24-bit integer to write.

### Return Value
Result<(), Error> - Ok(()) on success, or an I/O error.
```

--------------------------------

### impl PartialEq for Group

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/enum.Group.html

Provides equality and inequality comparison methods for the Group enum.

```APIDOC
## impl PartialEq for Group

### Description
Provides equality and inequality comparison methods for the Group enum.

### Methods

#### fn eq(&self, other: &Self) -> bool

Equality operator `==`.

#### fn ne(&self, other: &Rhs) -> bool

Inequality operator `!=`.

### Parameters
- `other` (&Self or &Rhs) - The value to compare against.

### Returns
- `bool` - `true` if the comparison holds, `false` otherwise.
```

--------------------------------

### take

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceGroupIter.html

Creates an iterator that yields the first n elements, or fewer if the underlying iterator ends sooner. This method is part of the Iterator trait and is available on IceGroupIter.

```APIDOC
## take

### Description
Creates an iterator that yields the first `n` elements, or fewer if the underlying iterator ends sooner.

### Method
take

### Signature
fn take(self, n: usize) -> Take<Self>
where Self: Sized

### Parameters
- **n** (usize) - Required - The number of elements to take.

### Returns
- **Take<Self>** - An iterator adapter that yields the first n elements.

### Notes
- Available since Rust 1.0.0 (const: unstable).
```

--------------------------------

### write_i16

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceFileWriter.html

Writes a signed 16-bit integer to the underlying writer.

```APIDOC
## write_i16

### Description
Writes a signed 16-bit integer to the underlying writer.

### Method
write_i16

### Signature
fn write_i16<T: ByteOrder>(&mut self, n: i16) -> Result<(), Error>

### Parameters
- **n** (i16) - Required - The signed 16-bit integer to write.
- **T** (ByteOrder) - Required - The byte order to use.

### Return Value
- **Result<(), Error>** - Ok(()) on success, or an I/O error.

```

--------------------------------

### fn try_reduce<R>(&mut self, f: impl FnMut(Self::Item, Self::Item) -> R) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceGroupIter.html

Reduces the elements to a single one by repeatedly applying a reducing operation. If the closure returns a failure, the failure is propagated back to the caller immediately. This is a nightly-only experimental API.

```APIDOC
## fn try_reduce<R>(&mut self, f: impl FnMut(Self::Item, Self::Item) -> R) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType

### Description
Reduces the elements to a single one by repeatedly applying a reducing operation. If the closure returns a failure, the failure is propagated back to the caller immediately.

### Signature
```rust
fn try_reduce<R>(
    &mut self,
    f: impl FnMut(Self::Item, Self::Item) -> R,
) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
where
    Self: Sized,
    R: Try<Output = Self::Item>,
    <R as Try>::Residual: Residual<Option<Self::Item>>,
```

### Parameters
- **f** (impl FnMut(Self::Item, Self::Item) -> R) - Required - A closure that takes two items and returns a value that implements Try.

### Return Value
- **<<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType** - The reduced value or a failure.

### Note
This is a nightly-only experimental API. (`iterator_try_reduce`)

### Example
```rust
let result = iter.try_reduce(|a, b| if a + b > 100 { Err("overflow") } else { Ok(a + b) });
```
```

--------------------------------

### copied

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceGroupIter.html

Creates an iterator which copies all of its elements.

```APIDOC
## copied

### Description
Creates an iterator which copies all of its elements.

### Signature
```rust
fn copied<'a, T>(self) -> Copied<Self>
where
    T: Copy + 'a,
    Self: Sized + Iterator<Item = &'a T>,
```

### Return Value
- **Copied<Self>** - An iterator that yields copies of the original elements.

### Notes
- Available since Rust 1.0.0.
- Const evaluation is unstable.
```

--------------------------------

### write_u64

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceFileWriter.html

Writes an unsigned 64-bit integer to the underlying writer. Returns a Result indicating success or an I/O error.

```APIDOC
## write_u64

### Description
Writes an unsigned 64-bit integer to the underlying writer.

### Method
write_u64

### Signature
fn write_u64<T>(&mut self, n: u64) -> Result<(), Error> where T: ByteOrder

### Parameters
- **n** (u64) - Required - The unsigned 64-bit integer to write.

### Return Value
- **Result<(), Error>** - Ok(()) on success, or an I/O error.
```

--------------------------------

### map

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceGroupIter.html

Takes a closure and creates an iterator which calls that closure on each element.

```APIDOC
## map

### Description
Takes a closure and creates an iterator which calls that closure on each element.

### Method
map

### Signature
```rust
fn map<B, F>(self, f: F) -> Map<Self, F>
where
    Self: Sized,
    F: FnMut(Self::Item) -> B,
```

### Parameters
- **f** (F) - Required - The closure to call on each element.

### Return Value
Returns a `Map` iterator adapter.

### Notes
- Available since Rust 1.21.0.
- Const evaluation is unstable.
```

--------------------------------

### fn last(self) -> Option<Self::Item>

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceGroupIter.html

Consumes the iterator, returning the last element.

```APIDOC
## fn last(self) -> Option<Self::Item>

### Description
Consumes the iterator, returning the last element.

### Method
last

### Signature
fn last(self) -> Option<Self::Item>
where Self: Sized

### Parameters
- **self** - The iterator to consume.

### Returns
- **Option<Self::Item>** - The last element, or None if the iterator is empty.

### Notes
- Available since Rust 1.0.0.
```

--------------------------------

### partial_cmp_by

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceGroupIter.html

Lexicographically compares the elements of this Iterator with those of another with respect to the specified comparison function. This is a nightly-only experimental API.

```APIDOC
## partial_cmp_by

### Description
Lexicographically compares the elements of this Iterator with those of another with respect to the specified comparison function. This is a nightly-only experimental API.

### Signature
```rust
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
where
    Self: Sized,
    I: IntoIterator,
    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
```

### Parameters
- **other** (I) - The iterator to compare against.
- **partial_cmp** (F) - A comparison function that returns an Option<Ordering>.

### Return Value
- **Option<Ordering>** - The result of the lexicographic comparison.

### Availability
- Nightly-only experimental API (`iter_order_by`)
- Version 1.5.0 (const: unstable)
```

--------------------------------

### write_i8

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceFileWriter.html

Writes a signed 8-bit integer to the underlying writer.

```APIDOC
## write_i8

### Description
Writes a signed 8-bit integer to the underlying writer.

### Method
write_i8

### Signature
fn write_i8(&mut self, n: i8) -> Result<(), Error>

### Parameters
- **n** (i8) - Required - The signed 8-bit integer to write.

### Return Value
- **Result<(), Error>** - Ok(()) on success, or an I/O error.

```

--------------------------------

### fn count(self) -> usize

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceGroupIter.html

Consumes the iterator, counting the number of iterations and returning it.

```APIDOC
## fn count(self) -> usize

### Description
Consumes the iterator, counting the number of iterations and returning it.

### Method
count

### Signature
fn count(self) -> usize
where Self: Sized

### Parameters
- **self** - The iterator to consume.

### Returns
- **usize** - The number of iterations.

### Notes
- Available since Rust 1.0.0.
- Const unstable (tracking issue #92476).
```

--------------------------------

### write_i48

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceFileWriter.html

Writes a signed 48-bit integer to the underlying writer. Returns a Result indicating success or an I/O error.

```APIDOC
## write_i48

### Description
Writes a signed 48-bit integer to the underlying writer.

### Method
write_i48

### Signature
fn write_i48<T>(&mut self, n: i64) -> Result<(), Error> where T: ByteOrder

### Parameters
- **n** (i64) - Required - The signed 48-bit integer to write.

### Return Value
- **Result<(), Error>** - Ok(()) on success, or an I/O error.
```

--------------------------------

### Iterator::partition

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceGroupIter.html

Consumes an iterator, creating two collections from it based on a predicate.

```APIDOC
## partition

### Description
Consumes an iterator, creating two collections from it.

### Method
partition

### Signature
fn partition<B, F>(self, f: F) -> (B, B)
where Self: Sized, B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool

### Parameters
- **f** (F) - Required - A predicate function that determines which collection each item goes into.

### Returns
- **(B, B)** - A tuple of two collections: the first contains items for which the predicate returned true, the second contains the rest.
```

--------------------------------

### cloned

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceGroupIter.html

Creates an iterator which clones all of its elements.

```APIDOC
## cloned

### Description
Creates an iterator which clones all of its elements.

### Signature
```rust
fn cloned<'a, T>(self) -> Cloned<Self>
where
    T: Clone + 'a,
    Self: Sized + Iterator<Item = &'a T>,
```

### Return Value
- **Cloned<Self>** - An iterator that yields clones of the original elements.

### Notes
- Available since Rust 1.0.0.
- Const evaluation is unstable.
```

--------------------------------

### write_u32

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceFileWriter.html

Writes an unsigned 32-bit integer to the underlying writer.

```APIDOC
## write_u32

### Description
Writes an unsigned 32-bit integer to the underlying writer.

### Method
write_u32

### Signature
fn write_u32<T>(&mut self, n: u32) -> Result<(), Error>
where T: ByteOrder

### Parameters
- **n** (u32) - Required - The unsigned 32-bit integer to write.

### Return Value
Result<(), Error> - Ok(()) on success, or an I/O error.
```

--------------------------------

### scan

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceGroupIter.html

An iterator adapter that holds internal state and produces a new iterator, similar to fold but yielding an iterator.

```APIDOC
## scan

### Description
An iterator adapter which, like fold, holds internal state, but unlike fold, produces a new iterator.

### Method
scan

### Signature
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
where Self: Sized, F: FnMut(&mut St, Self::Item) -> Option<B>

### Parameters
- **initial_state** (St) - Required - The initial state for the scan.
- **f** (F) - Required - A closure that takes a mutable reference to the state and an item, returning an Option<B>.

### Returns
- **Scan<Self, St, F>** - An iterator adapter that yields the results of the closure.

### Notes
- Available since Rust 1.0.0.
- Const evaluation is unstable.
```

--------------------------------

### unzip

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceGroupIter.html

Converts an iterator of pairs into a pair of containers.

```APIDOC
## unzip

### Description
Converts an iterator of pairs into a pair of containers.

### Signature
```rust
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
where
    FromA: Default + Extend<A>,
    FromB: Default + Extend<B>,
    Self: Sized + Iterator<Item = (A, B)>,
```

### Return Value
- **(FromA, FromB)** - A pair of containers containing the first and second elements of each pair.

### Notes
- Available since Rust 1.36.0.
- Const evaluation is unstable.
```

--------------------------------

### fn find_map<B, F>(&mut self, f: F) -> Option<B>

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceGroupIter.html

Applies a function to the elements of the iterator and returns the first non-none result. This method consumes the iterator and returns the first Some value produced by the function, or None if all results are None.

```APIDOC
## fn find_map<B, F>(&mut self, f: F) -> Option<B>

### Description
Applies function to the elements of iterator and returns the first non-none result.

### Method
find_map

### Signature
fn find_map<B, F>(&mut self, f: F) -> Option<B>
where Self: Sized, F: FnMut(Self::Item) -> Option<B>

### Parameters
- **f** (F) - Required - A function that takes an item and returns an Option<B>.

### Returns
- **Option<B>** - Returns the first non-None result, or None if all results are None.

### Notes
- This method is available since Rust 1.30.0.
```

--------------------------------

### cmp_by

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceGroupIter.html

Lexicographically compares the elements of this Iterator with those of another using a specified comparison function. This is a nightly-only experimental API.

```APIDOC
## cmp_by

### Description
Lexicographically compares the elements of this Iterator with those of another with respect to the specified comparison function.

### Method
cmp_by

### Signature
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering

### Parameters
- **other** (I) - Required - The iterator to compare against.
- **cmp** (F) - Required - The comparison function that takes two items and returns an Ordering.

### Return Value
- **Ordering** - The result of the lexicographic comparison.

### Notes
- This is a nightly-only experimental API (`iter_order_by`).
- Available since 1.5.0 (const: unstable).
```

--------------------------------

### fn by_ref(&mut self) -> &mut Self

Source: https://docs.rs/ages-ice-archive/latest/ages_ice_archive/struct.IceGroupIter.html

Creates a “by reference” adapter for this instance of Iterator. This method is part of the Iterator trait implementation for IceGroupIter.

```APIDOC
## fn by_ref(&mut self) -> &mut Self

### Description
Creates a “by reference” adapter for this instance of `Iterator`.

### Method
`by_ref`

### Signature
```rust
fn by_ref(&mut self) -> &mut Self
where
    Self: Sized,
```

### Parameters
- `self` - A mutable reference to the iterator.

### Returns
- `&mut Self` - A mutable reference to the iterator, allowing chaining of iterator methods.

### Notes
- Available since Rust 1.0.0.
- Const evaluation is currently unstable.
```
Tokens:
Raw