Files
spark/src/client/spark/Predicates/Data/Primitive/DoublePredicate.cs
T

120 lines
6.2 KiB
C#

using bts.proto;
using bts.utils;
using mbts.spark;
using mbts.ui.spark;
using ProtoBuf;
using System;
using System.Collections.Generic;
using System.ComponentModel;
namespace mbts {
static class DoublePredicateVMFactory {
public static Dictionary<DoublePredicate.PredicateTypeOneofCase, ITemplatedPropertyWrapperVM<DoublePredicate>> get_oneofs() =>
new Dictionary<DoublePredicate.PredicateTypeOneofCase, ITemplatedPropertyWrapperVM<DoublePredicate>> {
{ DoublePredicate.PredicateTypeOneofCase.GreaterThan, PropertyWrapperVMUtils.create_vm<DoublePredicate, double>(
PredicateTemplateKeys.DoubleValue, p => p.greater_than.Value, (p, d) => p.greater_than = d) },
{ DoublePredicate.PredicateTypeOneofCase.LessThan, PropertyWrapperVMUtils.create_vm<DoublePredicate, double>(
PredicateTemplateKeys.DoubleValue, p => p.less_than.Value, (p, d) => p.less_than = d) },
{ DoublePredicate.PredicateTypeOneofCase.InsideRange, PropertyWrapperVMUtils.create_vm<DoublePredicate, DoubleRange>(
PredicateTemplateKeys.DoubleRange, p => p.inside_range.Value, (p, r) => p.inside_range = r) },
{ DoublePredicate.PredicateTypeOneofCase.OutsideRange, PropertyWrapperVMUtils.create_vm<DoublePredicate, DoubleRange>(
PredicateTemplateKeys.DoubleRange, p => p.outside_range.Value, (p, r) => p.outside_range = r) }
};
}
[ProtoContract]
class DoublePredicate : IEquatable<DoublePredicate> {
// not using a 'negate' flag here bc its meaning is not consistent for all value-types
// greater than vs less than for specific values, or inside vs outside for value-ranges
// trading a little more code for more clarity
double? _greater_than, _less_than;
DoubleRange? _inside_range, _outside_range;
public enum PredicateTypeOneofCase {
None,
[Description("is greater than")]
GreaterThan,
[Description("is less than")]
LessThan,
[Description("is between")]
InsideRange,
[Description("is not between")]
OutsideRange
}
[ProtoMember(1)]
public double? greater_than { get => _greater_than; set => _set(ref _greater_than, value); }
[ProtoMember(2)]
public double? less_than { get => _less_than; set => _set(ref _less_than, value); }
[ProtoMember(3)]
public DoubleRange? inside_range { get => _inside_range; set => _set(ref _inside_range, value); }
[ProtoMember(4)]
public DoubleRange? outside_range { get => _outside_range; set => _set(ref _outside_range, value); }
public PredicateTypeOneofCase predicate_type_case {
get {
if (_greater_than != null) return PredicateTypeOneofCase.GreaterThan;
if (_less_than != null) return PredicateTypeOneofCase.LessThan;
if (_inside_range != null) return PredicateTypeOneofCase.InsideRange;
if (_outside_range != null) return PredicateTypeOneofCase.OutsideRange;
return PredicateTypeOneofCase.None;
}
}
public static DoublePredicate create(PredicateTypeOneofCase type, double min, double max) {
var rv = new DoublePredicate();
switch (type) {
case PredicateTypeOneofCase.GreaterThan: rv.greater_than = min; break;
case PredicateTypeOneofCase.LessThan: rv.less_than = max; break;
case PredicateTypeOneofCase.InsideRange: rv.inside_range = new DoubleRange(min, max); break;
case PredicateTypeOneofCase.OutsideRange: rv.outside_range = new DoubleRange(min, max); break;
}
return rv;
}
public IPredicate<double> create() {
switch (predicate_type_case) {
case PredicateTypeOneofCase.GreaterThan: return PredicateBuilder.greater_than(_greater_than.Value);
case PredicateTypeOneofCase.LessThan: return PredicateBuilder.less_than(_less_than.Value);
case PredicateTypeOneofCase.InsideRange: return PredicateBuilder.inside_range(_inside_range.Value.minimum, _inside_range.Value.maximum);
case PredicateTypeOneofCase.OutsideRange: return PredicateBuilder.outside_range(_outside_range.Value.minimum, _outside_range.Value.maximum);
default: return null;
}
}
public bool Equals(DoublePredicate other) {
if (other == null)
return false;
switch (predicate_type_case) {
case PredicateTypeOneofCase.GreaterThan: return other._greater_than.HasValue && _greater_than.Value.Equals(other._greater_than.Value);
case PredicateTypeOneofCase.LessThan: return other._less_than.HasValue && _less_than.Value.Equals(other._less_than.Value);
case PredicateTypeOneofCase.InsideRange: return other._inside_range.HasValue && _inside_range.Value.Equals(other._inside_range.Value);
case PredicateTypeOneofCase.OutsideRange: return other._outside_range.HasValue && _outside_range.Value.Equals(other._outside_range.Value);
case PredicateTypeOneofCase.None: return other.predicate_type_case == PredicateTypeOneofCase.None;
default: throw ExceptionHelper.unexpected_oneof_case(predicate_type_case);
}
}
public override bool Equals(object obj) => Equals(obj as DoublePredicate);
public override int GetHashCode() {
switch (predicate_type_case) {
case PredicateTypeOneofCase.GreaterThan: return _greater_than.Value.GetHashCode() % MathUtils.Primes.P_17191;
case PredicateTypeOneofCase.LessThan: return _less_than.Value.GetHashCode() % MathUtils.Primes.P_83987;
case PredicateTypeOneofCase.InsideRange: return _inside_range.Value.GetHashCode() % MathUtils.Primes.P_356219;
case PredicateTypeOneofCase.OutsideRange: return _outside_range.Value.GetHashCode() % MathUtils.Primes.P_919223;
default: return 0;
}
}
void _set<T>(ref T? field, T? value) where T : struct {
if (value.HasValue) {
_greater_than = null;
_less_than = null;
_inside_range = null;
_outside_range = null;
}
field = value;
}
}
}