Finished task2. Implemented BufRead and Write for R and W.

hw6/task2/src/main.rs

 use std::process;
 use shell::Shell;
+use shell::{R, W};
 use std::io;
 
 mod command;
 
 fn main() {
     let stdin = io::stdin();
+    let input = R(stdin.lock());
 
     let stdout = io::stdout();
+    let output = W(stdout.lock());
 
-    let mut s = Shell::new(stdin.lock(), stdout.lock(), "schell".to_string());
+    let mut s = Shell::new(input, output, "schell".to_string());
     match s.start() {
         Ok(_) => process::exit(0),
         Err(_) => process::exit(1),

hw6/task2/src/shell.rs

-use std::io::BufRead;
-use std::io::Write;
+use std::io::{BufRead,Write,Read, StdinLock, StdoutLock};
+use std::io;
+
 use command::*;
 use std::str::FromStr;
 use std::env;
 
-pub struct Shell<R:BufRead, W:Write> {
+pub struct R<'a>(pub StdinLock<'a>);
+pub struct W<'a>(pub StdoutLock<'a>);
+
+pub struct Shell<R, W> {
     pub reader: R,
     pub writer: W,
     pub should_exit: bool,
 
 }
 
+impl <'a>Read for R<'a> {
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize, io::Error> {
+        self.0.read(buf)
+    }
+}
+
+impl <'a>BufRead for R<'a> {
+
+    fn fill_buf(&mut self) -> Result<&[u8], io::Error> {
+        self.0.fill_buf()
+    }
+
+    fn consume(&mut self, amt: usize) {
+        self.0.consume(amt)
+    }
+}
+
+impl <'a>Write for W<'a> {
+    fn write(&mut self, buf: &[u8]) -> Result<usize, io::Error> {
+        self.0.write(buf)
+    }
+    
+    fn flush(&mut self) -> Result<(),  io::Error> {
+        self.0.flush()
+    }
+}
+