//******************************************************************************************************//  Word.cs - Gbtc////  Copyright © 2010, Grid Protection Alliance.  All Rights Reserved.////  Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See//  the NOTICE file distributed with this work for additional information regarding copyright ownership.//  The GPA licenses this file to you under the Eclipse Public License -v 1.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.opensource.org/licenses/eclipse-1.0.php////  Unless agreed to in writing, the subject software distributed under the License is distributed on an//  "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the//  License for the specific language governing permissions and limitations.////  Code Modification History://  ----------------------------------------------------------------------------------------------------//  04/10/2009 - James R. Carroll//       Generated original version of source code.//  09/14/2009 - Stephen C. Wills//       Added new header and license agreement.//  10/8/2012 - Danyelle Gilliam//        Modified Header////******************************************************************************************************    using System; namespace GSF{    /// <summary>    /// Represents functions and extensions related to 16-bit words, 32-bit double-words and 64-bit quad-words.    /// </summary>    [CLSCompliant(false)]    public static class Word    {        /// <summary>        /// Aligns word value on a 16-bit boundry.        /// </summary>        /// <param name="word">Word value to align.</param>        /// <returns>Word value aligned to next 16-bit boundry.</returns>        public static short AlignWord(this short word)        {            return (short)(word + 1 - (word - 1) % 2);        }         /// <summary>        /// Aligns word value on a 16-bit boundry.        /// </summary>        /// <param name="word">Word value to align.</param>        /// <returns>Word value aligned to next 16-bit boundry.</returns>        public static ushort AlignWord(this ushort word)        {            return (ushort)(word + 1 - (word - 1) % 2);        }         /// <summary>        /// Aligns double-word value on a 32-bit boundry.        /// </summary>        /// <param name="doubleWord">Double-word value to align.</param>        /// <returns>Double-word value aligned to next 32-bit boundry.</returns>        public static int AlignDoubleWord(this int doubleWord)        {            return doubleWord + 3 - (doubleWord - 1) % 4;        }         /// <summary>        /// Aligns double-word value on a 32-bit boundry.        /// </summary>        /// <param name="doubleWord">Double-word value to align.</param>        /// <returns>Double-word value aligned to next 32-bit boundry.</returns>        public static uint AlignDoubleWord(this uint doubleWord)        {            return doubleWord + 3 - (doubleWord - 1) % 4;        }         /// <summary>        /// Aligns quad-word value on a 64-bit boundry.        /// </summary>        /// <param name="quadWord">Quad-word value to align.</param>        /// <returns>Quad-word value aligned to next 64-bit boundry.</returns>        public static long AlignQuadWord(this long quadWord)        {            return quadWord + 7 - (quadWord - 1) % 8;        }         /// <summary>        /// Aligns quad-word value on a 64-bit boundry.        /// </summary>        /// <param name="quadWord">Quad-word value to align.</param>        /// <returns>Quad-word value aligned to next 64-bit boundry.</returns>        public static ulong AlignQuadWord(this ulong quadWord)        {            return quadWord + 7 - (quadWord - 1) % 8;        }         /// <summary>        /// Returns the high-nibble (high 4-bits) from a byte.        /// </summary>        /// <param name="value">Byte value.</param>        /// <returns>The high-nibble of the specified byte value.</returns>        public static byte HighNibble(this byte value)        {            return (byte)((value & (byte)0xF0) >> 4);        }         /// <summary>        /// Returns the high-byte from an unsigned word (UInt16).        /// </summary>        /// <param name="word">2-byte, 16-bit unsigned integer value.</param>        /// <returns>The high-order byte of the specified 16-bit unsigned integer value.</returns>        /// <remarks>        /// On little-endian architectures (e.g., Intel platforms), this will be the byte value whose in-memory representation        /// is the same as the right-most, most-significant-byte of the integer value.        /// </remarks>        public static byte HighByte(this ushort word)        {            return (byte)((word & (ushort)0xFF00) >> 8);        }         /// <summary>        /// Returns the unsigned high-word (UInt16) from an unsigned double-word (UInt32).        /// </summary>        /// <param name="doubleWord">4-byte, 32-bit unsigned integer value.</param>        /// <returns>The unsigned high-order word of the specified 32-bit unsigned integer value.</returns>        /// <remarks>        /// On little-endian architectures (e.g., Intel platforms), this will be the word value        /// whose in-memory representation is the same as the right-most, most-significant-word        /// of the integer value.        /// </remarks>        public static ushort HighWord(this uint doubleWord)        {            return (ushort)((doubleWord & (uint)0xFFFF0000) >> 16);        }         /// <summary>        /// Returns the unsigned high-double-word (UInt32) from an unsigned quad-word (UInt64).        /// </summary>        /// <param name="quadWord">8-byte, 64-bit unsigned integer value.</param>        /// <returns>The high-order double-word of the specified 64-bit unsigned integer value.</returns>        /// <remarks>        /// On little-endian architectures (e.g., Intel platforms), this will be the word value        /// whose in-memory representation is the same as the right-most, most-significant-word        /// of the integer value.        /// </remarks>        public static uint HighDword(this ulong quadWord)        {            return (uint)((quadWord & (ulong)0xFFFFFFFF00000000) >> 32);        }         /// <summary>        /// Returns the low-nibble (low 4-bits) from a byte.        /// </summary>        /// <param name="value">Byte value.</param>        /// <returns>The low-nibble of the specified byte value.</returns>        public static byte LowNibble(this byte value)        {            return (byte)(value & (byte)0x0F);        }         /// <summary>        /// Returns the low-byte from an unsigned word (UInt16).        /// </summary>        /// <param name="word">2-byte, 16-bit unsigned integer value.</param>        /// <returns>The low-order byte of the specified 16-bit unsigned integer value.</returns>        /// <remarks>        /// On little-endian architectures (e.g., Intel platforms), this will be the byte value        /// whose in-memory representation is the same as the left-most, least-significant-byte        /// of the integer value.        /// </remarks>        public static byte LowByte(this ushort word)        {            return (byte)(word & (ushort)0x00FF);        }         /// <summary>        /// Returns the unsigned low-word (UInt16) from an unsigned double-word (UInt32).        /// </summary>        /// <param name="doubleWord">4-byte, 32-bit unsigned integer value.</param>        /// <returns>The unsigned low-order word of the specified 32-bit unsigned integer value.</returns>        /// <remarks>        /// On little-endian architectures (e.g., Intel platforms), this will be the word value        /// whose in-memory representation is the same as the left-most, least-significant-word        /// of the integer value.        /// </remarks>        public static ushort LowWord(this uint doubleWord)        {            return (ushort)(doubleWord & (uint)0x0000FFFF);        }         /// <summary>        /// Returns the unsigned low-double-word (UInt32) from an unsigned quad-word (UInt64).        /// </summary>        /// <param name="quadWord">8-byte, 64-bit unsigned integer value.</param>        /// <returns>The low-order double-word of the specified 64-bit unsigned integer value.</returns>        /// <remarks>        /// On little-endian architectures (e.g., Intel platforms), this will be the word value        /// whose in-memory representation is the same as the left-most, least-significant-word        /// of the integer value.        /// </remarks>        public static uint LowDword(this ulong quadWord)        {            return (uint)(quadWord & (ulong)0x00000000FFFFFFFF);        }         /// <summary>        /// Makes an unsigned word (UInt16) from two bytes.        /// </summary>        /// <param name="high">High byte.</param>        /// <param name="low">Low byte.</param>        /// <returns>An unsigned 16-bit word made from the two specified bytes.</returns>        public static ushort MakeWord(byte high, byte low)        {            return (ushort)(low + ((ushort)high << 8));        }         /// <summary>        /// Makes an unsigned double-word (UInt32) from two unsigned words (UInt16).        /// </summary>        /// <param name="high">High word.</param>        /// <param name="low">Low word.</param>        /// <returns>An unsigned 32-bit double-word made from the two specified unsigned 16-bit words.</returns>        public static uint MakeDword(ushort high, ushort low)        {            return (uint)(low + ((uint)high << 16));        }         /// <summary>        /// Makes an unsigned quad-word (UInt64) from two unsigned double-words (UInt32).        /// </summary>        /// <param name="high">High double-word.</param>        /// <param name="low">Low double-word.</param>        /// <returns>An unsigned 64-bit quad-word made from the two specified unsigned 32-bit double-words.</returns>        public static ulong MakeQword(uint high, uint low)        {            return (ulong)(low + ((ulong)high << 32));        }    }}