Use None instead of u64::MAX for unknown/unspecified size/stop

src/rsfilesrc.rs

@@ -62,13 +62,13 @@ impl Source for FileSrc {
         true
     }
 
-    fn get_size(&self) -> u64 {
+    fn get_size(&self) -> Option<u64> {
         if let StreamingState::Started { ref file, .. } = self.streaming_state {
             file.metadata()
                 .ok()
-                .map_or(u64::MAX, |m| m.len())
+                .map(|m| m.len())
         } else {
-            u64::MAX
+            None
         }
     }
 
@@ -132,7 +132,7 @@ impl Source for FileSrc {
         Ok(size)
     }
 
-    fn seek(&mut self, _: u64, _: u64) -> Result<(), ErrorMessage> {
+    fn seek(&mut self, _: u64, _: Option<u64>) -> Result<(), ErrorMessage> {
         Ok(())
     }
 }

src/rshttpsrc.rs

@@ -34,9 +34,9 @@ enum StreamingState {
         response: Response,
         seekable: bool,
         position: u64,
-        size: u64,
+        size: Option<u64>,
         start: u64,
-        stop: u64,
+        stop: Option<u64>,
     },
 }
 
@@ -58,14 +58,19 @@ impl HttpSrc {
         Box::new(HttpSrc::new())
     }
 
-    fn do_request(&self, uri: Url, start: u64, stop: u64) -> Result<StreamingState, ErrorMessage> {
+    fn do_request(&self,
+                  uri: Url,
+                  start: u64,
+                  stop: Option<u64>)
+                  -> Result<StreamingState, ErrorMessage> {
         let mut req = self.client.get(uri.clone());
 
-        if start != 0 || stop != u64::MAX {
-            req = if stop == u64::MAX {
-                req.header(Range::Bytes(vec![ByteRangeSpec::AllFrom(start)]))
-            } else {
-                req.header(Range::Bytes(vec![ByteRangeSpec::FromTo(start, stop - 1)]))
+        if start != 0 || stop.is_some() {
+            req = match stop {
+                None => req.header(Range::Bytes(vec![ByteRangeSpec::AllFrom(start)])),
+                Some(stop) => {
+                    req.header(Range::Bytes(vec![ByteRangeSpec::FromTo(start, stop - 1)]))
+                }
             };
         }
 
@@ -80,9 +85,9 @@ impl HttpSrc {
         }
 
         let size = if let Some(&ContentLength(content_length)) = response.headers.get() {
-            content_length + start
+            Some(content_length + start)
         } else {
-            u64::MAX
+            None
         };
 
         let accept_byte_ranges = if let Some(&AcceptRanges(ref ranges)) = response.headers
@@ -92,7 +97,7 @@ impl HttpSrc {
             false
         };
 
-        let seekable = size != u64::MAX && accept_byte_ranges;
+        let seekable = size.is_some() && accept_byte_ranges;
 
         let position = if let Some(&ContentRange(ContentRangeSpec::Bytes { range: Some((range_start,
                                                                                  _)),
@@ -141,16 +146,16 @@ impl Source for HttpSrc {
         }
     }
 
-    fn get_size(&self) -> u64 {
+    fn get_size(&self) -> Option<u64> {
         match self.streaming_state {
             StreamingState::Started { size, .. } => size,
-            _ => u64::MAX,
+            _ => None,
         }
     }
 
     fn start(&mut self, uri: &Url) -> Result<(), ErrorMessage> {
         self.streaming_state = StreamingState::Stopped;
-        self.streaming_state = try!(self.do_request(uri.clone(), 0, u64::MAX));
+        self.streaming_state = try!(self.do_request(uri.clone(), 0, None));
 
         Ok(())
     }
@@ -161,7 +166,7 @@ impl Source for HttpSrc {
         Ok(())
     }
 
-    fn seek(&mut self, start: u64, stop: u64) -> Result<(), ErrorMessage> {
+    fn seek(&mut self, start: u64, stop: Option<u64>) -> Result<(), ErrorMessage> {
         let (position, old_stop, uri) = match self.streaming_state {
             StreamingState::Started { position, stop, ref uri, .. } => {
                 (position, stop, uri.clone())

src/rssource.rs

@@ -20,6 +20,7 @@ use std::os::raw::c_void;
 use std::ffi::{CStr, CString};
 use std::slice;
 use std::ptr;
+use std::u64;
 
 use std::sync::Mutex;
 
@@ -60,12 +61,12 @@ pub trait Source {
     fn uri_validator(&self) -> Box<UriValidator>;
 
     fn is_seekable(&self) -> bool;
-    fn get_size(&self) -> u64;
+    fn get_size(&self) -> Option<u64>;
 
     fn start(&mut self, uri: &Url) -> Result<(), ErrorMessage>;
     fn stop(&mut self) -> Result<(), ErrorMessage>;
     fn fill(&mut self, offset: u64, data: &mut [u8]) -> Result<usize, FlowError>;
-    fn seek(&mut self, start: u64, stop: u64) -> Result<(), ErrorMessage>;
+    fn seek(&mut self, start: u64, stop: Option<u64>) -> Result<(), ErrorMessage>;
 }
 
 impl SourceWrapper {
@@ -158,7 +159,10 @@ pub unsafe extern "C" fn source_get_size(ptr: *const SourceWrapper) -> u64 {
     let wrap: &SourceWrapper = &*ptr;
     let source = &wrap.source.lock().unwrap();
 
-    source.get_size()
+    match source.get_size() {
+        Some(size) => size,
+        None => u64::MAX,
+    }
 }
 
 #[no_mangle]
@@ -237,7 +241,7 @@ pub unsafe extern "C" fn source_seek(ptr: *mut SourceWrapper, start: u64, stop:
     let wrap: &mut SourceWrapper = &mut *ptr;
     let source = &mut wrap.source.lock().unwrap();
 
-    match source.seek(start, stop) {
+    match source.seek(start, if stop == u64::MAX { None } else { Some(stop) }) {
         Ok(..) => GBoolean::True,
         Err(ref msg) => {
             msg.post(wrap.source_raw);