public TupleDomain <U> Transform <U>(Func <T, U> function) { if (this.Domains == null) { return(TupleDomain <U> .None()); } IDictionary <U, Domain> Result = new Dictionary <U, Domain>(); foreach (KeyValuePair <T, Domain> Entry in this.Domains) { U Key = function.Invoke(Entry.Key); if (Key == null) { continue; } if (Result.ContainsKey(Key)) { throw new ArgumentException($"Every argument must have a unique mapping, {Key.ToString()} maps to {Entry.Value.ToString()} and {Result[Key].ToString()}."); } Result.Add(Key, Entry.Value); } return(TupleDomain <U> .WithColumnDomains(Result)); }
/// <summary> /// Extract all column constraints that require exactly one value or only null in their respective Domains. /// Returns an empty Optional if the Domain is none. /// </summary> /// <param name="tupleDomain"></param> /// <returns></returns> public static IDictionary <T, object> ExtractFixedValues(TupleDomain <T> tupleDomain) { if (tupleDomain.Domains == null) { return(null); } return(tupleDomain.Domains.Where(x => x.Value.IsNullableSingleValue()).ToDictionary(x => x.Key, x => (object)x.Value)); }
public override bool Equals(object obj) { if (this == obj) { return(true); } if (obj == null || this.GetType() != obj.GetType()) { return(false); } TupleDomain <T> Other = (TupleDomain <T>)obj; return(Object.Equals(this.Domains, Other.Domains)); }
public static TupleDomain <T> ColumnWiseUnion(TupleDomain <T> first, TupleDomain <T> second, params TupleDomain <T>[] rest) { List <TupleDomain <T> > Domains = new List <TupleDomain <T> >(); if (first != null) { Domains.Add(first); } if (second != null) { Domains.Add(second); } if (rest != null && rest.Length > 0) { Domains.AddRange(rest); } return(ColumnWiseUnion(Domains)); }
/// <summary> /// Returns the strict intersection of the TupleDomains. /// The resulting TupleDomain represents the set of tuples that would be valid /// in both TupleDomains. /// </summary> /// <param name="other"></param> /// <returns></returns> public TupleDomain <T> Intersect(TupleDomain <T> other) { if (this.IsNone() || other.IsNone()) { return(None()); } IDictionary <T, Domain> Intersected = this.Domains.ToDictionary(x => x.Key, x => x.Value); foreach (KeyValuePair <T, Domain> Item in other.Domains) { if (!Intersected.ContainsKey(Item.Key)) { Intersected.Add(Item.Key, Item.Value); } else { Intersected[Item.Key] = Item.Value.Intersect(Intersected[Item.Key]); } } return(WithColumnDomains(Intersected)); }
/// <summary> /// Returns true only if the this TupleDomain contains all possible tuples that would be allowable by /// the other TupleDomain. /// </summary> /// <param name="domains"></param> /// <returns></returns> public bool Contains(TupleDomain <T> other) { return(other.IsNone() || ColumnWiseUnion(this, other).Equals(this)); }
/// <summary> /// Returns true only if there exists a strict intersection between the TupleDomains. /// i.e. there exists some potential tuple that would be allowable in both TupleDomains. /// </summary> /// <param name="other"></param> /// <returns></returns> public bool Overlaps(TupleDomain <T> other) { return(!this.Intersect(other).IsNone()); }