Generic wrappers

[vikigenius]

Should I always wrap my FDs in a generic wrapper even if I implement EventSource and just have a single source?

pub struct IPCSource {
    socket_source: calloop::generic::Generic<calloop::generic::FdWrapper<UnixListener>>,
}

impl calloop::EventSource for IPCSource {
...
}

vs

pub struct IPCSource {
    socket: UnixListener,
}

impl calloop::EventSource for IPCSource {
...
}

And if I do wrap it in a Generic:

How should I process events

    fn process_events<F>(
        &mut self,
        readiness: calloop::Readiness,
        token: calloop::Token,
        callback: F,
    ) -> Result<calloop::PostAction, Self::Error>
    where
        F: FnMut(Self::Event, &mut Self::Metadata) -> Self::Ret,
    {
        self.socket_source
            .process_events(readiness, token, |evt, _| {
                if readiness.readable {
                    // TODO
                }
            });
        Ok(calloop::PostAction::Continue)
    }

vs

    fn process_events<F>(
        &mut self,
        readiness: calloop::Readiness,
        token: calloop::Token,
        callback: F,
    ) -> Result<calloop::PostAction, Self::Error>
    where
        F: FnMut(Self::Event, &mut Self::Metadata) -> Self::Ret,
    {
        
        if readiness.readable {
                    // TODO
        }
        Ok(calloop::PostAction::Continue)
    }

[notgull]

Generic is the best way to wrap a file descriptor, as it takes care of much of the internal busywork of registering file descriptors. So the first pattern is the best one to use here.

[vikigenius]

@notgull Thanks for the response. If I do the first pattern. How should I process events.

If I use this

    fn process_events<F>(
        &mut self,
        readiness: calloop::Readiness,
        token: calloop::Token,
        callback: F,
    ) -> Result<calloop::PostAction, Self::Error>
    where
        F: FnMut(Self::Event, &mut Self::Metadata) -> Self::Ret,
    {
        self.socket_source
            .process_events(readiness, token, |evt, _| {
                if readiness.readable {
                    // TODO
                    self.handle_ipc_event(); // Causes compile error
                }
                Ok(calloop::PostAction::Continue)
            });
        Ok(calloop::PostAction::Continue)
    }

I get an error because I can't borrow self as mutable ?