public override void Write(Int16 val)
		{
			val = Utilities.SwapBytes(val);
			base.Write(val);

			if (AutoFlush) Flush();
		}

			internal Channel(Int16 id, Layer layer)
			{
				ID = id;
				Layer = layer;
				Layer.Channels.Add(this);
				Layer.SortedChannels.Add(ID, this);
			}

        /// <summary>
        /// Converts a <see cref="Int16"/> to big endian notation.
        /// </summary>
        /// <param name="input">The <see cref="Int16"/> to convert.</param>
        /// <returns>The converted <see cref="Int16"/>.</returns>
        public static Int16 BigEndian(Int16 input)
        {
            if (!BitConverter.IsLittleEndian)
                return input;

            return Swap(input);
        }

 public Document(
     Int16 _TypeId,
     Int64 _Serial,
     Int32 _SignedUser,
     DateTime _Date,
     Boolean _Printed,
     String _DocumentShortName,
     String _DocumentFullName,
     String _MedexDataTable,
     String _DocumentBody,
     String _DocumentHeader,
     Boolean _SetDeleted
     
     )
 {
     TypeId = _TypeId;
        Serial = _Serial;
        SignedUser = _SignedUser;
        Date = _Date;
        Printed = _Printed;
        DocumentShortName = _DocumentShortName;
        DocumentFullName = _DocumentFullName;
        MedexDataTable = _MedexDataTable;
        DocumentBody = _DocumentBody;
        DocumentHeader = _DocumentHeader;
        SetDeleted = _SetDeleted;
 }

        private static void VerifyInt16ImplicitCastToComplex(Int16 value)
        {
            Complex c_cast = value;

            if (false == Support.VerifyRealImaginaryProperties(c_cast, value, 0.0))
            {
                Console.WriteLine("Int16ImplicitCast ({0})" + value);
                Assert.True(false, "Verification Failed");
            }
            else
            {
                if (value != Int16.MaxValue)
                {
                    Complex c_cast_plus = c_cast + 1;
                    if (false == Support.VerifyRealImaginaryProperties(c_cast_plus, value + 1, 0.0))
                    {
                        Console.WriteLine("PLuS + Int16ImplicitCast ({0})" + value);
                        Assert.True(false, "Verification Failed");
                    }
                }

                if (value != Int16.MinValue)
                {
                    Complex c_cast_minus = c_cast - 1;
                    if (false == Support.VerifyRealImaginaryProperties(c_cast_minus, value - 1, 0.0))
                    {
                        Console.WriteLine("Minus - Int16ImplicitCast + 1 ({0})" + value);
                        Assert.True(false, "Verification Failed");
                    }
                }
            }
        }

        public static byte[] Int16(Int16 i, Endianness e = Endianness.Machine)
        {
            byte[] bytes = BitConverter.GetBytes(i);

            if (NeedsFlipping(e)) Array.Reverse(bytes);

            return bytes;
        }

 public static void Write(this BinaryWriter writer, Int16 value, bool invertEndian = false)
 {
     if (invertEndian)
     {
         writer.WriteInvertedBytes(BitConverter.GetBytes(value));
     }
     else
     {
         writer.Write(value);
     }
 }

        private static void VerifyInt16ImplicitCastToComplex(Int16 value)
        {
            Complex c_cast = value;

            Support.VerifyRealImaginaryProperties(c_cast, value, 0.0, 
                string.Format("Int16ImplicitCast ({0})", value));
            
            if (value != Int16.MaxValue)
            {
                Complex c_cast_plus = c_cast + 1;
                Support.VerifyRealImaginaryProperties(c_cast_plus, value + 1, 0.0, 
                    string.Format("PLuS + Int16ImplicitCast ({0})", value));
            }

            if (value != Int16.MinValue)
            {
                Complex c_cast_minus = c_cast - 1;
                Support.VerifyRealImaginaryProperties(c_cast_minus, value - 1, 0.0, 
                    string.Format("Minus - Int16ImplicitCast + 1 ({0})", value));
            }
        }

 public override void WriteArray(string prefix, string localName, string namespaceUri, Int16[] array, int offset, int count)
 {
     throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR.GetString(SR.JsonWriteArrayNotSupported)));
 }

 internal static Exception TryToInt16(string s, out Int16 result) {
     if (!Int16.TryParse(s, NumberStyles.AllowLeadingSign|NumberStyles.AllowLeadingWhite|NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo, out result)) {
         return new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "Int16"));
     }
     return null;
 }

        private static void VerifyInt16ImplicitCastToBigInteger(Int16 value)
        {
            BigInteger bigInteger = value;

            Assert.Equal(value, bigInteger);
            Assert.Equal(value.ToString(), bigInteger.ToString());
            Assert.Equal(value, (Int16)bigInteger);

            if (value != Int16.MaxValue)
            {
                Assert.Equal((Int16)(value + 1), (Int16)(bigInteger + 1));
            }

            if (value != Int16.MinValue)
            {
                Assert.Equal((Int16)(value - 1), (Int16)(bigInteger - 1));
            }
    
            VerifyBigIntegerUsingIdentities(bigInteger, 0 == value);
        }

        public void Write(Int16[] value, int offset, int count)
        {
            const int size = sizeof(Int16);

            CreateBuffer(size * count);
            for (int i = 0; i < count; i++)
            {
                Array.Copy(BitConverter.GetBytes(value[i + offset]), 0, buffer, i * size, size);
            }

            WriteBuffer(size * count, size);
        }

 /// <summary>
 /// Converts int16 to the array of bytes size 2
 /// </summary>
 /// <param name="value">Int16 value</param>
 /// <returns>Array of bytes of size 2.</returns>
 public static byte[] Int16ToBytes(Int16 value)
 {
     return Int32ToBytes(value, 2);
 }

 public override void WriteArray(string prefix, string localName, string namespaceUri, Int16[] array, int offset, int count)
 {
     throw new NotSupportedException(SR.JsonWriteArrayNotSupported);
 }

 public void Push(Int16 value)
 {
     Data[StackIndex++] = value;
 }

        // valid for SqlDbType.SmallInt
        internal void SetInt16(Int16 value)
        {
            Debug.Assert(
                SmiXetterAccessMap.IsSetterAccessValid(_metaData, SmiXetterTypeCode.XetInt16));

            if (SqlDbType.Variant == _metaData.SqlDbType)
            {
                _stateObj.Parser.WriteSqlVariantHeader(4, TdsEnums.SQLINT2, 0, _stateObj);
            }
            else
            {
                _stateObj.WriteByte((byte)_metaData.MaxLength);
            }
            _stateObj.Parser.WriteShort(value, _stateObj);
        }

 internal static unsafe IntPtr ConvertInt16ByrefToPtr(ref Int16 value) {
     fixed (Int16 *x = &value) {
         AssertByrefPointsToStack(new IntPtr(x));
         return new IntPtr(x);
     }
 }

 private static void VerifyInt16ExplicitCastFromBigInteger(Int16 value, BigInteger bigInteger)
 {
     Assert.Equal(value, (Int16)bigInteger);
 }

 public ADCResultEventArgs(Byte input, Int16 value)
 {
     this.input = input;
     this.value = value;
 }

 private unsafe int ReadArray(Int16[] array, int offset, int count)
 {
     CheckArray(array, offset, count);
     int actual = Math.Min(count, _arrayCount);
     fixed (Int16* items = &array[offset])
     {
         BufferReader.UnsafeReadArray((byte*)items, (byte*)&items[actual]);
     }
     SkipArrayElements(actual);
     return actual;
 }