prometheus-parser 0.4.2

// (C) Copyright 2019-2020 Hewlett Packard Enterprise Development LP

use std::fmt;

use super::function::Function;
use super::group::Group;
use super::operator::Operator;
use super::return_value::{LabelSetOp, ReturnKind, ReturnValue};
use super::selector::Selector;

/// A root expression node.
///
/// These are all valid root expression types.
#[derive(PartialEq, Clone)]
pub enum Expression {
  /// A single scalar float
  Float(f64),

  /// A single scalar string.
  ///
  /// Prometheus' docs claim strings aren't currently implemented, but they're
  /// valid as function arguments.
  String(String),

  /// A metric selector
  Selector(Selector),

  /// A grouped expression wrapped in parentheses
  Group(Group),

  /// A function call
  Function(Function),

  /// A binary operator expression
  Operator(Operator)
}

// For handling groups when testing
impl Expression {
  /// Wraps this Expression in a Group, consuming this Expression but returning
  /// an owned Group.
  pub fn group(self) -> Expression {
    Group::new(self).wrap()
  }

  /// Determines a predicted `ReturnValue` for this Expression. A `ReturnValue`
  /// includes a predicted data type and a set of label operations that may
  /// affect which labels are returned.
  pub fn return_value(&self) -> ReturnValue {
    match self {
      Expression::Float(_) => ReturnValue {
        kind: ReturnKind::Scalar,
        label_ops: vec![LabelSetOp::clear(self.clone(), None)]
      },
      Expression::String(_) => ReturnValue {
        kind: ReturnKind::String,
        label_ops: vec![LabelSetOp::clear(self.clone(), None)]
      },
      Expression::Selector(s) => s.return_value(),
      Expression::Group(g) => g.return_value(),
      Expression::Function(f) => f.return_value(),
      Expression::Operator(o) => o.return_value()
    }
  }

  /// If this Expression is a Float, returns its value. Otherwise, returns None.
  pub fn as_f64(&self) -> Option<f64> {
    if let Expression::Float(f) = self {
      Some(*f)
    } else {
      None
    }
  }

  /// If this Expression is a String, returns its value. Otherwise, returns
  /// None.
  pub fn as_str(&self) -> Option<&str> {
    if let Expression::String(s) = self {
      Some(s.as_str())
    } else {
      None
    }
  }
}

impl fmt::Debug for Expression {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    // don't bother formatting the Expression enum itself, this just creates
    // tons of whitespace if we pretty-print
    // this makes the output significantly more readable, if a bit misleading

    // there's gotta be a better way to pass through flags...
    if f.alternate() {
      match self {
        Expression::Float(val) => write!(f, "{:#?}", val),
        Expression::String(val) => write!(f, "{:#?}", val),
        Expression::Selector(val) => write!(f, "{:#?}", val),
        Expression::Group(val) => write!(f, "{:#?}", val),
        Expression::Function(val) => write!(f, "{:#?}", val),
        Expression::Operator(val) => write!(f, "{:#?}", val),
      }
    } else {
      match self {
        Expression::Float(val) => write!(f, "{:?}", val),
        Expression::String(val) => write!(f, "{:?}", val),
        Expression::Selector(val) => write!(f, "{:?}", val),
        Expression::Group(val) => write!(f, "{:?}", val),
        Expression::Function(val) => write!(f, "{:?}", val),
        Expression::Operator(val) => write!(f, "{:?}", val),
      }
    }
  }
}

impl fmt::Display for Expression {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    match self {
      Expression::Float(val) => write!(f, "{}", val),
      Expression::String(val) => write!(f, "{}", val),
      Expression::Selector(val) => write!(f, "{}", val),
      Expression::Group(val) => write!(f, "{}", val),
      Expression::Function(val) => write!(f, "{}", val),
      Expression::Operator(val) => write!(f, "{}", val),
    }
  }
}

pub type BExpression = Box<Expression>;