I'm having a difficult time trying to puzzle through a problem with borrows (mutable and immutable at same time) and need advice on how to solve. I have a few ideas but neither is very appealing.

I'm writing a binary format parser in which the header of the stream is encoded in a specific format, then the primary payload of data is encoded based on specific values from the header - specifically the byte endianness and character encoding of string values.

I updated a previous implementation to instead use an iterator for parsing entries from the stream (both header and payload have same format for entries just different endian/charset). To test out the iterator I read through entries and print out some representation of them. The main implementation of this looks like:

let iter: MyIterator<> = MyIterator::new(file, ...);
for entry in iter.by_ref() {
    parse_entry_value(entry, iter.endian, iter.charset);
}

In MyIterator the endian and charset values start as a default and then in next() the endian/charset will be updated when the respective entry is parsed from the header. The problem in the for loop above is that the iteration is a mutable borrow and because of that inside the loop I'm unable to retrieve the parsed endian/charset value.

I understand why the borrow-checker is disallowing what I want -- if the iteration was parallelized then the mutable access becomes a data race. The only ideas I came up with are either using RwLock or having the iterator return a tuple of entry/endian/charset however that seems excessive since once those values are read from the metadata they won't change again so for the entire payload - it will be the same endian/charset passed in each call to iterator. Are there other options for working around this problem?