arrow-parser 0.0.2

use crate::operator::ExprOperator;
use crate::operator::ExprOperatorName;
use crate::operator::EXPR_OPERATORS;
use crate::token::TokenType;
use lazy_static::lazy_static;
use std::collections::HashMap;

lazy_static! {
  pub static ref BINARY_OPERATOR_MAPPING: HashMap<TokenType, &'static ExprOperator> = {
    let mut map = HashMap::<TokenType, &'static ExprOperator>::new();
    map.insert(
      TokenType::Plus,
      &EXPR_OPERATORS[&ExprOperatorName::Addition],
    );
    map.insert(
      TokenType::HyphenChevronRight,
      &EXPR_OPERATORS[&ExprOperatorName::Arrow],
    );
    map.insert(TokenType::KeywordAs, &EXPR_OPERATORS[&ExprOperatorName::As]);
    map.insert(
      TokenType::ColonColon,
      &EXPR_OPERATORS[&ExprOperatorName::Bind],
    );
    map.insert(
      TokenType::Ampersand,
      &EXPR_OPERATORS[&ExprOperatorName::BitwiseAnd],
    );
    map.insert(
      TokenType::ChevronLeftChevronLeft,
      &EXPR_OPERATORS[&ExprOperatorName::BitwiseLeftShift],
    );
    map.insert(
      TokenType::Bar,
      &EXPR_OPERATORS[&ExprOperatorName::BitwiseOr],
    );
    map.insert(
      TokenType::ChevronRightChevronRight,
      &EXPR_OPERATORS[&ExprOperatorName::BitwiseRightShift],
    );
    map.insert(
      TokenType::ChevronRightChevronRightChevronRight,
      &EXPR_OPERATORS[&ExprOperatorName::BitwiseUnsignedRightShift],
    );
    map.insert(
      TokenType::Caret,
      &EXPR_OPERATORS[&ExprOperatorName::BitwiseXor],
    );
    map.insert(
      TokenType::ParenthesisOpen,
      &EXPR_OPERATORS[&ExprOperatorName::Call],
    );
    map.insert(
      TokenType::BracketOpen,
      &EXPR_OPERATORS[&ExprOperatorName::Index],
    );
    map.insert(
      TokenType::Slash,
      &EXPR_OPERATORS[&ExprOperatorName::Division],
    );
    map.insert(
      TokenType::EqualsEquals,
      &EXPR_OPERATORS[&ExprOperatorName::Equality],
    );
    map.insert(
      TokenType::AsteriskAsterisk,
      &EXPR_OPERATORS[&ExprOperatorName::Exponentiation],
    );
    map.insert(
      TokenType::ChevronRight,
      &EXPR_OPERATORS[&ExprOperatorName::GreaterThan],
    );
    map.insert(
      TokenType::ChevronRightEquals,
      &EXPR_OPERATORS[&ExprOperatorName::GreaterThanOrEqual],
    );
    map.insert(
      TokenType::ExclamationEquals,
      &EXPR_OPERATORS[&ExprOperatorName::Inequality],
    );
    map.insert(
      TokenType::ChevronLeft,
      &EXPR_OPERATORS[&ExprOperatorName::LessThan],
    );
    map.insert(
      TokenType::ChevronLeftEquals,
      &EXPR_OPERATORS[&ExprOperatorName::LessThanOrEqual],
    );
    map.insert(
      TokenType::AmpersandAmpersand,
      &EXPR_OPERATORS[&ExprOperatorName::LogicalAnd],
    );
    map.insert(
      TokenType::BarBar,
      &EXPR_OPERATORS[&ExprOperatorName::LogicalOr],
    );
    map.insert(
      TokenType::Dot,
      &EXPR_OPERATORS[&ExprOperatorName::MemberAccess],
    );
    map.insert(
      TokenType::Asterisk,
      &EXPR_OPERATORS[&ExprOperatorName::Multiplication],
    );
    map.insert(
      TokenType::QuestionQuestion,
      &EXPR_OPERATORS[&ExprOperatorName::OptionalCoalescing],
    );
    map.insert(
      TokenType::QuestionDot,
      &EXPR_OPERATORS[&ExprOperatorName::OptionalMemberAccess],
    );
    map.insert(
      TokenType::QuestionBracketOpen,
      &EXPR_OPERATORS[&ExprOperatorName::OptionalIndex],
    );
    map.insert(
      TokenType::QuestionParenthesisOpen,
      &EXPR_OPERATORS[&ExprOperatorName::OptionalCall],
    );
    map.insert(
      TokenType::Percent,
      &EXPR_OPERATORS[&ExprOperatorName::Remainder],
    );
    map.insert(
      TokenType::Hyphen,
      &EXPR_OPERATORS[&ExprOperatorName::Subtraction],
    );
    map
  };
  pub static ref UNARY_OPERATOR_MAPPING: HashMap<TokenType, &'static ExprOperator> = {
    let mut map = HashMap::<TokenType, &'static ExprOperator>::new();
    map.insert(
      TokenType::Exclamation,
      &EXPR_OPERATORS[&ExprOperatorName::Not],
    );
    map.insert(
      TokenType::Hyphen,
      &EXPR_OPERATORS[&ExprOperatorName::Negation],
    );
    map
  };
}