tree.rs

use std::io::{self, Read};
use std::rc::Rc;
use std::cell::RefCell;

fn main() -> io::Result<()>{
    let mut buffer = String::new();
    let stdin = io::stdin();
    let mut handle = stdin.lock();
    handle.read_to_string(&mut buffer)?;
    let tokens = str2token(buffer);
    println!("{:?}", tokens);
    Ok(())
}

#[derive(Clone, Debug)]
enum Token {
    Plus(u64),
    Minus(u64),
    Prev(u64),
    Next(u64),
    WhileStart,
    WhileEnd,
    Input,
    Output,
}

fn str2token(input: String) -> Vec<Token> {
    let mut ret: Vec<Token> = Vec::new();
    for &b in input.as_bytes() {
        match b as char {
            '+' => ret.push(Token::Plus(1)),
            '-' => ret.push(Token::Minus(1)),
            '<' => ret.push(Token::Prev(1)),
            '>' => ret.push(Token::Next(1)),
            '[' => ret.push(Token::WhileStart),
            ']' => ret.push(Token::WhileEnd),
            ',' => ret.push(Token::Input),
            '.' => ret.push(Token::Output),
            '\n' => (),
            _ => panic!("invalid string"),
        }
    }
    ret
}

fn make_tree(tokens: Vec<Token>) -> TokenTree {
    let mut ret = TokenTree::root();
    for token in &tokens {
        ret.add_child(TokenTree::new(token.clone()));
    }
    ret
}


#[derive(Clone, Debug)]
struct TokenTree {
    value: Option<Token>, // root node have no value
    children: Vec<Rc<RefCell<TokenTree>>>,
}

impl TokenTree {
    fn new(value: Token) -> TokenTree {
        TokenTree {
            value: Some(value),
            children: Vec::new(),
        }
    }

    fn add_child(&mut self, child: TokenTree) {
        let sub_tree = Rc::new(RefCell::new(child));
        self.children.push(sub_tree);
    }

    fn root() -> TokenTree {
        TokenTree {
            value: None,
            children: Vec::new(),
        }
    }
}