fix some warnings (unneeded parentheses, missing dyn keyword)

4 files changed, 16 insertions, 16 deletions

diff --git a/nihav-core/src/demuxers/mod.rs b/nihav-core/src/demuxers/mod.rs
index 352c160..b54e563 100644
--- a/nihav-core/src/demuxers/mod.rs
+++ b/nihav-core/src/demuxers/mod.rs
@@ -88,7 +88,7 @@ impl StreamManager {
     /// Adds a new stream.
     pub fn add_stream(&mut self, stream: NAStream) -> Option<usize> {
         let stream_num = self.streams.len();
-        let mut str = stream.clone();
+        let mut str = stream;
         str.set_num(stream_num);
         self.streams.push(str.into_ref());
         self.ignored.push(false);
@@ -442,7 +442,7 @@ pub trait DemuxerCreator {
 }
 
 /// Creates demuxer for a provided bytestream.
-pub fn create_demuxer<'a>(dmxcr: &DemuxerCreator, br: &'a mut ByteReader<'a>) -> DemuxerResult<Demuxer<'a>> {
+pub fn create_demuxer<'a>(dmxcr: &dyn DemuxerCreator, br: &'a mut ByteReader<'a>) -> DemuxerResult<Demuxer<'a>> {
     let mut dmx = dmxcr.new_demuxer(br);
     let mut str = StreamManager::new();
     let mut seek_idx = SeekIndex::new();
@@ -453,7 +453,7 @@ pub fn create_demuxer<'a>(dmxcr: &DemuxerCreator, br: &'a mut ByteReader<'a>) ->
 /// List of registered demuxers.
 #[derive(Default)]
 pub struct RegisteredDemuxers {
-    dmxs:   Vec<&'static DemuxerCreator>,
+    dmxs:   Vec<&'static dyn DemuxerCreator>,
 }
 
 impl RegisteredDemuxers {
@@ -462,11 +462,11 @@ impl RegisteredDemuxers {
         Self { dmxs: Vec::new() }
     }
     /// Registers a new demuxer.
-    pub fn add_demuxer(&mut self, dmx: &'static DemuxerCreator) {
+    pub fn add_demuxer(&mut self, dmx: &'static dyn DemuxerCreator) {
         self.dmxs.push(dmx);
     }
     /// Searches for a demuxer that supports requested container format.
-    pub fn find_demuxer(&self, name: &str) -> Option<&DemuxerCreator> {
+    pub fn find_demuxer(&self, name: &str) -> Option<&dyn DemuxerCreator> {
         for &dmx in self.dmxs.iter() {
             if dmx.get_name() == name {
                 return Some(dmx);
@@ -475,7 +475,7 @@ impl RegisteredDemuxers {
         None
     }
     /// Provides an iterator over currently registered demuxers.
-    pub fn iter(&self) -> std::slice::Iter<&DemuxerCreator> {
+    pub fn iter(&self) -> std::slice::Iter<&dyn DemuxerCreator> {
         self.dmxs.iter()
     }
 }
diff --git a/nihav-core/src/io/byteio.rs b/nihav-core/src/io/byteio.rs
index 3677501..adbb636 100644
--- a/nihav-core/src/io/byteio.rs
+++ b/nihav-core/src/io/byteio.rs
@@ -75,7 +75,7 @@ pub trait ByteIO {
 /// [`MemoryReader`]: ./struct.MemoryReader.html
 #[allow(dead_code)]
 pub struct ByteReader<'a> {
-    io: &'a mut ByteIO,
+    io: &'a mut dyn ByteIO,
 }
 
 /// Bytestream reader from memory.
@@ -241,7 +241,7 @@ impl<'a> ByteReader<'a> {
     /// # Ok(())
     /// # }
     /// ````
-    pub fn new(io: &'a mut ByteIO) -> Self { ByteReader { io } }
+    pub fn new(io: &'a mut dyn ByteIO) -> Self { ByteReader { io } }
 
     /// Reads data into provided buffer. Partial read is treated as success.
     pub fn read_buf(&mut self, buf: &mut [u8])  -> ByteIOResult<usize> {
@@ -639,7 +639,7 @@ impl<T: Read+Seek> ByteIO for FileReader<T> {
 /// [`MemoryWriter`]: ./struct.MemoryWriter.html
 #[allow(dead_code)]
 pub struct ByteWriter<'a> {
-    io: &'a mut ByteIO,
+    io: &'a mut dyn ByteIO,
 }
 
 /// Bytestream writer to memory.
@@ -665,7 +665,7 @@ pub struct GrowableMemoryWriter<'a> {
 
 impl<'a> ByteWriter<'a> {
     /// Constructs a new instance of `ByteWriter`.
-    pub fn new(io: &'a mut ByteIO) -> Self { ByteWriter { io } }
+    pub fn new(io: &'a mut dyn ByteIO) -> Self { ByteWriter { io } }
 
     /// Writes byte array to the output.
     pub fn write_buf(&mut self, buf: &[u8])  -> ByteIOResult<()> {
diff --git a/nihav-core/src/io/codebook.rs b/nihav-core/src/io/codebook.rs
index 384a743..0ec8883 100644
--- a/nihav-core/src/io/codebook.rs
+++ b/nihav-core/src/io/codebook.rs
@@ -289,7 +289,7 @@ fn build_esc_lut(table: &mut Vec<u32>,
 impl<S: Copy> Codebook<S> {
 
     /// Constructs a new `Codebook` instance using provided codebook description and mode.
-    pub fn new(cb: &mut CodebookDescReader<S>, mode: CodebookMode) -> CodebookResult<Self> {
+    pub fn new(cb: &mut dyn CodebookDescReader<S>, mode: CodebookMode) -> CodebookResult<Self> {
         let mut maxbits = 0;
         let mut nnz = 0;
         let mut escape_list: EscapeCodes = HashMap::new();
diff --git a/nihav-core/src/muxers/mod.rs b/nihav-core/src/muxers/mod.rs
index 69ab917..40a6eb3 100644
--- a/nihav-core/src/muxers/mod.rs
+++ b/nihav-core/src/muxers/mod.rs
@@ -134,7 +134,7 @@ pub trait MuxerCreator {
 }
 
 /// Creates muxer for a provided bytestream writer.
-pub fn create_muxer<'a>(mxcr: &MuxerCreator, str: StreamManager, bw: &'a mut ByteWriter<'a>) -> MuxerResult<Muxer<'a>> {
+pub fn create_muxer<'a>(mxcr: &dyn MuxerCreator, str: StreamManager, bw: &'a mut ByteWriter<'a>) -> MuxerResult<Muxer<'a>> {
     let mut mux = mxcr.new_muxer(bw);
     mux.create(&str)?;
     Ok(Muxer::new(mux, str))
@@ -143,7 +143,7 @@ pub fn create_muxer<'a>(mxcr: &MuxerCreator, str: StreamManager, bw: &'a mut Byt
 /// List of registered muxers.
 #[derive(Default)]
 pub struct RegisteredMuxers {
-    muxes:  Vec<&'static MuxerCreator>,
+    muxes:  Vec<&'static dyn MuxerCreator>,
 }
 
 impl RegisteredMuxers {
@@ -152,11 +152,11 @@ impl RegisteredMuxers {
         Self { muxes: Vec::new() }
     }
     /// Registers a new muxer.
-    pub fn add_muxer(&mut self, mux: &'static MuxerCreator) {
+    pub fn add_muxer(&mut self, mux: &'static dyn MuxerCreator) {
         self.muxes.push(mux);
     }
     /// Searches for a muxer that supports requested container format.
-    pub fn find_muxer(&self, name: &str) -> Option<&MuxerCreator> {
+    pub fn find_muxer(&self, name: &str) -> Option<&dyn MuxerCreator> {
         for &mux in self.muxes.iter() {
             if mux.get_name() == name {
                 return Some(mux);
@@ -165,7 +165,7 @@ impl RegisteredMuxers {
         None
     }
     /// Provides an iterator over currently registered muxers.
-    pub fn iter(&self) -> std::slice::Iter<&MuxerCreator> {
+    pub fn iter(&self) -> std::slice::Iter<&dyn MuxerCreator> {
         self.muxes.iter()
     }
 }