/// <summary> /// Build an XArray referring to the first element only in an array. /// </summary> /// <param name="array">Array to use first element from</param> /// <returns>XArray wrapping first array value as a Single</returns> public static XArray Single(Array array, int count) { return(new XArray() { Array = array, Selector = ArraySelector.Single(count) }); }
/// <summary> /// Build an XArray with only the value 'false' for the logical row count. /// </summary> /// <param name="count">Number of rows in result XArray</param> /// <returns>XArray with a single value false for everything</returns> public static XArray AllFalse(int count) { return(new XArray() { Array = s_SingleFalse, NullRows = null, Selector = ArraySelector.Single(count) }); }
/// <summary> /// Build an XArray with only the value 'null' for the logical row count. /// </summary> /// <param name="count">Row Count to return 'null' for</param> /// <returns>XArray with a null Array and a single value indicating null for everything</returns> public static XArray Null(Array singleNullValueArray, int count) { return(new XArray() { Array = singleNullValueArray, NullRows = s_SingleTrue, Selector = ArraySelector.Single(count) }); }
/// <summary> /// Build an XArray referring to [0, Count) in the array with the optional given null array. /// </summary> /// <param name="array">Array containing values</param> /// <param name="count">Count of valid Array values</param> /// <param name="nulls">bool[] true for rows which have a null value</param> /// <param name="isSingle">True for IsSingleValue arrays, False otherwise</param> /// <returns>XArray wrapping the array from [0, Count)</returns> public static XArray All(Array array, int count = -1, bool[] nulls = null, bool isSingle = false) { if (array == null) { if (count == 0 || count == -1) { return(XArray.Empty); } throw new ArgumentNullException("array"); } if (count == -1) { count = array.Length; } if (isSingle == false && count > array.Length) { throw new ArgumentOutOfRangeException("length"); } if (isSingle == false && nulls != null && count > nulls.Length) { throw new ArgumentOutOfRangeException("length"); } return(new XArray() { Array = array, NullRows = nulls, Selector = (isSingle ? ArraySelector.Single(count) : ArraySelector.All(count)) }); }
/// <summary> /// Replace the values in an XArray and return it with the same selector /// </summary> /// <param name="other">Replacement Array to use</param> /// <returns>XArray with values replaced and Selector the same</returns> public XArray ReplaceValues(XArray other, bool[] nulls) { if (other.Selector.IsSingleValue) { return(new XArray(this) { Array = other.Array, NullRows = nulls, Selector = ArraySelector.Single(this.Count) }); } else { return(new XArray(this) { Array = other.Array, NullRows = nulls }); } }
public ArraySelector Select(ArraySelector inner, ref int[] remapArray) { // This selector could refer to a full array [0, Count), a slice [Start, End), or indirection indices. // If this is a single value, return the requested count of copies of it if (this.IsSingleValue) { return(ArraySelector.Single(inner.Count)); } // If this selector is not shifted or indirected, the inner selector can be used as-is if (this.Indices == null && this.StartIndexInclusive == 0) { return(inner); } // If the inner selector specifies just an index and length, we can shift our index and length if (inner.Indices == null) { ArraySelector newSelector = new ArraySelector(this); newSelector.StartIndexInclusive += inner.StartIndexInclusive; newSelector.EndIndexExclusive = newSelector.StartIndexInclusive + inner.Count; return(newSelector); } // Otherwise, we need to remap the indices in the inner array to ones in the real array Allocator.AllocateToSize(ref remapArray, inner.Count); for (int i = 0; i < inner.Count; ++i) { remapArray[i] = Index(inner.Index(i)); } return(new ArraySelector() { StartIndexInclusive = 0, EndIndexExclusive = inner.Count, Indices = remapArray }); }