nom-operator 0.0.2

// Copyright 2017 The nom-operator project developers
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

//! An Operator wrapper with extra info for parsing

use std::fmt;
use IResult;
use Parser;

/// An Operator wrapper with extra info for parsing
pub struct Operator<O> {
    /// The underlying operator enum
    pub op: O,

    /// The associativity of the operator
    pub associativity: Associativity,

    /// Size of the operator, Unary, Binary, etc...
    pub size: OperatorSize,

    /// The precedence of the operator
    /// If * has precedence 10 and - has precedence 9
    /// the following expression 1 * 2 - 3
    /// would parse as (1 * 2) - 3
    pub precedence: usize,

    /// The nom parser function
    pub parser: Parser,
}


impl<O> Operator<O> {
    /// Creates a new operator
    pub fn new(op: O,
               assoc: Associativity,
               size: OperatorSize,
               prec: usize,
               parser: Parser) -> Self {
        Operator {
            op: op,
            associativity: assoc,
            size: size,
            precedence: prec,
            parser: parser,
        }
    }
}

impl<O: fmt::Debug> fmt::Debug for Operator<O> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f,
               "Operator<{:?}>: \n\tAssociativity: {:?}\n\tPrecedence: {}",
               self.op,
               self.associativity,
               self.precedence)
    }
}

impl<O: PartialEq> PartialEq for Operator<O> {
    // TODO: Should we compare the parser?
    fn eq(&self, other: &Operator<O>) -> bool {
        self.op == other.op &&
            self.associativity == other.associativity &&
            self.precedence == other.precedence
    }
}

/// Size of the operator
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum OperatorSize {
    /// Unary operator
    ///
    /// ++x
    Unary,

    /// Binary operator
    ///
    /// 5 ^ 5
    Binary,
}


/// Associativity of the operator
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Associativity {
    /// Left associative operator
    ///
    /// 5 * 5 * 7 = (5 * 5) * 7
    Left,

    /// Right associative operator
    ///
    /// 5 ^ 5 ^ 9 = 5 ^ (5 ^ 9)
    Right,
}