120 lines
6.2 KiB
C#
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;
|
|
}
|
|
}
|
|
} |