use std::any::Any;
use std::cmp::Ordering;
use gitql_ast::operator::GroupComparisonOperator;
use gitql_ast::types::time::TimeType;
use gitql_ast::types::DataType;
use super::base::Value;
use super::boolean::BoolValue;
#[derive(Clone)]
pub struct TimeValue {
pub value: String,
}
impl TimeValue {
pub fn new(time: String) -> Self {
TimeValue { value: time }
}
}
impl Value for TimeValue {
fn literal(&self) -> String {
self.value.to_string()
}
fn equals(&self, other: &Box<dyn Value>) -> bool {
if let Some(other_time) = other.as_any().downcast_ref::<TimeValue>() {
return self.value == other_time.value;
}
false
}
fn compare(&self, other: &Box<dyn Value>) -> Option<Ordering> {
if let Some(other_time) = other.as_any().downcast_ref::<TimeValue>() {
return self.value.partial_cmp(&other_time.value);
}
None
}
fn data_type(&self) -> Box<dyn DataType> {
Box::new(TimeType)
}
fn as_any(&self) -> &dyn Any {
self
}
fn eq_op(&self, other: &Box<dyn Value>) -> Result<Box<dyn Value>, String> {
if let Some(other_text) = other.as_any().downcast_ref::<TimeValue>() {
let are_equals = self.value == other_text.value;
return Ok(Box::new(BoolValue { value: are_equals }));
}
Err("Unexpected type to perform `=` with".to_string())
}
fn group_eq_op(
&self,
other: &Box<dyn Value>,
group_op: &GroupComparisonOperator,
) -> Result<Box<dyn Value>, String> {
if other.is_array_of(|element_type| element_type.is_time()) {
let elements = &other.as_array().unwrap();
let mut matches_count = 0;
for element in elements.iter() {
if self.value == element.as_time().unwrap() {
matches_count += 1;
if GroupComparisonOperator::Any.eq(group_op) {
break;
}
}
}
let result = match group_op {
GroupComparisonOperator::All => matches_count == elements.len(),
GroupComparisonOperator::Any => matches_count > 0,
};
return Ok(Box::new(BoolValue::new(result)));
}
Err("Unexpected type to perform `=` with".to_string())
}
fn bang_eq_op(&self, other: &Box<dyn Value>) -> Result<Box<dyn Value>, String> {
if let Some(other_text) = other.as_any().downcast_ref::<TimeValue>() {
let are_equals = self.value != other_text.value;
return Ok(Box::new(BoolValue { value: are_equals }));
}
Err("Unexpected type to perform `!=` with".to_string())
}
fn group_bang_eq_op(
&self,
other: &Box<dyn Value>,
group_op: &GroupComparisonOperator,
) -> Result<Box<dyn Value>, String> {
if other.is_array_of(|element_type| element_type.is_time()) {
let elements = &other.as_array().unwrap();
let mut matches_count = 0;
for element in elements.iter() {
if self.value != element.as_time().unwrap() {
matches_count += 1;
if GroupComparisonOperator::Any.eq(group_op) {
break;
}
}
}
let result = match group_op {
GroupComparisonOperator::All => matches_count == elements.len(),
GroupComparisonOperator::Any => matches_count > 0,
};
return Ok(Box::new(BoolValue::new(result)));
}
Err("Unexpected type to perform `!=` with".to_string())
}
fn gt_op(&self, other: &Box<dyn Value>) -> Result<Box<dyn Value>, String> {
if let Some(other_text) = other.as_any().downcast_ref::<TimeValue>() {
let are_equals = self.value > other_text.value;
return Ok(Box::new(BoolValue { value: are_equals }));
}
Err("Unexpected type to perform `>` with".to_string())
}
fn group_gt_op(
&self,
other: &Box<dyn Value>,
group_op: &GroupComparisonOperator,
) -> Result<Box<dyn Value>, String> {
if other.is_array_of(|element_type| element_type.is_time()) {
let elements = &other.as_array().unwrap();
let mut matches_count = 0;
for element in elements.iter() {
if self.value > element.as_time().unwrap() {
matches_count += 1;
if GroupComparisonOperator::Any.eq(group_op) {
break;
}
}
}
let result = match group_op {
GroupComparisonOperator::All => matches_count == elements.len(),
GroupComparisonOperator::Any => matches_count > 0,
};
return Ok(Box::new(BoolValue::new(result)));
}
Err("Unexpected type to perform `>` with".to_string())
}
fn gte_op(&self, other: &Box<dyn Value>) -> Result<Box<dyn Value>, String> {
if let Some(other_text) = other.as_any().downcast_ref::<TimeValue>() {
let are_equals = self.value >= other_text.value;
return Ok(Box::new(BoolValue { value: are_equals }));
}
Err("Unexpected type to perform `>=` with".to_string())
}
fn group_gte_op(
&self,
other: &Box<dyn Value>,
group_op: &GroupComparisonOperator,
) -> Result<Box<dyn Value>, String> {
if other.is_array_of(|element_type| element_type.is_time()) {
let elements = &other.as_array().unwrap();
let mut matches_count = 0;
for element in elements.iter() {
if self.value >= element.as_time().unwrap() {
matches_count += 1;
if GroupComparisonOperator::Any.eq(group_op) {
break;
}
}
}
let result = match group_op {
GroupComparisonOperator::All => matches_count == elements.len(),
GroupComparisonOperator::Any => matches_count > 0,
};
return Ok(Box::new(BoolValue::new(result)));
}
Err("Unexpected type to perform `>=` with".to_string())
}
fn lt_op(&self, other: &Box<dyn Value>) -> Result<Box<dyn Value>, String> {
if let Some(other_text) = other.as_any().downcast_ref::<TimeValue>() {
let are_equals = self.value < other_text.value;
return Ok(Box::new(BoolValue { value: are_equals }));
}
Err("Unexpected type to perform `<` with".to_string())
}
fn group_lt_op(
&self,
other: &Box<dyn Value>,
group_op: &GroupComparisonOperator,
) -> Result<Box<dyn Value>, String> {
if other.is_array_of(|element_type| element_type.is_time()) {
let elements = &other.as_array().unwrap();
let mut matches_count = 0;
for element in elements.iter() {
if self.value < element.as_time().unwrap() {
matches_count += 1;
if GroupComparisonOperator::Any.eq(group_op) {
break;
}
}
}
let result = match group_op {
GroupComparisonOperator::All => matches_count == elements.len(),
GroupComparisonOperator::Any => matches_count > 0,
};
return Ok(Box::new(BoolValue::new(result)));
}
Err("Unexpected type to perform `<` with".to_string())
}
fn lte_op(&self, other: &Box<dyn Value>) -> Result<Box<dyn Value>, String> {
if let Some(other_text) = other.as_any().downcast_ref::<TimeValue>() {
let are_equals = self.value <= other_text.value;
return Ok(Box::new(BoolValue { value: are_equals }));
}
Err("Unexpected type to perform `<=` with".to_string())
}
fn group_lte_op(
&self,
other: &Box<dyn Value>,
group_op: &GroupComparisonOperator,
) -> Result<Box<dyn Value>, String> {
if other.is_array_of(|element_type| element_type.is_time()) {
let elements = &other.as_array().unwrap();
let mut matches_count = 0;
for element in elements.iter() {
if self.value <= element.as_time().unwrap() {
matches_count += 1;
if GroupComparisonOperator::Any.eq(group_op) {
break;
}
}
}
let result = match group_op {
GroupComparisonOperator::All => matches_count == elements.len(),
GroupComparisonOperator::Any => matches_count > 0,
};
return Ok(Box::new(BoolValue::new(result)));
}
Err("Unexpected type to perform `<=` with".to_string())
}
}