#region -- License Terms --

//

// MessagePack for CLI

//

// Copyright (C) 2010-2016 FUJIWARA, Yusuke

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

// http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

//

#endregion -- License Terms --

#if UNITY_STANDALONE || UNITY_WEBPLAYER || UNITY_WII || UNITY_IPHONE || UNITY_ANDROID || UNITY_PS3 || UNITY_XBOX360 || UNITY_FLASH || UNITY_BKACKBERRY || UNITY_WINRT

#define UNITY

#endif

using System;

using System.Collections.Generic;

#if CORE_CLR || UNITY

using Contract = MsgPack.MPContract;

#else

using System.Diagnostics.Contracts;

#endif // CORE_CLR || UNITY

using System.Linq;

using System.Text;

#if FEATURE_TAP

using System.Threading;

using System.Threading.Tasks;

#endif // FEATURE_TAP

namespace MsgPack

{

// This file was generated from Packer.Packing.tt and StreamingUnapkcerBase.ttinclude T4Template.

// Do not modify this file. Edit Packer.Packing.tt and StreamingUnapkcerBase.ttinclude instead.

[System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Maintainability", "CA1506:AvoidExcessiveClassCoupling", Justification = "AsyncResult<T>" )]

partial class Packer

{

#region -- Int16 --

/// <summary>

/// Packs <see cref="Int16"/> value to current stream.

/// </summary>

/// <param name="value"><see cref="Int16"/> value.</param>

/// <returns>This instance.</returns>

/// <exception cref="ObjectDisposedException">This instance has been disposed.</exception>

public Packer Pack( Int16 value )

{

this.VerifyNotDisposed();

Contract.EndContractBlock();

this.PrivatePackCore( value );

return this;

}

private void PrivatePackCore( Int16 value )

{

if ( this.TryPackTinySignedInteger( value ) )

{

return;

}

if ( this.TryPackInt8( value ) )

{

return;

}

#pragma warning disable 168

var b = this.TryPackInt16( value );

#pragma warning restore 168

Contract.Assert( b, "success" );

}

/// <summary>

/// Try packs <see cref="Int16"/> value to current stream strictly.

/// </summary>

/// <param name="value">Maybe <see cref="Int16"/> value.</param>

/// <returns>If <paramref name="value"/> has be packed successfully then true, otherwise false (normally, larger type required).</returns>

protected bool TryPackInt16( Int64 value )

{

if ( value < Int16.MinValue || value > Int16.MaxValue )

{

return false;

}

this.WriteByte( MessagePackCode.SignedInt16 );

unchecked

{

this.WriteByte( ( byte )( ( value >> 8 ) & 0xFF ) );

this.WriteByte( ( byte )( value & 0xFF ) );

}

return true;

}

#if FEATURE_TAP

/// <summary>

/// Packs <see cref="Int16"/> value to current stream asynchronously.

/// </summary>

/// <param name="value"><see cref="Int16"/> value.</param>

/// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>

/// <exception cref="ObjectDisposedException">This instance has been disposed.</exception>

public Task PackAsync( Int16 value )

{

return this.PackAsync( value, CancellationToken.None );

}

/// <summary>

/// Packs <see cref="Int16"/> value to current stream asynchronously.

/// </summary>

/// <param name="value"><see cref="Int16"/> 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( Int16 value, CancellationToken cancellationToken )

{

this.VerifyNotDisposed();

Contract.EndContractBlock();

return this.PrivatePackAsyncCore( value, cancellationToken );

}

private async Task PrivatePackAsyncCore( Int16 value, CancellationToken cancellationToken )

{

if ( await this.TryPackTinySignedIntegerAsync( value, cancellationToken ).ConfigureAwait( false ) )

{

return;

}

if ( await this.TryPackInt8Async( value, cancellationToken ).ConfigureAwait( false ) )

{

return;

}

#pragma warning disable 168

var b = await this.TryPackInt16Async( value, cancellationToken ).ConfigureAwait( false );

#pragma warning restore 168

Contract.Assert( b, "success" );

}

/// <summary>

/// Try packs <see cref="Int16"/> value to current stream strictly asynchronously.

/// </summary>

/// <param name="value">Maybe <see cref="Int16"/> value.</param>

/// <returns>

/// A <see cref="Task"/> that represents the asynchronous operation.

/// The value of the <c>TResult</c> parameter contains the value

/// whether <paramref name="value"/> has be packed successfully or not(normally, larger type required).

/// </returns>

protected Task<bool> TryPackInt16Async( Int64 value )

{

return this.TryPackInt16Async( value, CancellationToken.None );

}

/// <summary>

/// Try packs <see cref="Int16"/> value to current stream strictly asynchronously.

/// </summary>

/// <param name="value">Maybe <see cref="Int16"/> 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.

/// The value of the <c>TResult</c> parameter contains the value

/// whether <paramref name="value"/> has be packed successfully or not(normally, larger type required).

/// </returns>

protected async Task<bool> TryPackInt16Async( Int64 value, CancellationToken cancellationToken )

{

if ( value < Int16.MinValue || value > Int16.MaxValue )

{

return false;

}

await this.WriteByteAsync( MessagePackCode.SignedInt16 ).ConfigureAwait( false );

unchecked

{

await this.WriteByteAsync( ( byte )( ( value >> 8 ) & 0xFF ), cancellationToken ).ConfigureAwait( false );

await this.WriteByteAsync( ( byte )( value & 0xFF ), cancellationToken ).ConfigureAwait( false );

}

return true;

}

#endif // FEATURE_TAP

#endregion -- Int16 --

#region -- UInt16 --

/// <summary>

/// Packs <see cref="UInt16"/> value to current stream.

/// </summary>

/// <param name="value"><see cref="UInt16"/> value.</param>

/// <returns>This instance.</returns>

/// <exception cref="ObjectDisposedException">This instance has been disposed.</exception>

[CLSCompliant( false )]

public Packer Pack( UInt16 value )

{

this.VerifyNotDisposed();

Contract.EndContractBlock();

this.PrivatePackCore( value );

return this;

}

private void PrivatePackCore( UInt16 value )

{

if ( this.TryPackTinyUnsignedInteger( value ) )

{

return;

}

if ( this.TryPackUInt8( value ) )

{

return;

}

#pragma warning disable 168

var b = this.TryPackUInt16( value );

#pragma warning restore 168

Contract.Assert( b, "success" );

}

/// <summary>

/// Try packs <see cref="UInt16"/> value to current stream strictly.

/// </summary>

/// <param name="value">Maybe <see cref="UInt16"/> value.</param>

/// <returns>If <paramref name="value"/> has be packed successfully then true, otherwise false (normally, larger type required).</returns>

[CLSCompliant( false )]

protected bool TryPackUInt16( UInt64 value )

{

if ( value > UInt16.MaxValue )

{

return false;

}

this.WriteByte( MessagePackCode.UnsignedInt16 );

unchecked

{

this.WriteByte( ( byte )( ( value >> 8 ) & 0xFF ) );

this.WriteByte( ( byte )( value & 0xFF ) );

}

return true;

}

#if FEATURE_TAP

/// <summary>

/// Packs <see cref="UInt16"/> value to current stream asynchronously.

/// </summary>

/// <param name="value"><see cref="UInt16"/> value.</param>

/// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>

/// <exception cref="ObjectDisposedException">This instance has been disposed.</exception>

[CLSCompliant( false )]

public Task PackAsync( UInt16 value )

{

return this.PackAsync( value, CancellationToken.None );

}

/// <summary>

/// Packs <see cref="UInt16"/> value to current stream asynchronously.

/// </summary>

/// <param name="value"><see cref="UInt16"/> 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>

[CLSCompliant( false )]

public Task PackAsync( UInt16 value, CancellationToken cancellationToken )

{

this.VerifyNotDisposed();

Contract.EndContractBlock();

return this.PrivatePackAsyncCore( value, cancellationToken );

}

private async Task PrivatePackAsyncCore( UInt16 value, CancellationToken cancellationToken )

{

if ( await this.TryPackTinyUnsignedIntegerAsync( value, cancellationToken ).ConfigureAwait( false ) )

{

return;

}

if ( await this.TryPackUInt8Async( value, cancellationToken ).ConfigureAwait( false ) )

{

return;

}

#pragma warning disable 168

var b = await this.TryPackUInt16Async( value, cancellationToken ).ConfigureAwait( false );

#pragma warning restore 168

Contract.Assert( b, "success" );

}

/// <summary>

/// Try packs <see cref="UInt16"/> value to current stream strictly asynchronously.

/// </summary>

/// <param name="value">Maybe <see cref="UInt16"/> value.</param>

/// <returns>

/// A <see cref="Task"/> that represents the asynchronous operation.

/// The value of the <c>TResult</c> parameter contains the value

/// whether <paramref name="value"/> has be packed successfully or not(normally, larger type required).

/// </returns>

[CLSCompliant( false )]

protected Task<bool> TryPackUInt16Async( UInt64 value )

{

return this.TryPackUInt16Async( value, CancellationToken.None );

}

/// <summary>

/// Try packs <see cref="UInt16"/> value to current stream strictly asynchronously.

/// </summary>

/// <param name="value">Maybe <see cref="UInt16"/> 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.

/// The value of the <c>TResult</c> parameter contains the value

/// whether <paramref name="value"/> has be packed successfully or not(normally, larger type required).

/// </returns>

[CLSCompliant( false )]

protected async Task<bool> TryPackUInt16Async( UInt64 value, CancellationToken cancellationToken )

{

if ( value > UInt16.MaxValue )

{

return false;

}

await this.WriteByteAsync( MessagePackCode.UnsignedInt16 ).ConfigureAwait( false );

unchecked

{

await this.WriteByteAsync( ( byte )( ( value >> 8 ) & 0xFF ), cancellationToken ).ConfigureAwait( false );

await this.WriteByteAsync( ( byte )( value & 0xFF ), cancellationToken ).ConfigureAwait( false );

}

return true;

}

#endif // FEATURE_TAP

#endregion -- UInt16 --

#region -- Int32 --

/// <summary>

/// Packs <see cref="Int32"/> value to current stream.

/// </summary>

/// <param name="value"><see cref="Int32"/> value.</param>

/// <returns>This instance.</returns>

/// <exception cref="ObjectDisposedException">This instance has been disposed.</exception>

public Packer Pack( Int32 value )

{

this.VerifyNotDisposed();

Contract.EndContractBlock();

this.PrivatePackCore( value );

return this;

}

private void PrivatePackCore( Int32 value )

{

if ( this.TryPackTinySignedInteger( value ) )

{

return;

}

if ( this.TryPackInt8( value ) )

{

return;

}

if ( this.TryPackInt16( value ) )

{

return;

}

#pragma warning disable 168

var b = this.TryPackInt32( value );

#pragma warning restore 168

Contract.Assert( b, "success" );

}

/// <summary>

/// Try packs <see cref="Int32"/> value to current stream strictly.

/// </summary>

/// <param name="value">Maybe <see cref="Int32"/> value.</param>

/// <returns>If <paramref name="value"/> has be packed successfully then true, otherwise false (normally, larger type required).</returns>

protected bool TryPackInt32( Int64 value )

{

if ( value < Int32.MinValue || value > Int32.MaxValue )

{

return false;

}

this.WriteByte( MessagePackCode.SignedInt32 );

unchecked

{

this.WriteByte( ( byte )( ( value >> 24 ) & 0xFF ) );

this.WriteByte( ( byte )( ( value >> 16 ) & 0xFF ) );

this.WriteByte( ( byte )( ( value >> 8 ) & 0xFF ) );

this.WriteByte( ( byte )( value & 0xFF ) );

}

return true;

}

#if FEATURE_TAP

/// <summary>

/// Packs <see cref="Int32"/> value to current stream asynchronously.

/// </summary>

/// <param name="value"><see cref="Int32"/> value.</param>

/// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>

/// <exception cref="ObjectDisposedException">This instance has been disposed.</exception>

public Task PackAsync( Int32 value )

{

return this.PackAsync( value, CancellationToken.None );

}

/// <summary>

/// Packs <see cref="Int32"/> value to current stream asynchronously.

/// </summary>

/// <param name="value"><see cref="Int32"/> 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( Int32 value, CancellationToken cancellationToken )

{

this.VerifyNotDisposed();

Contract.EndContractBlock();

return this.PrivatePackAsyncCore( value, cancellationToken );

}

private async Task PrivatePackAsyncCore( Int32 value, CancellationToken cancellationToken )

{

if ( await this.TryPackTinySignedIntegerAsync( value, cancellationToken ).ConfigureAwait( false ) )

{

return;

}

if ( await this.TryPackInt8Async( value, cancellationToken ).ConfigureAwait( false ) )

{

return;

}

if ( await this.TryPackInt16Async( value, cancellationToken ).ConfigureAwait( false ) )

{

return;

}

#pragma warning disable 168

var b = await this.TryPackInt32Async( value, cancellationToken ).ConfigureAwait( false );

#pragma warning restore 168

Contract.Assert( b, "success" );

}

/// <summary>

/// Try packs <see cref="Int32"/> value to current stream strictly asynchronously.

/// </summary>

/// <param name="value">Maybe <see cref="Int32"/> value.</param>

/// <returns>

/// A <see cref="Task"/> that represents the asynchronous operation.

/// The value of the <c>TResult</c> parameter contains the value

/// whether <paramref name="value"/> has be packed successfully or not(normally, larger type required).

/// </returns>

protected Task<bool> TryPackInt32Async( Int64 value )

{

return this.TryPackInt32Async( value, CancellationToken.None );

}

/// <summary>

/// Try packs <see cref="Int32"/> value to current stream strictly asynchronously.

/// </summary>

/// <param name="value">Maybe <see cref="Int32"/> 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.

/// The value of the <c>TResult</c> parameter contains the value

/// whether <paramref name="value"/> has be packed successfully or not(normally, larger type required).

/// </returns>

protected async Task<bool> TryPackInt32Async( Int64 value, CancellationToken cancellationToken )

{

if ( value < Int32.MinValue || value > Int32.MaxValue )

{

return false;

}

await this.WriteByteAsync( MessagePackCode.SignedInt32 ).ConfigureAwait( false );

unchecked

{

await this.WriteByteAsync( ( byte )( ( value >> 24 ) & 0xFF ), cancellationToken ).ConfigureAwait( false );

await this.WriteByteAsync( ( byte )( ( value >> 16 ) & 0xFF ), cancellationToken ).ConfigureAwait( false );

await this.WriteByteAsync( ( byte )( ( value >> 8 ) & 0xFF ), cancellationToken ).ConfigureAwait( false );

await this.WriteByteAsync( ( byte )( value & 0xFF ), cancellationToken ).ConfigureAwait( false );

}

return true;

}

#endif // FEATURE_TAP

#endregion -- Int32 --

#region -- UInt32 --

/// <summary>

/// Packs <see cref="UInt32"/> value to current stream.

/// </summary>

/// <param name="value"><see cref="UInt32"/> value.</param>

/// <returns>This instance.</returns>

/// <exception cref="ObjectDisposedException">This instance has been disposed.</exception>

[CLSCompliant( false )]

public Packer Pack( UInt32 value )

{

this.VerifyNotDisposed();

Contract.EndContractBlock();

this.PrivatePackCore( value );

return this;

}

private void PrivatePackCore( UInt32 value )

{

if ( this.TryPackTinyUnsignedInteger( value ) )

{

return;

}

if ( this.TryPackUInt8( value ) )

{

return;

}

if ( this.TryPackUInt16( value ) )

{

return;

}

#pragma warning disable 168

var b = this.TryPackUInt32( value );

#pragma warning restore 168

Contract.Assert( b, "success" );

}

/// <summary>

/// Try packs <see cref="UInt32"/> value to current stream strictly.

/// </summary>

/// <param name="value">Maybe <see cref="UInt32"/> value.</param>

/// <returns>If <paramref name="value"/> has be packed successfully then true, otherwise false (normally, larger type required).</returns>

[CLSCompliant( false )]

protected bool TryPackUInt32( UInt64 value )

{

if ( value > UInt32.MaxValue )

{

return false;

}

this.WriteByte( MessagePackCode.UnsignedInt32 );

unchecked

{

this.WriteByte( ( byte )( ( value >> 24 ) & 0xFF ) );

this.WriteByte( ( byte )( ( value >> 16 ) & 0xFF ) );

this.WriteByte( ( byte )( ( value >> 8 ) & 0xFF ) );

this.WriteByte( ( byte )( value & 0xFF ) );

}

return true;

}

#if FEATURE_TAP

/// <summary>

/// Packs <see cref="UInt32"/> value to current stream asynchronously.

/// </summary>

/// <param name="value"><see cref="UInt32"/> value.</param>

/// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>

/// <exception cref="ObjectDisposedException">This instance has been disposed.</exception>

[CLSCompliant( false )]

public Task PackAsync( UInt32 value )

{

return this.PackAsync( value, CancellationToken.None );

}

/// <summary>

/// Packs <see cref="UInt32"/> value to current stream asynchronously.

/// </summary>

/// <param name="value"><see cref="UInt32"/> 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>

[CLSCompliant( false )]

public Task PackAsync( UInt32 value, CancellationToken cancellationToken )

{

this.VerifyNotDisposed();

Contract.EndContractBlock();

return this.PrivatePackAsyncCore( value, cancellationToken );

}

private async Task PrivatePackAsyncCore( UInt32 value, CancellationToken cancellationToken )

{

if ( await this.TryPackTinyUnsignedIntegerAsync( value, cancellationToken ).ConfigureAwait( false ) )

{

return;

}

if ( await this.TryPackUInt8Async( value, cancellationToken ).ConfigureAwait( false ) )

{

return;

}

if ( await this.TryPackUInt16Async( value, cancellationToken ).ConfigureAwait( false ) )

{

return;

}

#pragma warning disable 168

var b = await this.TryPackUInt32Async( value, cancellationToken ).ConfigureAwait( false );

#pragma warning restore 168

Contract.Assert( b, "success" );

}

/// <summary>

/// Try packs <see cref="UInt32"/> value to current stream strictly asynchronously.

/// </summary>

/// <param name="value">Maybe <see cref="UInt32"/> value.</param>

/// <returns>

/// A <see cref="Task"/> that represents the asynchronous operation.

/// The value of the <c>TResult</c> parameter contains the value

/// whether <paramref name="value"/> has be packed successfully or not(normally, larger type required).

/// </returns>

[CLSCompliant( false )]

protected Task<bool> TryPackUInt32Async( UInt64 value )

{

return this.TryPackUInt32Async( value, CancellationToken.None );

}

/// <summary>

/// Try packs <see cref="UInt32"/> value to current stream strictly asynchronously.

/// </summary>

/// <param name="value">Maybe <see cref="UInt32"/> 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.

/// The value of the <c>TResult</c> parameter contains the value

/// whether <paramref name="value"/> has be packed successfully or not(normally, larger type required).

/// </returns>

[CLSCompliant( false )]

protected async Task<bool> TryPackUInt32Async( UInt64 value, CancellationToken cancellationToken )

{

if ( value > UInt32.MaxValue )

{

return false;

}

await this.WriteByteAsync( MessagePackCode.UnsignedInt32 ).ConfigureAwait( false );

unchecked

{

await this.WriteByteAsync( ( byte )( ( value >> 24 ) & 0xFF ), cancellationToken ).ConfigureAwait( false );

await this.WriteByteAsync( ( byte )( ( value >> 16 ) & 0xFF ), cancellationToken ).ConfigureAwait( false );

await this.WriteByteAsync( ( byte )( ( value >> 8 ) & 0xFF ), cancellationToken ).ConfigureAwait( false );

await this.WriteByteAsync( ( byte )( value & 0xFF ), cancellationToken ).ConfigureAwait( false );

}

return true;

}

#endif // FEATURE_TAP

#endregion -- UInt32 --

#region -- Int64 --

/// <summary>

/// Packs <see cref="Int64"/> value to current stream.

/// </summary>

/// <param name="value"><see cref="Int64"/> value.</param>

/// <returns>This instance.</returns>

/// <exception cref="ObjectDisposedException">This instance has been disposed.</exception>

public Packer Pack( Int64 value )

{

this.VerifyNotDisposed();

Contract.EndContractBlock();

this.PrivatePackCore( value );

return this;

}

private void PrivatePackCore( Int64 value )

{

if ( this.TryPackTinySignedInteger( value ) )

{

return;

}

if ( this.TryPackInt8( value ) )

{

return;

}

if ( this.TryPackInt16( value ) )

{

return;

}

if ( this.TryPackInt32( value ) )

{

return;

}

#pragma warning disable 168

var b = this.TryPackInt64( value );

#pragma warning restore 168

Contract.Assert( b, "success" );

}

/// <summary>

/// Try packs <see cref="Int64"/> value to current stream strictly.

/// </summary>

/// <param name="value">Maybe <see cref="Int64"/> value.</param>

/// <returns>If <paramref name="value"/> has be packed successfully then true, otherwise false (normally, larger type required).</returns>

protected bool TryPackInt64( Int64 value )

{

this.WriteByte( MessagePackCode.SignedInt64 );

unchecked

{

this.WriteByte( ( byte )( ( value >> 56 ) & 0xFF ) );

this.WriteByte( ( byte )( ( value >> 48 ) & 0xFF ) );

this.WriteByte( ( byte )( ( value >> 40 ) & 0xFF ) );

this.WriteByte( ( byte )( ( value >> 32 ) & 0xFF ) );

this.WriteByte( ( byte )( ( value >> 24 ) & 0xFF ) );

this.WriteByte( ( byte )( ( value >> 16 ) & 0xFF ) );

this.WriteByte( ( byte )( ( value >> 8 ) & 0xFF ) );

this.WriteByte( ( byte )( value & 0xFF ) );

}

return true;

}

#if FEATURE_TAP

/// <summary>

/// Packs <see cref="Int64"/> value to current stream asynchronously.

/// </summary>

/// <param name="value"><see cref="Int64"/> value.</param>

/// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>

/// <exception cref="ObjectDisposedException">This instance has been disposed.</exception>

public Task PackAsync( Int64 value )

{

return this.PackAsync( value, CancellationToken.None );

}

/// <summary>

/// Packs <see cref="Int64"/> value to current stream asynchronously.

/// </summary>

/// <param name="value"><see cref="Int64"/> 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( Int64 value, CancellationToken cancellationToken )

{

this.VerifyNotDisposed();

Contract.EndContractBlock();

return this.PrivatePackAsyncCore( value, cancellationToken );

}

private async Task PrivatePackAsyncCore( Int64 value, CancellationToken cancellationToken )

{

if ( await this.TryPackTinySignedIntegerAsync( value, cancellationToken ).ConfigureAwait( false ) )

{

return;

}

if ( await this.TryPackInt8Async( value, cancellationToken ).ConfigureAwait( false ) )

{

return;

}

if ( await this.TryPackInt16Async( value, cancellationToken ).ConfigureAwait( false ) )

{

return;

}

if ( await this.TryPackInt32Async( value, cancellationToken ).ConfigureAwait( false ) )

{

return;

}

#pragma warning disable 168

var b = await this.TryPackInt64Async( value, cancellationToken ).ConfigureAwait( false );

#pragma warning restore 168

Contract.Assert( b, "success" );

}

/// <summary>

/// Try packs <see cref="Int64"/> value to current stream strictly asynchronously.

/// </summary>

/// <param name="value">Maybe <see cref="Int64"/> value.</param>

/// <returns>

/// A <see cref="Task"/> that represents the asynchronous operation.

/// The value of the <c>TResult</c> parameter contains the value

/// whether <paramref name="value"/> has be packed successfully or not(normally, larger type required).

/// </returns>

protected Task<bool> TryPackInt64Async( Int64 value )

{

return this.TryPackInt64Async( value, CancellationToken.None );

}

/// <summary>

/// Try packs <see cref="Int64"/> value to current stream strictly asynchronously.

/// </summary>

/// <param name="value">Maybe <see cref="Int64"/> 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.

/// The value of the <c>TResult</c> parameter contains the value

/// whether <paramref name="value"/> has be packed successfully or not(normally, larger type required).

/// </returns>

protected async Task<bool> TryPackInt64Async( Int64 value, CancellationToken cancellationToken )

{

await this.WriteByteAsync( MessagePackCode.SignedInt64 ).ConfigureAwait( false );

unchecked

{

await this.WriteByteAsync( ( byte )( ( value >> 56 ) & 0xFF ), cancellationToken ).ConfigureAwait( false );

await this.WriteByteAsync( ( byte )( ( value >> 48 ) & 0xFF ), cancellationToken ).ConfigureAwait( false );

await this.WriteByteAsync( ( byte )( ( value >> 40 ) & 0xFF ), cancellationToken ).ConfigureAwait( false );

await this.WriteByteAsync( ( byte )( ( value >> 32 ) & 0xFF ), cancellationToken ).ConfigureAwait( false );

await this.WriteByteAsync( ( byte )( ( value >> 24 ) & 0xFF ), cancellationToken ).ConfigureAwait( false );

await this.WriteByteAsync( ( byte )( ( value >> 16 ) & 0xFF ), cancellationToken ).ConfigureAwait( false );

await this.WriteByteAsync( ( byte )( ( value >> 8 ) & 0xFF ), cancellationToken ).ConfigureAwait( false );

await this.WriteByteAsync( ( byte )( value & 0xFF ), cancellationToken ).ConfigureAwait( false );

}

return true;

}

#endif // FEATURE_TAP

#endregion -- Int64 --

#region -- UInt64 --

/// <summary>

/// Packs <see cref="UInt64"/> value to current stream.

/// </summary>

/// <param name="value"><see cref="UInt64"/> value.</param>

/// <returns>This instance.</returns>

/// <exception cref="ObjectDisposedException">This instance has been disposed.</exception>

[CLSCompliant( false )]

public Packer Pack( UInt64 value )

{

this.VerifyNotDisposed();

Contract.EndContractBlock();

this.PrivatePackCore( value );

return this;

}

private void PrivatePackCore( UInt64 value )

{

if ( this.TryPackTinyUnsignedInteger( value ) )

{

return;

}

if ( this.TryPackUInt8( value ) )

{

return;

}

if ( this.TryPackUInt16( value ) )

{

return;

}

if ( this.TryPackUInt32( value ) )

{

return;

}

#pragma warning disable 168

var b = this.TryPackUInt64( value );

#pragma warning restore 168

Contract.Assert( b, "success" );

}

/// <summary>

/// Try packs <see cref="UInt64"/> value to current stream strictly.

/// </summary>

/// <param name="value">Maybe <see cref="UInt64"/> value.</param>

/// <returns>If <paramref name="value"/> has be packed successfully then true, otherwise false (normally, larger type required).</returns>

[CLSCompliant( false )]

protected bool TryPackUInt64( UInt64 value )

{

this.WriteByte( MessagePackCode.UnsignedInt64 );

unchecked

{

this.WriteByte( ( byte )( ( value >> 56 ) & 0xFF ) );

this.WriteByte( ( byte )( ( value >> 48 ) & 0xFF ) );

this.WriteByte( ( byte )( ( value >> 40 ) & 0xFF ) );

this.WriteByte( ( byte )( ( value >> 32 ) & 0xFF ) );

this.WriteByte( ( byte )( ( value >> 24 ) & 0xFF ) );

this.WriteByte( ( byte )( ( value >> 16 ) & 0xFF ) );

this.WriteByte( ( byte )( ( value >> 8 ) & 0xFF ) );

this.WriteByte( ( byte )( value & 0xFF ) );

}

return true;

}

#if FEATURE_TAP

/// <summary>

/// Packs <see cref="UInt64"/> value to current stream asynchronously.

/// </summary>

/// <param name="value"><see cref="UInt64"/> value.</param>

/// <returns>A <see cref="Task"/> that represents the asynchronous operation.</returns>

/// <exception cref="ObjectDisposedException">This instance has been disposed.</exception>

[CLSCompliant( false )]

public Task PackAsync( UInt64 value )

{

return this.PackAsync( value, CancellationToken.None );

}

/// <summary>

/// Packs <see cref="UInt64"/> value to current stream asynchronously.

/// </summary>

/// <param name="value"><see cref="UInt64"/> 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>

[CLSCompliant( false )]

public Task PackAsync( UInt64 value, CancellationToken cancellationToken )

{

this.VerifyNotDisposed();

Contract.EndContractBlock();

return this.PrivatePackAsyncCore( value, cancellationToken );

}

private async Task PrivatePackAsyncCore( UInt64 value, CancellationToken cancellationToken )

{

if ( await this.TryPackTinyUnsignedIntegerAsync( value, cancellationToken ).ConfigureAwait( false ) )

{

return;

}

if ( await this.TryPackUInt8Async( value, cancellationToken ).ConfigureAwait( false ) )

{

return;

}

if ( await this.TryPackUInt16Async( value, cancellationToken ).ConfigureAwait( false ) )

{

return;

}

if ( await this.TryPackUInt32Async( value, cancellationToken ).ConfigureAwait( false ) )

{

return;

}

#pragma warning disable 168

var b = await this.TryPackUInt64Async( value, cancellationToken ).ConfigureAwait( false );

#pragma warning restore 168

Contract.Assert( b, "success" );

}

/// <summary>

/// Try packs <see cref="UInt64"/> value to current stream strictly asynchronously.

/// </summary>

/// <param name="value">Maybe <see cref="UInt64"/> value.</param>

/// <returns>

/// A <see cref="Task"/> that represents the asynchronous operation.

/// The value of the <c>TResult</c> parameter contains the value

/// whether <paramref name="value"/> has be packed successfully or not(normally, larger type required).

/// </returns>

[CLSCompliant( false )]

protected Task<bool> TryPackUInt64Async( UInt64 value )

{

return this.TryPackUInt64Async( value, CancellationToken.None );

}

/// <summary>

/// Try packs <see cref="UInt64"/> value to current stream strictly asynchronously.

/// </summary>

/// <param name="value">Maybe <see cref="UInt64"/> 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.

/// The value of the <c>TResult</c> parameter contains the value

/// whether <paramref name="value"/> has be packed successfully or not(normally, larger type required).

/// </returns>

[CLSCompliant( false )]

protected async Task<bool> TryPackUInt64Async( UInt64 value, CancellationToken cancellationToken )

{

await this.WriteByteAsync( MessagePackCode.UnsignedInt64 ).ConfigureAwait( false );

unchecked

{

await this.WriteByteAsync( ( byte )( ( value >> 56 ) & 0xFF ), cancellationToken ).ConfigureAwait( false );

await this.WriteByteAsync( ( byte )( ( value >> 48 ) & 0xFF ), cancellationToken ).ConfigureAwait( false );

await this.WriteByteAsync( ( byte )( ( value >> 40 ) & 0xFF ), cancellationToken ).ConfigureAwait( false );

await this.WriteByteAsync( ( byte )( ( value >> 32 ) & 0xFF ), cancellationToken ).ConfigureAwait( false );

await this.WriteByteAsync( ( byte )( ( value >> 24 ) & 0xFF ), cancellationToken ).ConfigureAwait( false );

await this.WriteByteAsync( ( byte )( ( value >> 16 ) & 0xFF ), cancellationToken ).ConfigureAwait( false );

await this.WriteByteAsync( ( byte )( ( value >> 8 ) & 0xFF ), cancellationToken ).ConfigureAwait( false );

await this.WriteByteAsync( ( byte )( value & 0xFF ), cancellationToken ).ConfigureAwait( false );

}

return true;

}