path: root/src/tree.rs

// Copyright (c) 2021 Soni L.
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT license.
// Documentation and comments licensed under CC BY-SA 4.0.

//! Command syntax tree.

use ::std::borrow::Cow;

use crate::Command;
use crate::args::{ArgumentType, ArgumentTypeAny};
use crate::strcursor::StringReader;
// FIXME
use crate::args::CommandContext;

/// The kind of node.
enum NodeKind<S, E> {
    /// Root node.
    Root,
    /// Literal node.
    Literal {
        /// The literal of the node.
        literal: Cow<'static, str>,
    },
    /// Argument node.
    Argument {
        /// The label of the node.
        label: Cow<'static, str>,
        /// The argument type.
        arg: Box<dyn ArgumentTypeAny<S, E>>,
    },
}

/// A node in the syntax tree.
pub struct CommandNode<T, S, E> {
    /// The command to run for this node.
    command: Option<Command<T, S, E>>,
    /// Nodes.
    nodes: (),
    /// Literal nodes.
    literals: (),
    /// Argument nodes.
    arguments: (),
    /// The kind of node.
    kind: NodeKind<S, E>,
}

impl<T, S, E> CommandNode<T, S, E> {
    /// Creates a new root node.
    pub fn root() -> Self {
        CommandNode {
            command: None,
            nodes: (),
            literals: (),
            arguments: (),
            kind: NodeKind::Root,
        }
    }

    /// Creates a new literal node.
    pub fn literal(
        word: Cow<'static, str>,
        command: Option<Command<T, S, E>>,
    ) -> Self {
        CommandNode {
            command: command,
            nodes: (),
            literals: (),
            arguments: (),
            kind: NodeKind::Literal {
                literal: word,
            },
        }
    }

    /// Creates a new argument node.
    pub fn argument<A: ArgumentType<S, E> + 'static>(
        name: Cow<'static, str>,
        command: Option<Command<T, S, E>>,
        argument: A,
    ) -> Self {
        CommandNode {
            command: command,
            nodes: (),
            literals: (),
            arguments: (),
            kind: NodeKind::Argument {
                label: name,
                arg: Box::new(argument),
            },
        }
    }

    /// Returns the name of this node.
    ///
    /// For literal nodes, this is the literal itself. For argument nodes, this
    /// is the name of the argument.
    pub fn get_name(&self) -> &str {
        match self.kind {
            NodeKind::Root => "",
            NodeKind::Literal { ref literal, .. } => literal,
            NodeKind::Argument { ref label, .. } => label,
        }
    }
}