Cannot move out of an `Arc`

#1

Hi all I am getting "cannot move out of an Arc in here:

error[E0507]: cannot move out of an `Arc`
  --> src/fetch/fetch_job.rs:94:18
   |
94 |             .zip(lock.clone().uri_iter)
   |                  ^^^^^^^^^^^^^^^^^^^^^ cannot move out of an `Arc`
        let mut lock = Arc::new(self.clone());
        let requests: Vec<_> = (0..self.chunk)
            .zip(lock.clone().uri_iter)

not sure how to fix this.

1 Like

#2

You can use *lock to dereference the Arc and get at the value inside it. Then you can clone that value, instead of cloning the Arc:

.zip((*lock).clone().uri_iter)

Though it might make more sense in this case to clone only the one field you need, instead of the whole struct:

.zip(lock.uri_iter.clone())
1 Like

#3
error[E0507]: cannot move out of borrowed content
  --> src/fetch/fetch_job.rs:94:18
   |
94 |             .zip((*lock).clone().uri_iter)
   |                  ^^^^^^^^^^^^^^^^^^^^^^^^ cannot move out of borrowed content
        let mut lock = Arc::new(self.clone());
        let requests: Vec<_> = (0..self.chunk)
            .zip((*lock).clone().uri_iter)
            .map(move |(_, uri)| {
0 Likes

#4

What is the type of self? Is it a reference? (Does this function take an &self argument?) Does the Self type implement Clone?

0 Likes

#5
impl<'a, S, I> WeatherStream<'a, S, I>
where
    S: StoreWeather ,
    I: Iterator<Item = Uri> + Send,
{
    fn new(uri_iter: I, chunk: u64, duration: Duration, storage_client: S) -> Self {
        Self {
            uri_iter,
            chunk,
            interval: Interval::new_interval(duration),
            fetch_future: None,
            storage_client: Arc::new(Mutex::new(Box::new(storage_client))),
            time_pass: TimePass::Ready,
        }
    }

    //change number of requests to a parameter.
    pub fn fetch_chunk(&self) -> impl Future<Item = bool, Error = ()> {
        let client = build_https_client().unwrap(); //TODO catch error
        let chunk = Arc::new(self.chunk);
        let mut lock = Arc::new(self.clone());
        let requests: Vec<_> = (0..self.chunk)
            .zip(lock.uri_iter.clone())
            .map(move |(_, uri)| {
                client
                    .clone()
                    .get(uri)
                    .map(|res| {
                        println!("Response: {}", res.status());
                        println!("Headers: {:#?}", res.headers());
                    })
                    .map_err(|_| ())
            })
            .collect();
        future::join_all(requests)
            .map(move |res: Vec<()>| res.len() as u64 == *chunk)
            .map_err(|_| ())
    }
}
0 Likes

#6

No self does not implement clone, that is why I am using Arc

0 Likes

#7

Then you should probably clone the member variable (uri_iter) instead of trying to clone the unclonable inner lock.

            .zip(lock.uri_iter.clone())
0 Likes

#8
error[E0599]: no method named `clone` found for type `I` in the current scope
  --> src/fetch/fetch_job.rs:94:32
   |
94 |             .zip(lock.uri_iter.clone())
   |                                ^^^^^
   |
   = help: items from traits can only be used if the trait is implemented and in scope
   = note: the following trait defines an item `clone`, perhaps you need to implement it:
           candidate #1: `std::clone::Clone`
   = help: did you mean `cloned`?

but I did implement it:

#[derive(Clone,Copy)]
pub struct DarkSky {
    pub base: &'static str,
    pub coordinates: &'static str,
    pub start: DateTime<Local>,
    pub end: DateTime<Local>,
    pub current: DateTime<Local>,
}


impl DarkSky {
    pub fn new(
        base: &'static str,
        coordinates: &'static str,
        start: DateTime<Local>,
        end: DateTime<Local>,
    ) -> Self {
        Self {
            base,
            coordinates,
            start,
            end,
            current: start,
        }
    }
}

impl Iterator for DarkSky {
    type Item = hyper::Uri;

    fn next(&mut self) -> Option<Self::Item> {
        let date = self.current - chrono::Duration::days(1);
        if date > self.end {
            None
        } else {
            self.current = date.clone();
            Some(
                format!("{}/{} {}", self.base, self.coordinates, date.timestamp())
                    .parse::<hyper::Uri>()
                    .unwrap(),
            )
        }
    }
}
0 Likes

#9

self here has type &WeatherStream. When you write self.clone(), since it can’t clone the WeatherStream, it clones the &WeatherStream, returning an identical &WeatherStream value. You then put this in an Arc, creating an Arc<&WeatherStream>. The Arc doesn’t add anything here. (I’m also not clear why chunk is an Arc.)

If you want to be able to create multiple copies of the uri_iter field, you will at least need to require a Clone bound on its type I. Or perhaps you can instead take &mut self and return a future that captures a mutable reference to self.uri_iter so you do not need to clone it.

Or your function could take self: Arc<Self> if you want it to be able to return a future with shared ownership of the whole WeatherStream. In this case you’ll need to add some more Mutex or RwLock for fields like the iterator that need to be mutable.

2 Likes

#10

Ok makes sense I will try some things around and will let you know of the progress

0 Likes

#11

Okay so here is what I did:

    //change number of requests to a parameter.
    pub fn fetch_chunk(self: Arc<Self>) -> impl Future<Item = bool, Error = ()> + 'a {
        let client = build_https_client().unwrap(); //TODO catch error
        let iter = self.clone().uri_iter.lock().unwrap();
        let requests: Vec<_> = (0..self.chunk)
            .zip(*iter)
            .map(move |(_, uri)| {
                client
                    .clone()
                    .get(uri)
                    .map(|res| {
                        println!("Response: {}", res.status());
                        println!("Headers: {:#?}", res.headers());
                    })
                    .map_err(|_| ())
            })
            .collect();
        future::join_all(requests)
            .map(move |res: Vec<()>| res.len() as u64 == self.clone().chunk)
            .map_err(|_| ())
    }
}

impl<'a, S, I> Stream for WeatherStream<'a, S, I>
where
    S: StoreWeather + 'a,
    I: Iterator<Item = Uri> + Send + 'a,
{
    type Item = bool;
    type Error = ();

    fn poll(&mut self) -> Poll<Option<Self::Item>, ()> {
        loop {
            match self.time_pass {
                TimePass::Ready => {
                    if let Some(_) = self.fetch_future {
                        try_ready!(self.fetch_future.poll().map_err(|_| ()));
                    } else {
                        self.fetch_future: Option<Box<Future<Item=bool, Error=()> + 'a + Send>> = Some(Box::new(self.fetch_chunk()));
                        try_ready!(self.fetch_future.poll().map_err(|_| ()));
                    }
                    self.time_pass = TimePass::Waiting;
                    self.fetch_future = None;
                }
                TimePass::Waiting => {
                    match self.interval.poll() {
                        Ok(Async::Ready(value)) => {
                            self.time_pass = TimePass::Ready;
                            return Ok(Async::Ready(Some(false)));
                        }
                        Ok(Async::NotReady) => return Ok(Async::NotReady),
                        Err(err) => return Err(()),
                    }
                }
            };
        }
    }
}

and I get this:

error[E0599]: no method named `fetch_chunk` found for type `std::sync::Arc<&mut fetch::fetch_job::WeatherStream<'a, S, I>>` in the current scope
   --> src/fetch/fetch_job.rs:126:128
    |
126 |                         self.fetch_future: Option<Box<Future<Item=bool, Error=()> + 'a + Send>> = Some(Box::new(Arc::new(self).fetch_chunk()));
    |                                                                                                                                ^^^^^^^^^^^

error: aborting due to previous error
0 Likes