/// <summary> /// Packs a null value to current stream asynchronously. /// </summary> /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param> /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns> /// <exception cref="ObjectDisposedException">This instance has been disposed.</exception> public async Task PackNullAsync(CancellationToken cancellationToken) { this.VerifyNotDisposed(); Contract.EndContractBlock(); await this.PrivatePackNullAsyncCore(cancellationToken).ConfigureAwait(false); }
/// <summary> /// Initializes a new instance of the <see cref="MessagePackObjectDictionary"/> class. /// </summary> /// <param name="dictionary">The dictionary to be copied from.</param> /// <exception cref="ArgumentNullException"> /// <paramref name="dictionary"/> is <c>null</c>. /// </exception> /// <exception cref="ArgumentException"> /// Failed to copy from <paramref name="dictionary"/>. /// </exception> /// <remarks> /// This constructor takes <em>O(N)</em> time, <em>N</em> is <see cref="P:ICollection{T}.Count"/> of <paramref name="dictionary"/>. /// Initial capacity will be <see cref="P:ICollection{T}.Count"/> of <paramref name="dictionary"/>. /// </remarks> public MessagePackObjectDictionary(IDictionary <MessagePackObject, MessagePackObject> dictionary) { if (dictionary == null) { throw new ArgumentNullException("dictionary"); } Contract.EndContractBlock(); if (dictionary.Count <= Threashold) { this._keys = new List <MessagePackObject>(dictionary.Count); this._values = new List <MessagePackObject>(dictionary.Count); } else { this._dictionary = new Dictionary <MessagePackObject, MessagePackObject>(dictionary.Count, MessagePackObjectEqualityComparer.Instance); } try { foreach (var kv in dictionary) { this.AddCore(kv.Key, kv.Value, false); } } catch (ArgumentException ex) { #if SILVERLIGHT throw new ArgumentException("Failed to copy specified dictionary.", ex); #else throw new ArgumentException("Failed to copy specified dictionary.", "dictionary", ex); #endif } }
/// <summary> /// Gets the value associated with the specified key. /// </summary> /// <param name="key"> /// The key whose value to get. /// </param> /// <param name="value"> /// When this method returns, the value associated with the specified key, if the key is found; /// otherwise, the default value for the type of the <paramref name="value"/> parameter. /// This parameter is passed uninitialized. /// </param> /// <returns> /// <c>true</c> if this dictionary contains an element with the specified key; otherwise, <c>false</c>. /// </returns> /// <exception cref="ArgumentNullException"> /// <paramref name="key"/> is <see cref="MessagePackObject.Nil"/>. /// </exception> /// <remarks> /// <para> /// Note that tiny integers are considered equal regardless of its CLI <see cref="Type"/>, /// and UTF-8 encoded bytes are considered equals to <see cref="String"/>. /// </para> /// <para> /// This method approaches an O(1) operation. /// </para> /// </remarks> public bool TryGetValue(MessagePackObject key, out MessagePackObject value) { if (key.IsNil) { ThrowKeyNotNilException("key"); } Contract.EndContractBlock(); this.AssertInvariant(); if (this._dictionary == null) { int index = this._keys.FindIndex(item => item == key); if (index < 0) { value = MessagePackObject.Nil; return(false); } else { value = this._values[index]; return(true); } } else { return(this._dictionary.TryGetValue(key, out value)); } }
/// <summary> /// Unpacks raw value from the specified <see cref="Stream"/> as <see cref="UnpackingStream"/>. /// </summary> /// <param name="source">The <see cref="Stream"/> which contains Message Pack binary stream.</param> /// <returns> /// The <see cref="UnpackingStream"/> which represents raw value stream. /// </returns> /// <exception cref="ArgumentNullException"> /// <paramref name="source"/> is <c>null</c>. /// </exception> /// <exception cref="ArgumentException"> /// The <see cref="P:Stream.CanRead"/> of <paramref name="source"/> is <c>false</c>. /// </exception> /// <exception cref="UnpackException"> /// <paramref name="source"/> is not valid MessagePack stream. /// Note that the state of <paramref name="source"/> will be unpredictable espicially it is not seekable. /// </exception> /// <exception cref="MessageTypeException"> /// The unpacked result in the <paramref name="source"/> is not raw binary. /// Note that the state of <paramref name="source"/> will be unpredictable espicially it is not seekable. /// </exception> /// <remarks> /// <para> /// <see cref="UnpackingStream"/> does not own <paramref name="source"/>, so <paramref name="source"/> still should be closed. /// </para> /// <para> /// When the type of packed value is not known, use <see cref="UnpackObject(Stream)"/> instead. /// </para> /// </remarks> public static UnpackingStream UnpackByteStream(Stream source) { ValidateStream(source); Contract.EndContractBlock(); return(UnpackByteStreamCore(source)); }
/// <summary> /// Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. /// </summary> /// <param name="buffer"> /// An array of bytes. When this method returns, /// the buffer contains the specified byte array with the values between <paramref name="offset"/> and ( <paramref name="offset"/> + <paramref name="count"/> - 1) /// replaced by the bytes read from the current source. /// </param> /// <param name="offset"> /// The zero-based byte offset in <paramref name="buffer"/> at which to begin storing the data read from the current stream. /// </param> /// <param name="count"> /// The maximum number of bytes to be read from the current stream. /// </param> /// <returns> /// The total number of bytes read into the buffer. /// This can be less than the number of bytes requested if that many bytes are not currently available, /// or zero (0) if the end of the stream has been reached. /// </returns> /// <exception cref="T:System.ArgumentException"> /// The sum of <paramref name="offset"/> and <paramref name="count"/> is larger than the buffer length. /// </exception> /// <exception cref="T:System.ArgumentNullException"> /// <paramref name="buffer"/> is <c>null</c>. /// </exception> /// <exception cref="T:System.ArgumentOutOfRangeException"> /// <paramref name="offset"/> or <paramref name="count"/> is negative. /// </exception> /// <exception cref="T:System.IO.IOException"> /// An I/O error occurs. /// </exception> /// <exception cref="T:System.ObjectDisposedException"> /// Methods were called after the stream was closed. /// </exception> /// <remarks> /// <note> /// Arguments might be passed to the underlying <see cref="Stream"/> without any validation. /// </note> /// </remarks> public sealed override int Read(byte[] buffer, int offset, int count) { if (count < 0) { throw new ArgumentOutOfRangeException("count"); } Contract.EndContractBlock(); if (this.CurrentOffset == this.RawLength) { return(0); } int realCount = count; var exceeds = this.CurrentOffset + count - this.RawLength; if (exceeds > 0) { realCount -= checked (( int )exceeds); } var readCount = this.Underlying.Read(buffer, offset, realCount); this.CurrentOffset += readCount; return(readCount); }
/// <summary> /// Gets or sets the element with the specified key. /// </summary> /// <value> /// The element with the specified key. /// </value> /// <param name="key">Key for geting or seting value.</param> /// <exception cref="ArgumentNullException"> /// <paramref name="key"/> is <see cref="MessagePackObject.Nil"/>. /// </exception> /// <exception cref="T:System.Collections.Generic.KeyNotFoundException"> /// The property is retrieved and <paramref name="key"/> is not found. /// </exception> /// <exception cref="InvalidOperationException"> /// The property is set and this instance is frozen. /// </exception> /// <remarks> /// <para> /// Note that tiny integers are considered equal regardless of its CLI <see cref="Type"/>, /// and UTF-8 encoded bytes are considered equals to <see cref="String"/>. /// </para> /// <para> /// This method approaches an O(1) operation. /// </para> /// </remarks> public MessagePackObject this[MessagePackObject key] { get { if (key.IsNil) { ThrowKeyNotNilException("key"); } Contract.EndContractBlock(); MessagePackObject result; if (!this.TryGetValue(key, out result)) { throw new KeyNotFoundException(String.Format(CultureInfo.CurrentCulture, "Key '{0}'({1} type) does not exist in this dictionary.", key, key.UnderlyingType)); } return(result); } set { if (key.IsNil) { ThrowKeyNotNilException("key"); } this.VerifyIsNotFrozen(); Contract.EndContractBlock(); this.AssertInvariant(); this.AddCore(key, value, true); } }
/// <summary> /// Packs <see cref="Byte"/> value to current stream asynchronously. /// </summary> /// <param name="value"><see cref="Byte"/> value.</param> /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param> /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns> /// <exception cref="ObjectDisposedException">This instance has been disposed.</exception> public Task PackAsync(byte value, CancellationToken cancellationToken) { this.VerifyNotDisposed(); Contract.EndContractBlock(); return(this.PrivatePackAsyncCore(value, cancellationToken)); }
/// <summary> /// Packs <see cref="Byte"/> value to current stream. /// </summary> /// <param name="value"><see cref="Byte"/> value.</param> /// <returns>This instance.</returns> /// <exception cref="ObjectDisposedException">This instance has been disposed.</exception> public Packer Pack(byte value) { this.VerifyNotDisposed(); Contract.EndContractBlock(); this.PrivatePackCore(value); return(this); }
/// <summary> /// Packs a null value to current stream. /// </summary> /// <returns>This instance.</returns> /// <exception cref="ObjectDisposedException">This instance has been disposed.</exception> public Packer PackNull() { this.VerifyNotDisposed(); Contract.EndContractBlock(); this.PrivatePackNullCore(); return(this); }
public static void UnpackCollectionTo <T>(Unpacker unpacker, MessagePackSerializer <T> serializer, IEnumerable <T> collection, Action <T> addition) { if (unpacker == null) { throw new ArgumentNullException("unpacker"); } if (serializer == null) { throw new ArgumentNullException("serializer"); } if (collection == null) { throw new ArgumentNullException("collection"); } if (addition == null) { throw new ArgumentNullException("addition"); } if (!unpacker.IsArrayHeader) { throw SerializationExceptions.NewIsNotArrayHeader(); } #if !UNITY Contract.EndContractBlock(); #endif // !UNITY int count = GetItemsCount(unpacker); for (int i = 0; i < count; i++) { if (!unpacker.Read()) { throw SerializationExceptions.NewMissingItem(i); } T item; if (!unpacker.IsArrayHeader && !unpacker.IsMapHeader) { item = serializer.UnpackFrom(unpacker); } else { using (Unpacker subtreeUnpacker = unpacker.ReadSubtree()) { item = serializer.UnpackFrom(subtreeUnpacker); } } addition(item); } }
public static void UnpackCollectionTo <TDiscarded>(Unpacker unpacker, IEnumerable collection, Func <object, TDiscarded> addition) { if (unpacker == null) { SerializationExceptions.ThrowArgumentNullException("unpacker"); } if (collection == null) { SerializationExceptions.ThrowArgumentNullException("collection"); } if (addition == null) { SerializationExceptions.ThrowArgumentNullException("addition"); } #if ASSERT Contract.Assert(unpacker != null); Contract.Assert(collection != null); Contract.Assert(addition != null); #endif // ASSERT if (!unpacker.IsArrayHeader) { SerializationExceptions.ThrowIsNotArrayHeader(unpacker); } #if ASSERT Contract.EndContractBlock(); #endif // ASSERT int count = GetItemsCount(unpacker); for (int i = 0; i < count; i++) { if (!unpacker.Read()) { SerializationExceptions.ThrowMissingItem(i, unpacker); } MessagePackObject item; if (!unpacker.IsArrayHeader && !unpacker.IsMapHeader) { item = _messagePackObjectSerializer.UnpackFrom(unpacker); } else { using (Unpacker subtreeUnpacker = unpacker.ReadSubtree()) { item = _messagePackObjectSerializer.UnpackFrom(subtreeUnpacker); } } addition(item); } }
public static void UnpackArrayTo <T>(Unpacker unpacker, MessagePackSerializer <T> serializer, T[] array) { if (unpacker == null) { SerializationExceptions.ThrowArgumentNullException("unpacker"); } if (serializer == null) { SerializationExceptions.ThrowArgumentNullException("serializer"); } if (array == null) { SerializationExceptions.ThrowArgumentNullException("array"); } #if ASSERT Contract.Assert(unpacker != null); Contract.Assert(serializer != null); Contract.Assert(array != null); #endif // ASSERT if (!unpacker.IsArrayHeader) { SerializationExceptions.ThrowIsNotArrayHeader(unpacker); } #if ASSERT Contract.EndContractBlock(); #endif // ASSERT int count = GetItemsCount(unpacker); for (int i = 0; i < count; i++) { if (!unpacker.Read()) { SerializationExceptions.ThrowMissingItem(i, unpacker); } T item; if (!unpacker.IsArrayHeader && !unpacker.IsMapHeader) { item = serializer.UnpackFrom(unpacker); } else { using (Unpacker subtreeUnpacker = unpacker.ReadSubtree()) { item = serializer.UnpackFrom(subtreeUnpacker); } } array[i] = item; } }
/// <summary> /// Unpacks raw value from the specified <see cref="Stream"/> as <see cref="UnpackingStream"/>. /// </summary> /// <param name="source">The <see cref="Stream"/> which contains Message Pack binary stream.</param> /// <returns> /// The <see cref="UnpackingStream"/> which represents raw value stream. /// </returns> /// <exception cref="ArgumentNullException"> /// <paramref name="source"/> is <c>null</c>. /// </exception> /// <exception cref="ArgumentException"> /// The <see cref="P:Stream.CanRead"/> of <paramref name="source"/> is <c>false</c>. /// </exception> /// <exception cref="UnpackException"> /// <paramref name="source"/> is not valid MessagePack stream. /// Note that the state of <paramref name="source"/> will be unpredictable espicially it is not seekable. /// </exception> /// <exception cref="MessageTypeException"> /// The unpacked result in the <paramref name="source"/> is not raw binary. /// Note that the state of <paramref name="source"/> will be unpredictable espicially it is not seekable. /// </exception> /// <remarks> /// <para> /// <see cref="UnpackingStream"/> does not own <paramref name="source"/>, so <paramref name="source"/> still should be closed. /// </para> /// <para> /// When the type of packed value is not known, use <see cref="UnpackObject(Stream)"/> instead. /// </para> /// </remarks> public static UnpackingStream UnpackByteStream(Stream source) { ValidateStream(source); #if !UNITY Contract.EndContractBlock(); #endif // !UNITY return(UnpackByteStreamCore(source)); }
/// <summary> /// Encode specified string by default encoding. /// </summary> /// <param name="value">String value.</param> /// <returns>Encoded <paramref name="value"/>.</returns> /// <exception cref="ArgumentNullException"> /// <paramref name="value"/> is null. /// </exception> public static byte[] EncodeString(string value) { if (value == null) { throw new ArgumentNullException("value"); } Contract.EndContractBlock(); return(_utf8NonBom.GetBytes(value)); }
/// <summary> /// Decode specified byte[] by default encoding. /// </summary> /// <param name="value">Byte[] value.</param> /// <returns>Decoded <paramref name="value"/>.</returns> /// <exception cref="ArgumentNullException"> /// <paramref name="value"/> is null. /// </exception> /// <exception cref="System.Text.DecoderFallbackException"> /// <paramref name="value"/> contains non-UTF-8 bits. /// </exception> public static string DecodeStringStrict(byte[] value) { if (value == null) { throw new ArgumentNullException("value"); } Contract.EndContractBlock(); return(_utf8NonBomStrict.GetString(value, 0, value.Length)); }
/// <summary> /// Copies the entire collection to a compatible one-dimensional array, starting at the beginning of the target array. /// </summary> /// <param name="array"> /// The one-dimensional <see cref="Array"/> that is the destination of the elements copied from this dictionary. /// The <see cref="Array"/> must have zero-based indexing. /// </param> public void CopyTo(MessagePackObject[] array) { if (array == null) { throw new ArgumentNullException("array"); } Contract.EndContractBlock(); CollectionOperation.CopyTo(this, this.Count, 0, array, 0, this.Count); }
void ICollection <KeyValuePair <MessagePackObject, MessagePackObject> > .Add(KeyValuePair <MessagePackObject, MessagePackObject> item) { if (item.Key.IsNil) { ThrowKeyNotNilException("key"); } this.VerifyIsNotFrozen(); Contract.EndContractBlock(); this.AddCore(item.Key, item.Value, false); }
/// <summary> /// Removes the element with the specified key from the <see cref="MessagePackObjectDictionary"/>. /// </summary> /// <param name="key">The key of the element to remove.</param> /// <returns> /// <c>true</c> if the element is successfully removed; otherwise, <c>false</c>. /// This method also returns false if <paramref name="key"/> was not found in the original <see cref="MessagePackObjectDictionary"/>. /// </returns> /// <exception cref="ArgumentNullException"> /// <paramref name="key"/> is <see cref="MessagePackObject.Nil"/>. /// </exception> /// <remarks> /// This method approaches an O(1) operation. /// </remarks> public bool Remove(MessagePackObject key) { if (key.IsNil) { ThrowKeyNotNilException("key"); } this.VerifyIsNotFrozen(); Contract.EndContractBlock(); return(this.RemoveCore(key, default(MessagePackObject), false)); }
/// <summary> /// Adds the specified key and value to the dictionary. /// </summary> /// <param name="key"> /// The key of the element to add. /// </param> /// <param name="value"> /// The value of the element to add. The value can be <c>null</c> for reference types. /// </param> /// <returns> /// An element with the same key already does not exist in the dictionary and sucess to add then newly added node; /// otherwise <c>null</c>. /// </returns> /// <exception cref="ArgumentException"> /// <paramref name="key"/> already exists in this dictionary. /// Note that tiny integers are considered equal regardless of its CLI <see cref="Type"/>, /// and UTF-8 encoded bytes are considered equals to <see cref="String"/>. /// </exception> /// <exception cref="ArgumentNullException"> /// <paramref name="key"/> is <see cref="MessagePackObject.Nil"/>. /// </exception> /// <remarks> /// If <see cref="Count"/> is less than the capacity, this method approaches an O(1) operation. /// If the capacity must be increased to accommodate the new element, /// this method becomes an O(<em>N</em>) operation, where <em>N</em> is <see cref="Count"/>. /// </remarks> public void Add(MessagePackObject key, MessagePackObject value) { if (key.IsNil) { ThrowKeyNotNilException("key"); } this.VerifyIsNotFrozen(); Contract.EndContractBlock(); this.AddCore(key, value, false); }
bool ICollection <KeyValuePair <MessagePackObject, MessagePackObject> > .Remove(KeyValuePair <MessagePackObject, MessagePackObject> item) { if (item.Key.IsNil) { ThrowKeyNotNilException("key"); } this.VerifyIsNotFrozen(); Contract.EndContractBlock(); return(this.RemoveCore(item.Key, item.Value, true)); }
object IDictionary.this[object key] { get { if (key == null) { throw new ArgumentNullException("key"); } #if !UNITY Contract.EndContractBlock(); #endif // !UNITY var typedKey = ValidateObjectArgument(key, "key"); if (typedKey.IsNil) { ThrowKeyNotNilException("key"); } MessagePackObject value; if (!this.TryGetValue(typedKey, out value)) { return(null); } return(value); } set { if (key == null) { throw new ArgumentNullException("key"); } this.VerifyIsNotFrozen(); #if !UNITY Contract.EndContractBlock(); #endif // !UNITY var typedKey = ValidateObjectArgument(key, "key"); if (typedKey.IsNil) { ThrowKeyNotNilException("key"); } this[typedKey] = ValidateObjectArgument(value, "value"); } }
/// <summary> /// Unpacks specified type value with the default context. /// </summary> /// <typeparam name="T">The type of the value.</typeparam> /// <param name="source">The <see cref="Unpacker"/>.</param> /// <returns>The deserialized value.</returns> /// <exception cref="ArgumentNullException"> /// <paramref name="source"/> is <c>null</c>. /// </exception> /// <exception cref="System.Runtime.Serialization.SerializationException"> /// Cannot deserialize <typeparamref name="T"/> value. /// </exception> public static T Unpack <T>(this Unpacker source) { if (source == null) { throw new ArgumentNullException("source"); } #if !UNITY Contract.EndContractBlock(); #endif // !UNITY return(UnpackCore <T>(source, new SerializationContext())); }
protected virtual void WriteBytes(byte[] value, bool isImmutable) { if (value == null) { ThrowArgumentNullException("value"); } Contract.EndContractBlock(); // ReSharper disable once PossibleNullReferenceException foreach (var b in value) { this.WriteByte(b); } }
/// <summary> /// Unpacks raw value from the specified <see cref="Stream"/> as <see cref="UnpackingStreamReader"/> with specified encoding. /// </summary> /// <param name="source">The <see cref="Stream"/> which contains Message Pack binary stream.</param> /// <param name="encoding">The <see cref="Encoding"/> to decode binary stream.</param> /// <returns> /// The <see cref="UnpackingStreamReader"/> which represents raw value stream as UTF-8 string. /// </returns> /// <exception cref="ArgumentNullException"> /// <paramref name="source"/> is <c>null</c>. /// Or, <paramref name="encoding"/> is <c>null</c>. /// </exception> /// <exception cref="ArgumentException"> /// The <see cref="P:Stream.CanRead"/> of <paramref name="source"/> is <c>false</c>. /// </exception> /// <exception cref="UnpackException"> /// <paramref name="source"/> is not valid MessagePack stream. /// Note that the state of <paramref name="source"/> will be unpredictable espicially it is not seekable. /// </exception> /// <exception cref="MessageTypeException"> /// The unpacked result in the <paramref name="source"/> is not raw binary. /// Note that the state of <paramref name="source"/> will be unpredictable espicially it is not seekable. /// </exception> /// <remarks> /// <para> /// if <paramref name="source"/> contains invalid sequence as specified encoding string, /// the <see cref="DecoderFallbackException"/> may occurs on read char. /// </para> /// <para> /// <see cref="UnpackingStreamReader"/> does not own <paramref name="source"/>, so <paramref name="source"/> still should be closed. /// </para> /// <para> /// When the type of packed value is not known, use <see cref="UnpackObject(Stream)"/> instead. /// </para> /// </remarks> public static UnpackingStreamReader UnpackCharStream(Stream source, Encoding encoding) { ValidateStream(source); if (encoding == null) { throw new ArgumentNullException("encoding"); } Contract.EndContractBlock(); var stream = UnpackByteStreamCore(source); return(new DefaultUnpackingStreamReader(stream, encoding, stream.RawLength)); }
/// <summary> /// Determines whether the <see cref="MessagePackObjectDictionary"/> contains an element with the specified key. /// </summary> /// <param name="key">The key to locate in the <see cref="MessagePackObjectDictionary"/>.</param> /// <exception cref="ArgumentNullException"> /// <paramref name="key"/> is <see cref="MessagePackObject.Nil"/>. /// </exception> /// <returns> /// <c>true</c> if the <see cref="MessagePackObjectDictionary"/> contains an element with the key; otherwise, <c>false</c>. /// </returns> /// <remarks> /// This method approaches an O(1) operation. /// </remarks> public bool ContainsKey(MessagePackObject key) { if (key.IsNil) { ThrowKeyNotNilException("key"); } Contract.EndContractBlock(); this.AssertInvariant(); return (this._dictionary == null ? this._keys.Contains(key, MessagePackObjectEqualityComparer.Instance) : this._dictionary.ContainsKey(key)); }
/// <summary> /// Packs specified value with the default context. /// </summary> /// <typeparam name="T">The type of the value.</typeparam> /// <param name="source">The <see cref="Packer"/>.</param> /// <param name="value">The value to be serialized.</param> /// <returns><paramref name="source"/>.</returns> /// <exception cref="ArgumentNullException"> /// <paramref name="source"/> is <c>null</c>. /// </exception> /// <exception cref="System.Runtime.Serialization.SerializationException"> /// Cannot serialize <paramref name="value"/>. /// </exception> public static Packer Pack <T>(this Packer source, T value) { if (source == null) { throw new ArgumentNullException("source"); } #if !UNITY Contract.EndContractBlock(); #endif // !UNITY PackCore(source, value, SerializationContext.Default); return(source); }
/// <summary> /// Writes specified bytes to stream using implementation specific most efficient manner asynchronously. /// </summary> /// <param name="value">Bytes to be written.</param> /// <param name="isImmutable">If the <paramref name="value"/> can be treat as immutable (that is, can be used safely without copying) then <c>true</c>.</param> /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param> /// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns> protected virtual async Task WriteBytesAsync(byte[] value, bool isImmutable, CancellationToken cancellationToken) { if (value == null) { ThrowArgumentNullException("value"); } Contract.EndContractBlock(); // ReSharper disable once PossibleNullReferenceException foreach (var b in value) { await this.WriteByteAsync(b, cancellationToken).ConfigureAwait(false); } }
/// <summary> /// Unpacks <see cref="String" /> value from specified offsetted byte array with specified encoding. /// </summary> /// <param name="source">The byte array which contains Message Pack binary stream.</param> /// <param name="offset">The offset to be unpacking start with.</param> /// <param name="encoding">The <see cref="Encoding"/> to decode binary stream.</param> /// <returns> /// The <see cref="UnpackingResult{T}"/> of <see cref="String" /> which contains unpacked <see cref="String" /> value and processed bytes count. /// </returns> /// <exception cref="ArgumentNullException"> /// <paramref name="source"/> is <c>null</c>. /// Or, <paramref name="encoding"/> is <c>null</c>. /// </exception> /// <exception cref="ArgumentException"> /// <paramref name="source"/> is empty. /// Or, the length of <paramref name="source"/> is not greater than <paramref name="offset"/>. /// </exception> /// <exception cref="ArgumentOutOfRangeException"> /// <paramref name="offset"/> is negative value. /// </exception> /// <exception cref="UnpackException"> /// <paramref name="source"/> is not valid MessagePack stream. /// </exception> /// <exception cref="MessageTypeException"> /// The unpacked result in the <paramref name="source"/> is not compatible to <see cref="String" />. /// Or, the unpacked result in the <paramref name="source"/> is invalid as specified encoding byte stream. /// </exception> /// <remarks> /// <para> /// Invocation of this method is equivalant to call <see cref="UnpackString(byte[], int)"/> with <c>offset</c> is <c>0</c>. /// </para> /// <para> /// When the type of packed value is not known, use <see cref="UnpackObject(byte[])"/> instead. /// </para> /// </remarks> public static UnpackingResult <string> UnpackString(byte[] source, int offset, Encoding encoding) { if (encoding == null) { throw new ArgumentNullException("encoding"); } Contract.EndContractBlock(); try { var result = UnpackBinary(source, offset); return(new UnpackingResult <string>(encoding.GetString(result.Value, 0, result.Value.Length), result.ReadCount)); } catch (DecoderFallbackException ex) { throw NewInvalidEncodingException(encoding, ex); } }
/// <summary> /// Unpacks <see cref="String"/> value from the specified <see cref="Stream"/> with specified encoding. /// </summary> /// <param name="source">The <see cref="Stream"/> which contains Message Pack binary stream.</param> /// <param name="encoding">The <see cref="Encoding"/> to decode binary stream.</param> /// <returns> /// The unpacked <see cref="String"/> value. /// </returns> /// <exception cref="ArgumentNullException"> /// <paramref name="source"/> is <c>null</c>. /// Or <paramref name="encoding"/> is <c>null</c>. /// </exception> /// <exception cref="ArgumentException"> /// The <see cref="P:Stream.CanRead"/> of <paramref name="source"/> is <c>false</c>. /// </exception> /// <exception cref="UnpackException"> /// <paramref name="source"/> is not valid MessagePack stream. /// Note that the state of <paramref name="source"/> will be unpredictable espicially it is not seekable. /// </exception> /// <exception cref="MessageTypeException"> /// The unpacked result in the <paramref name="source"/> is not raw binary. /// Or, the unpacked result in the <paramref name="source"/> is invalid as specified encoding byte stream. /// Note that the state of <paramref name="source"/> will be unpredictable espicially it is not seekable. /// </exception> /// <remarks> /// <para> /// The processed bytes count can be calculated via <see cref="P:Stream.Position"/> of <paramref name="source"/> when the <see cref="P:Stream.CanSeek" /> is <c>true</c>. /// </para> /// <para> /// When the type of packed value is not known, use <see cref="UnpackObject(Stream)"/> instead. /// </para> /// </remarks> public static string UnpackString(Stream source, Encoding encoding) { if (encoding == null) { throw new ArgumentNullException("encoding"); } Contract.EndContractBlock(); try { var result = UnpackBinary(source); return(encoding.GetString(result, 0, result.Length)); } catch (DecoderFallbackException ex) { throw NewInvalidEncodingException(encoding, ex); } }
/// <summary> /// Initializes an empty new instance of the <see cref="MessagePackObjectDictionary"/> class with specified initial capacity. /// </summary> /// <param name="initialCapacity">The initial capacity.</param> /// <exception cref="ArgumentOutOfRangeException"> /// <paramref name="initialCapacity"/> is negative. /// </exception> /// <remarks> /// This operation is an O(1) operation. /// </remarks> public MessagePackObjectDictionary(int initialCapacity) { if (initialCapacity < 0) { throw new ArgumentOutOfRangeException("initialCapacity"); } Contract.EndContractBlock(); if (initialCapacity <= Threashold) { this._keys = new List <MessagePackObject>(initialCapacity); this._values = new List <MessagePackObject>(initialCapacity); } else { this._dictionary = new Dictionary <MessagePackObject, MessagePackObject>(initialCapacity, MessagePackObjectEqualityComparer.Instance); } }