Made task2 more complex :|

hw6/task2/src/command.rs

+use std::ffi::OsString;
+use std::str::FromStr;
+
 enum Command {
     Empty,
     Exit,
 
 impl Command {}
 
+struct CommandNotFoundError();
+
 impl FromStr for Command {
-    fn from_str(s: &str) -> Result<Self, Self::Err> {}
+
+    type Err = CommandNotFoundError;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+
+    }
 }

hw6/task2/src/main.rs

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

hw6/task2/src/shell.rs

 use std::io;
 use std::io::prelude::*;
-use command;
+use std::io::BufRead;
+use std::io::Read;
 
-struct Shell<R, W> {
+
+pub struct R;
+pub struct W;
+
+pub struct Shell<R, W> {
     pub reader: R,
     pub writer: W,
     pub should_exit: bool,
     /// Creates a new Shell.
     pub fn new(input: R, output: W, name: String) -> Self {
         Shell {
-            reader = input,
-            writer = output,
-            should_exit = false,
-            name = name,
+            reader : input,
+            writer : output,
+            should_exit : false,
+            name : name,
         }
     }
     /// Initializes the Shell Loop
-    pub fn start() -> Result<Self, &str> {
-        shell_loop();
+    pub fn start<'a>(&self) -> Result<(), &'a str> {
+        self.shell_loop();
+        Ok(())
     }
+
     /// Waits for user inputs.
-    fn shell_loop() -> Result {
+    fn shell_loop(&self) -> Result<(),()> {
         loop {
         }
     }
+
+    /*
     /// Prints the shell prompt.
     fn prompt() -> Result<Option, &str> {
     }
     /// Runs a command.
     fn run(&str) {
     }
+
+    */
 }
 
-impl BufRead for Shell<R, W> {
-    fn fill_buf(&mut self) -> Result<&[u8]> {
-        stdin.fill_buf()
+
+impl Read for R {
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize, io::Error> {
+        let stdin = io::stdin();
+        let mut stdin = stdin.lock();
+
+
+        let buffer = stdin.read(buf);
+
+        match buffer {
+            Ok(x) => {
+                println!("{} ||| {:?}", x, buffer);
+                stdin.consume(x);
+                Ok(x)
+            },
+            Err(_) => Err(io::Error::new(io::ErrorKind::InvalidInput, "jhrthhzruzkikz")),
+        }
+    }
+}
+
+impl BufRead for R {
+
+    fn fill_buf(&mut self) -> Result<&[u8], io::Error> {
+        Ok(&[11])
     }
+
     fn consume(&mut self, amt: usize) {
+        let mut buffer = self.fill_buf;
+        if buffer.len <= amt {
+
+        }
     }
 }
 
-impl Write for Shell<R, W> {
-    fn write(&mut self, buf: &[u8]) -> Result<usize> {
+impl Write for W {
+    fn write(&mut self, buf: &[u8]) -> Result<usize, io::Error> {
     }
-    fn flush(&mut self) -> Result<()> {
+    fn flush(&mut self) -> Result<(),  io::Error> {
     }
 }