bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer) { if (object.ReferenceEquals(this, other)) { return(true); } if (other == null) { return(false); } var list = other as ListTuple; if (!object.ReferenceEquals(list, null)) { if (list.m_count != m_count) { return(false); } if (list.m_offset == 0 && list.m_count == list.m_items.Length) { return(CompareItems(list.m_items, comparer)); } else { return(CompareItems(list, comparer)); } } return(TupleHelpers.Equals(this, other, comparer)); }
public IVarTuple this[Range range] { get { int d = this.Depth; (int offset, int count) = range.GetOffsetAndLength(d + 1); if (count == 0) { return(STuple.Empty); } if (count == 1 && offset == d) { return(new STuple <T>(this.Tail)); } if (offset == 0) { if (count == d + 1) { return(this); } if (count == d) { return(this.Head); } } return(TupleHelpers.Splice(this, range)); } }
bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { if (object.ReferenceEquals(this, other)) { return(true); } if (other == null) { return(false); } var linked = other as LinkedTuple <T>; if (!object.ReferenceEquals(linked, null)) { // must have same length if (linked.Count != this.Count) { return(false); } // compare the tail before if (!comparer.Equals(this.Tail, linked.Tail)) { return(false); } // compare the rest return(this.Head.Equals(linked.Tail, comparer)); } return(TupleHelpers.Equals(this, other, comparer)); }
public IVarTuple this[Range range] { get { int lenHead = this.Head.Count; int lenTail = this.Tail.Count; (int offset, int count) = range.GetOffsetAndLength(lenHead + lenTail); if (count == 0) { return(STuple.Empty); } if (offset == 0) { if (count == lenHead + lenTail) { return(this); } if (count == lenHead) { return(this.Head); } } if (offset == lenHead && count == lenTail) { return(this.Tail); } return(TupleHelpers.Splice(this, range)); } }
public IVarTuple this[int?fromIncluded, int?toExcluded] { get { int begin = fromIncluded.HasValue ? TupleHelpers.MapIndexBounded(fromIncluded.Value, m_count) : 0; int end = toExcluded.HasValue ? TupleHelpers.MapIndexBounded(toExcluded.Value, m_count) : m_count; if (end <= begin) { return(STuple.Empty); } int p = this.Head.Count; if (begin >= p) { // all selected items are in the tail return(this.Tail[begin - p, end - p]); } if (end <= p) { // all selected items are in the head return(this.Head[begin, end]); } // selected items are both in head and tail return(new JoinedTuple(this.Head[begin, null], this.Tail[null, end - p])); } }
/// <summary>Test if the start of current tuple is equal to another tuple</summary> /// <param name="left">Larger tuple</param> /// <param name="right">Smaller tuple</param> /// <returns>True if the beginning of <paramref name="left"/> is equal to <paramref name="right"/> or if both tuples are identical</returns> public static bool StartsWith([NotNull] this ITuple left, [NotNull] ITuple right) { Contract.NotNull(left, nameof(left)); Contract.NotNull(right, nameof(right)); //REVIEW: move this on ITuple interface ? return(TupleHelpers.StartsWith(left, right)); }
/// <summary>Test if the end of current tuple is equal to another tuple</summary> /// <param name="left">Larger tuple</param> /// <param name="right">Smaller tuple</param> /// <returns>True if the end of <paramref name="left"/> is equal to <paramref name="right"/> or if both tuples are identical</returns> public static bool EndsWith(this IVarTuple left, IVarTuple right) { Contract.NotNull(left, nameof(left)); Contract.NotNull(right, nameof(right)); //REVIEW: move this on ITuple interface ? return(TupleHelpers.EndsWith(left, right)); }
public object?this[int index] { get { int p = TupleHelpers.MapIndex(index, m_count); return(p < m_split ? this.Head[p] : this.Tail[p - m_split]); } }
/// <summary>Return the typed value of an item of the tuple, given its position</summary> /// <typeparam name="TItem">Expected type of the item</typeparam> /// <param name="index">Position of the item (if negative, means relative from the end)</param> /// <returns>Value of the item at position <paramref name="index"/>, adapted into type <typeparamref name="TItem"/>.</returns> public TItem Get <TItem>(int index) { if (index > 0 || index < -1) { return(TupleHelpers.FailIndexOutOfRange <TItem>(index, 1)); } return(TypeConverters.Convert <T1, TItem>(this.Item1)); }
public object this[int index] { get { index = TupleHelpers.MapIndex(index, m_count); return(index < m_split ? this.Head[index] : this.Tail[index - m_split]); } }
object IReadOnlyList <object> .this[int index] { get { if (index > 0 || index < -1) { return(TupleHelpers.FailIndexOutOfRange <object>(index, 1)); } return(this.Item1); } }
object?IVarTuple.this[int index] { get { if (index > 0 || index < -1) { return(TupleHelpers.FailIndexOutOfRange <object>(index, 1)); } return(this.Item1); } }
public object?this[Index index] { get { int p = TupleHelpers.MapIndex(index, this.Depth + 1); if (p == this.Depth) { return(this.Tail); } return(this.Head[p]); } }
public bool Equals(IVarTuple?other) { if (other == null) { return(false); } if (other is MemoizedTuple mt) { return(m_packed.Equals(mt.m_packed)); } return(TupleHelpers.Equals(this, other, SimilarValueComparer.Default)); }
public bool Equals(IVarTuple other) { if (object.ReferenceEquals(other, null)) { return(false); } var memoized = other as MemoizedTuple; if (!object.ReferenceEquals(memoized, null)) { return(m_packed.Equals(memoized.m_packed)); } return(TupleHelpers.Equals(this, other, SimilarValueComparer.Default)); }
bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer) { if (other == null) { return(false); } if (other is STuple <T1> stuple) { return(comparer.Equals(this.Item1, stuple.Item1)); } if (other is ValueTuple <T1> vtuple) { return(comparer.Equals(this.Item1, vtuple.Item1)); } return(TupleHelpers.Equals(this, other, comparer)); }
public static ITupleFormatter <T> CreateAppender([NotNull] ITuple prefix) { Contract.NotNull(prefix, nameof(prefix)); return(new AnonymousTupleFormatter <T>( (value) => prefix.Append <T>(value), (tuple) => { if (tuple.Count != prefix.Count + 1) { throw new ArgumentException("Tuple size is invalid", "tuple"); } if (!TupleHelpers.StartsWith(tuple, prefix)) { throw new ArgumentException("Tuple does not start with the expected prefix", "tuple"); } return tuple.Last <T>(); } )); }
public IVarTuple this[int?fromIncluded, int?toExcluded] { get { int begin = fromIncluded.HasValue ? TupleHelpers.MapIndexBounded(fromIncluded.Value, m_count) : 0; int end = toExcluded.HasValue ? TupleHelpers.MapIndexBounded(toExcluded.Value, m_count) : m_count; int len = end - begin; if (len <= 0) { return(STuple.Empty); } if (begin == 0 && len == m_count) { return(this); } Contract.Assert(m_offset + begin >= m_offset); Contract.Assert(len >= 0 && len <= m_count); return(new ListTuple(m_items, m_offset + begin, len)); } }
public IVarTuple this[int?fromIncluded, int?toExcluded] { get { int count = m_items.Length; int begin = fromIncluded.HasValue ? TupleHelpers.MapIndexBounded(fromIncluded.Value, count) : 0; int end = toExcluded.HasValue ? TupleHelpers.MapIndexBounded(toExcluded.Value, count) : count; int len = end - begin; if (len <= 0) { return(STuple.Empty); } if (begin == 0 && len == count) { return(this); } Contract.Debug.Assert(begin >= 0); Contract.Debug.Assert((uint)len <= count); return(new ListTuple <T>(m_items.Slice(begin, len))); } }
public object this[int index] => m_items[TupleHelpers.MapIndex(index, m_items.Length)];
public T Get <T>(int index) { index = TupleHelpers.MapIndex(index, m_count); return(index < m_split?this.Head.Get <T>(index) : this.Tail.Get <T>(index - m_split)); }
public object this[int index] { get { return(m_items[TupleHelpers.MapIndex(index, m_items.Length)]); } }
public T this[Index index] => m_items.Span[TupleHelpers.MapIndex(index, m_items.Length)];
public ITuple this[int?fromIncluded, int?toExcluded] { get { return(TupleHelpers.Splice(this, fromIncluded, toExcluded)); } }
public object this[int index] => m_items[m_offset + TupleHelpers.MapIndex(index, m_count)];
bool IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { return(TupleHelpers.Equals(this, other, comparer)); }
int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { return(TupleHelpers.StructuralGetHashCode(this, comparer)); }
public IVarTuple this[int?fromIncluded, int?toExcluded] => TupleHelpers.Splice(this, fromIncluded, toExcluded);