示例#1
0
 public TBuilder AppendNull()
 {
     ValueOffsets.Append(Offset);
     ValidityBuffer.Append(false);
     NullCount++;
     return(Instance);
 }
示例#2
0
 public TBuilder Append(ReadOnlySpan <byte> span)
 {
     ValueOffsets.Append(Offset);
     ValueBuffer.Append(span);
     ValidityBuffer.Append(true);
     Offset += span.Length;
     return(Instance);
 }
示例#3
0
 public TBuilder Append(byte value)
 {
     ValueOffsets.Append(Offset);
     ValueBuffer.Append(value);
     Offset++;
     ValidityBuffer.Append(true);
     return(Instance);
 }
示例#4
0
 /// <summary>
 /// Append a single null value to the array.
 /// </summary>
 /// <returns>Returns the builder (for fluent-style composition).</returns>
 public TBuilder AppendNull()
 {
     // Do not add to the value buffer in the case of a null.
     // Note that we do not need to increment the offset as a result.
     ValidityBuffer.Append(false);
     ValueOffsets.Append(Offset);
     return(Instance);
 }
示例#5
0
 private Builder NullableAppend(bool?value)
 {
     if (Length % 8 == 0)
     {
         // append a new byte to the buffer when needed
         ValueBuffer.Append(0);
         ValidityBuffer.Append(0);
     }
     BitUtility.SetBit(ValueBuffer.Span, Length, value.GetValueOrDefault());
     BitUtility.SetBit(ValidityBuffer.Span, Length, value.HasValue);
     NullCount += value.HasValue ? 0 : 1;
     Length++;
     return(this);
 }
示例#6
0
            public TBuilder AppendRange(IEnumerable <byte> values)
            {
                if (values == null)
                {
                    return(AppendNull());
                }
                int len = ValueBuffer.Length;

                ValueBuffer.AppendRange(values);
                int valOffset = ValueBuffer.Length - len;

                ValueOffsets.Append(Offset);
                Offset += valOffset;
                ValidityBuffer.Append(true);
                return(Instance);
            }
示例#7
0
            public TBuilder AppendRange(IEnumerable <byte[]> values)
            {
                foreach (byte[] arr in values)
                {
                    if (arr == null)
                    {
                        AppendNull();
                        continue;
                    }
                    int len = ValueBuffer.Length;
                    ValueOffsets.Append(Offset);
                    ValueBuffer.Append(arr);
                    ValidityBuffer.Append(true);
                    Offset += ValueBuffer.Length - len;
                }

                return(Instance);
            }
示例#8
0
            /// <summary>
            /// Append a value, consisting of an enumerable collection of bytes, to the array.
            /// </summary>
            /// <remarks>
            /// Note that this method appends a single value, which may consist of arbitrarily many bytes.  If multiple
            /// values are to be added, use the <see cref="AppendRange(IEnumerable{byte})"/> method instead.
            /// </remarks>
            /// <param name="value">Enumerable collection of bytes to add.</param>
            /// <returns>Returns the builder (for fluent-style composition).</returns>
            public TBuilder Append(IEnumerable <byte> value)
            {
                if (value == null)
                {
                    return(AppendNull());
                }

                // Note: by looking at the length of the value buffer before and after, we avoid having to iterate
                // through the enumerable multiple times to get both length and contents.
                int priorLength = ValueBuffer.Length;

                ValueBuffer.AppendRange(value);
                int valueLength = ValueBuffer.Length - priorLength;

                Offset += valueLength;
                ValidityBuffer.Append(true);
                ValueOffsets.Append(Offset);
                return(Instance);
            }