Is any way to convert large mutable array into shared R/O?

1

I need to read some data from network and then parse it into movable/returnable key-value map. I don't want to reallocate all keys and values for map, because i already have them in the container (Vec, String or something else).

I could take a map, where both keys and values are just slices of container. It works, but such map is not movable/returnable. It is even impossible to move/return this map along with container, for example as parts of object

struct ParsedData<'a> {
    container: String,
    variables: HashMap<&'a str, &'a str>, // all &str are slices of container
}

because this object becames self-borrowing as soon as slices stored in the map.

I thought i could make some "shared slices" type, for example

struct SharedStr {
    origin: Rc<str>,
    range: Range,
}

impl Borrow<str> for SharedStr {
    fn borrow(&self) -> &str {
        &self.origin[self.range.start..self.range.end]
    }
}

having implemented Borrow trait to allow use this type as keys of map. But this way i have other issue - i can't turn mutable container(Vec or String) into Rc without redundant copying.

Such type

struct SharedString {
    origin: Rc<String>,
    range: Range,
}

could eliminate redundant copying, but this way i have double-dereferencing, which slowing down working with map with keys and values of such type.

Are there any other ways?

2

ByteString would be the closest thing out there.

3

Hyeonu, Thanx! Looks like this is what i need (along with Bytes).

4

This topic was automatically closed 90 days after the last reply. We invite you to open a new topic if you have further questions or comments.