Flush on drop

I believe flush must be explicit, and Rust should have a lint to
remind user to call it explicitly.

But while Rust has no such lint, we will flush on drop.

Note that current implementation panics, if flush fails.

protobuf/src/stream.rs

@@ -855,9 +855,6 @@ impl<'a> CodedOutputStream<'a> {
  }
 
  /// `CodedOutputStream` which writes directly to `Vec<u8>`.
- ///
- /// Caller should call `flush` at the end to guarantee vec contains
- /// all written data.
  pub fn vec(vec: &'a mut Vec<u8>) -> CodedOutputStream<'a> {
  CodedOutputStream {
  target: OutputTarget::Vec(vec),
@@ -899,6 +896,11 @@ impl<'a> CodedOutputStream<'a> {
  Ok(())
  }
 
+ /// Flush to buffer to the underlying buffer.
+ /// Note that `CodedOutputStream` does `flush` in the descructor,
+ /// however, if `flush` in desctructor fails, then destructor panics
+ /// and program terminates. So it's advisable to explicitly call flush
+ /// before destructor.
  pub fn flush(&mut self) -> ProtobufResult<()> {
  match self.target {
  OutputTarget::Bytes => Ok(()),
@@ -1229,6 +1231,13 @@ impl<'a> Write for CodedOutputStream<'a> {
  }
 }
 
+impl<'a> Drop for CodedOutputStream<'a> {
+ fn drop(&mut self) {
+ // This may panic
+ CodedOutputStream::flush(self).expect("failed to flush");
+ }
+}
+
 
 #[cfg(test)]
 mod test {