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

			if (AutoFlush) Flush();
		}

 private void OnPort(IPeerWireClient client, UInt16 port)
 {
     if (Port != null)
     {
         Port(client, port);
     }
 }

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

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

            return bytes;
        }

 public SystemBootEventArgs(UInt16 major, UInt16 minor, UInt16 patch, UInt16 build, UInt16 ll_version, Byte protocol_version, Byte hw)
 {
     this.major = major;
     this.minor = minor;
     this.patch = patch;
     this.build = build;
     this.ll_version = ll_version;
     this.protocol_version = protocol_version;
     this.hw = hw;
 }

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

            public void WriteFixedString(string data, UInt16 fixedCount)
            {
                FWriter.Write((UInt16)data.Length);

                byte[] str = UnicodeEncoding.Unicode.GetBytes(data);

                FWriter.Write(str);

                for (int i = 0; i < (fixedCount - data.Length); ++i)
                {
                    FWriter.Write((UInt16)0);
                }
            }

        //------------------------------------------------------
        //
        //  Internal Methods
        //
        //------------------------------------------------------

        #region Internal Methods

        // Returns true if position points to a word break in the supplied
        // char array.  position is an inter-character offset -- 0 points
        // to the space preceeding the first char, 1 points between the
        // first and second char, etc.
        //
        // insideWordDirection specifies whether we're looking for a word start
        // or word end.  If insideWordDirection == LogicalDirection.Forward, then
        // text = "abc def", position = 4 will return true, but if the direction is
        // backward, no word boundary will be found (looking backward position is
        // at the edge of whitespace, not a word).
        //
        // This method requires at least MinContextLength chars ahead of and
        // following position to give accurate results, but no more.
        internal static bool IsAtWordBoundary(char[] text, int position, LogicalDirection insideWordDirection)
        {
            CharClass[] classes = GetClasses(text);

            // If the inside text is blank, it's not a word boundary.
            if (insideWordDirection == LogicalDirection.Backward)
            {
                if (position == text.Length)
                {
                    return true;
                }
                if (position == 0 || IsWhiteSpace(text[position - 1], classes[position - 1]))
                {
                    return false;
                }
            }
            else
            {
                if (position == 0)
                {
                    return true;
                }
                if (position == text.Length || IsWhiteSpace(text[position], classes[position]))
                {
                    return false;
                }
            }

            UInt16[] charType3 = new UInt16[2];

            SafeNativeMethods.GetStringTypeEx(0 /* ignored */, SafeNativeMethods.CT_CTYPE3, new char[] { text[position - 1], text[position] }, 2, charType3);

            // Otherwise we're at a word boundary if the classes of the surrounding text differ.
            return IsWordBoundary(text[position - 1], text[position]) ||
                   (
                    !IsSameClass(charType3[0], classes[position - 1], charType3[1], classes[position]) &&
                    !IsMidLetter(text, position - 1, classes) &&
                    !IsMidLetter(text, position, classes) 
                   );
        }

        private static bool FindImplSlotForCurrentType(EEType* pTgtType,
                                        EEType* pItfType,
                                        UInt16 itfSlotNumber,
                                        UInt16* pImplSlotNumber)
        {
            bool fRes = false;

            // If making a call and doing virtual resolution don't look into the dispatch map,
            // take the slot number directly.
            if (!pItfType->IsInterface)
            {
                *pImplSlotNumber = itfSlotNumber;

                // Only notice matches if the target type and search types are the same
                // This will make dispatch to sealed slots work correctly
                return pTgtType == pItfType;
            }

            if (pTgtType->HasDispatchMap)
            {
                // For variant interface dispatch, the algorithm is to walk the parent hierarchy, and at each level
                // attempt to dispatch exactly first, and then if that fails attempt to dispatch variantly. This can
                // result in interesting behavior such as a derived type only overriding one particular instantiation
                // and funneling all the dispatches to it, but its the algorithm.

                bool fDoVariantLookup = false; // do not check variance for first scan of dispatch map 

                fRes = FindImplSlotInSimpleMap(
                    pTgtType, pItfType, itfSlotNumber, pImplSlotNumber, fDoVariantLookup);

                if (!fRes)
                {
                    fDoVariantLookup = true; // check variance for second scan of dispatch map
                    fRes = FindImplSlotInSimpleMap(
                     pTgtType, pItfType, itfSlotNumber, pImplSlotNumber, fDoVariantLookup);
                }
            }

            return fRes;
        }

 public SetAdvParametersEventArgs(UInt16 result)
 {
     this.result = result;
 }

 public RegReadEventArgs(UInt16 address, Byte value)
 {
     this.address = address;
     this.value = value;
 }

 public SetFilteringEventArgs(UInt16 result)
 {
     this.result = result;
 }

 public ConnectSelectiveEventArgs(UInt16 result, Byte connection_handle)
 {
     this.result = result;
     this.connection_handle = connection_handle;
 }

 public EndProcedureEventArgs(UInt16 result)
 {
     this.result = result;
 }

 public static string ToString(UInt16 value)
 {
     return value.ToString();
 }

 public SetAdvDataEventArgs(UInt16 result)
 {
     this.result = result;
 }

 public IOPortConfigIrqEventArgs(UInt16 result)
 {
     this.result = result;
 }

 public DeleteBondingEventArgs(UInt16 result)
 {
     this.result = result;
 }

 public PasskeyEntryEventArgs(UInt16 result)
 {
     this.result = result;
 }

 public EncryptStartEventArgs(Byte handle, UInt16 result)
 {
     this.handle = handle;
     this.result = result;
 }

 public ReadMultipleEventArgs(Byte connection, UInt16 result)
 {
     this.connection = connection;
     this.result = result;
 }