Loads a 16, 32 or 64 bit value with no byte swapping. More...
#include <brendian.h>
Static Public Member Functions | |
| static Word16 BURGER_INLINE | Load (Word16 uInput) |
| Fetch a 16 bit value. | |
| static Word32 BURGER_INLINE | Load (Word32 uInput) |
| Fetch a 32 bit value. | |
| static Word64 BURGER_INLINE | Load (Word64 uInput) |
| Fetch a 64 bit value. | |
| static float BURGER_INLINE | Load (float fInput) |
| Fetch a float value. | |
| static double BURGER_INLINE | Load (double dInput) |
| Fetch a double value. | |
| static Word16 BURGER_INLINE | Load (const Word16 *pInput) |
| Fetch a 16 bit value from memory. | |
| static Word32 BURGER_INLINE | Load (const Word32 *pInput) |
| Fetch a 32 bit value from memory. | |
| static Word64 BURGER_INLINE | Load (const Word64 *pInput) |
| Fetch a 64 bit value from memory. | |
| static float BURGER_INLINE | Load (const float *pInput) |
| Fetch a float value from memory. | |
| static double BURGER_INLINE | Load (const double *pInput) |
| Fetch a double value from memory. | |
| static Word16 BURGER_API | LoadAny (const Word16 *pInput) |
| Fetch a 16 bit unsigned value from memory with byte alignment. | |
| static Word32 BURGER_API | LoadAny (const Word32 *pInput) |
| Fetch a 32 bit unsigned value from memory with byte alignment. | |
| static Word64 BURGER_API | LoadAny (const Word64 *pInput) |
| Fetch a 64 bit unsigned value from memory with byte alignment. | |
| static float BURGER_API | LoadAny (const float *pInput) |
| Fetch a float value from memory with byte alignment. | |
| static double BURGER_API | LoadAny (const double *pInput) |
| Fetch a double value from memory with byte alignment. | |
| static void BURGER_INLINE | Fixup (Word16 *) |
| Does nothing. | |
| static void BURGER_INLINE | Fixup (Word32 *) |
| Does nothing. | |
| static void BURGER_INLINE | Fixup (Word64 *) |
| Does nothing. | |
| static void BURGER_INLINE | FixupAny (Word16 *) |
| Does nothing. | |
| static void BURGER_INLINE | FixupAny (Word32 *) |
| Does nothing. | |
| static void BURGER_INLINE | FixupAny (Word64 *) |
| Does nothing. | |
| static Int16 BURGER_INLINE | Load (Int16 iInput) |
| Fetch a 16 bit value. | |
| static Int32 BURGER_INLINE | Load (Int32 iInput) |
| Fetch a 32 bit value. | |
| static Int64 BURGER_INLINE | Load (Int64 iInput) |
| Fetch a 64 bit value. | |
| static Word BURGER_INLINE | Load (Word uInput) |
| Fetch an integer value. | |
| static Int BURGER_INLINE | Load (Int iInput) |
| Fetch a signed integer value. | |
| static Word BURGER_INLINE | Load (const Word *pInput) |
| Fetch an unsigned integer value from memory. | |
| static Int BURGER_INLINE | Load (const Int *pInput) |
| Fetch a signed integer value from memory. | |
| static Word BURGER_INLINE | LoadAny (const Word *pInput) |
| Fetch an unsigned integer value from memory with byte alignment. | |
| static Int BURGER_INLINE | LoadAny (const Int *pInput) |
| Fetch an signed integer value from memory with byte alignment. | |
| static void BURGER_INLINE | Fixup (Word *) |
| Does nothing. | |
| static void BURGER_INLINE | Fixup (Int *) |
| Does nothing. | |
| static void BURGER_INLINE | FixupAny (Word *) |
| Does nothing. | |
| static void BURGER_INLINE | FixupAny (Int *) |
| Does nothing. | |
| static Int16 BURGER_INLINE | Load (const Int16 *pInput) |
| Fetch a 16 bit value from memory. | |
| static Int32 BURGER_INLINE | Load (const Int32 *pInput) |
| Fetch a 32 bit value from memory. | |
| static Int64 BURGER_INLINE | Load (const Int64 *pInput) |
| Fetch a 64 bit value from memory. | |
| static Int16 BURGER_INLINE | LoadAny (const Int16 *pInput) |
| Fetch a 16 bit signed value from memory with byte alignment. | |
| static Int32 BURGER_INLINE | LoadAny (const Int32 *pInput) |
| Fetch a 32 bit signed value from memory with byte alignment. | |
| static Int64 BURGER_INLINE | LoadAny (const Int64 *pInput) |
| Fetch a 64 bit signed value from memory with byte alignment. | |
| static void BURGER_INLINE | Fixup (Int16 *) |
| Does nothing. | |
| static void BURGER_INLINE | Fixup (Int32 *) |
| Does nothing. | |
| static void BURGER_INLINE | Fixup (Int64 *) |
| Does nothing. | |
| static void BURGER_INLINE | Fixup (float *) |
| Does nothing. | |
| static void BURGER_INLINE | Fixup (double *) |
| Does nothing. | |
| static void BURGER_INLINE | FixupAny (Int16 *) |
| Does nothing. | |
| static void BURGER_INLINE | FixupAny (Int32 *) |
| Does nothing. | |
| static void BURGER_INLINE | FixupAny (Int64 *) |
| Does nothing. | |
| static void BURGER_INLINE | FixupAny (float *) |
| Does nothing. | |
| static void BURGER_INLINE | FixupAny (double *) |
| Does nothing. | |
Detailed Description
Loads a 16, 32 or 64 bit value with no byte swapping.
The classes Burger::LittleEndian and Burger::BigEndian either map to Burger::NativeEndian or Burger::SwapEndian. If the machine's endian matches the class, then it maps to this class.
This class does nothing for most functions by design. It is meant to vanish when the program is asking for no endian swapping since the data being read is the same endian as the machine.
The only functions that do not disappear are the LoadAny(??? *) group of calls since they have the ability to fetch a 16, 32 or 64 bit value irregardless of the alignment of the data pointer. These are useful in grabbing data from a byte stream and won't trigger an alignment access fault.
Under most circumstances, you will not call this class directly.
- See also:
- Burger::SwapEndian, Burger::LittleEndian and Burger::BigEndian
Member Function Documentation
| Burger::NativeEndian::Fixup | ( | Word16 * | pInput | ) | [inline, static] |
Does nothing.
The Burger::SwapEndian class would swap the endian of the variable, but this class performs no operation since the endian is already a match for what the machine expects.
- Parameters:
-
pInput Pointer to a 16 bit value.
| Burger::NativeEndian::Fixup | ( | Word32 * | pInput | ) | [inline, static] |
Does nothing.
The Burger::SwapEndian class would swap the endian of the variable, but this class performs no operation since the endian is already a match for what the machine expects.
- Parameters:
-
pInput Pointer to a 32 bit value.
| Burger::NativeEndian::Fixup | ( | Word64 * | pInput | ) | [inline, static] |
Does nothing.
The Burger::SwapEndian class would swap the endian of the variable, but this class performs no operation since the endian is already a match for what the machine expects.
- Parameters:
-
pInput Pointer to a 64 bit value.
| Burger::NativeEndian::Fixup | ( | Int * | pInput | ) | [inline, static] |
Does nothing.
The Burger::SwapEndian class would swap the endian of the variable, but this class performs no operation since the endian is already a match for what the machine expects.
- Parameters:
-
pInput Pointer to an integer value.
| Burger::NativeEndian::Fixup | ( | Int16 * | pInput | ) | [inline, static] |
Does nothing.
The Burger::SwapEndian class would swap the endian of the variable, but this class performs no operation since the endian is already a match for what the machine expects.
- Parameters:
-
pInput Pointer to a 16 bit value.
| Burger::NativeEndian::Fixup | ( | Int32 * | pInput | ) | [inline, static] |
Does nothing.
The Burger::SwapEndian class would swap the endian of the variable, but this class performs no operation since the endian is already a match for what the machine expects.
- Parameters:
-
pInput Pointer to a 32 bit value.
| Burger::NativeEndian::Fixup | ( | Int64 * | pInput | ) | [inline, static] |
Does nothing.
The Burger::SwapEndian class would swap the endian of the variable, but this class performs no operation since the endian is already a match for what the machine expects.
- Parameters:
-
pInput Pointer to a 64 bit value.
| Burger::NativeEndian::Fixup | ( | float * | pInput | ) | [inline, static] |
Does nothing.
The Burger::SwapEndian class would swap the endian of the variable, but this class performs no operation since the endian is already a match for what the machine expects.
- Parameters:
-
pInput Pointer to a float value.
| Burger::NativeEndian::Fixup | ( | double * | pInput | ) | [inline, static] |
Does nothing.
The Burger::SwapEndian class would swap the endian of the variable, but this class performs no operation since the endian is already a match for what the machine expects.
- Parameters:
-
pInput Pointer to a double value.
| Burger::NativeEndian::Fixup | ( | Word * | pInput | ) | [inline, static] |
Does nothing.
The Burger::SwapEndian class would swap the endian of the variable, but this class performs no operation since the endian is already a match for what the machine expects.
- Parameters:
-
pInput Pointer to an unsigned integer value.
| Burger::NativeEndian::FixupAny | ( | Word * | pInput | ) | [inline, static] |
Does nothing.
The Burger::SwapEndian class would swap the endian of the variable, but this class performs no operation since the endian is already a match for what the machine expects.
- Parameters:
-
pInput Pointer to an unsigned integer value.
| Burger::NativeEndian::FixupAny | ( | Int * | pInput | ) | [inline, static] |
Does nothing.
The Burger::SwapEndian class would swap the endian of the variable, but this class performs no operation since the endian is already a match for what the machine expects.
- Parameters:
-
pInput Pointer to an integer value.
| Burger::NativeEndian::FixupAny | ( | Word16 * | pInput | ) | [inline, static] |
Does nothing.
The Burger::SwapEndian class would swap the endian of the variable, but this class performs no operation since the endian is already a match for what the machine expects.
- Parameters:
-
pInput Pointer to a 16 bit value.
| Burger::NativeEndian::FixupAny | ( | Int32 * | pInput | ) | [inline, static] |
Does nothing.
The Burger::SwapEndian class would swap the endian of the variable, but this class performs no operation since the endian is already a match for what the machine expects.
- Parameters:
-
pInput Pointer to a 32 bit value.
| Burger::NativeEndian::FixupAny | ( | Word64 * | pInput | ) | [inline, static] |
Does nothing.
The Burger::SwapEndian class would swap the endian of the variable, but this class performs no operation since the endian is already a match for what the machine expects.
- Parameters:
-
pInput Pointer to a 64 bit value.
| Burger::NativeEndian::FixupAny | ( | Word32 * | pInput | ) | [inline, static] |
Does nothing.
The Burger::SwapEndian class would swap the endian of the variable, but this class performs no operation since the endian is already a match for what the machine expects.
- Parameters:
-
pInput Pointer to a 32 bit value.
| Burger::NativeEndian::FixupAny | ( | Int16 * | pInput | ) | [inline, static] |
Does nothing.
The Burger::SwapEndian class would swap the endian of the variable, but this class performs no operation since the endian is already a match for what the machine expects.
- Parameters:
-
pInput Pointer to a 16 bit value.
| Burger::NativeEndian::FixupAny | ( | Int64 * | pInput | ) | [inline, static] |
Does nothing.
The Burger::SwapEndian class would swap the endian of the variable, but this class performs no operation since the endian is already a match for what the machine expects.
- Parameters:
-
pInput Pointer to a 64 bit value.
| Burger::NativeEndian::FixupAny | ( | float * | pInput | ) | [inline, static] |
Does nothing.
The Burger::SwapEndian class would swap the endian of the variable, but this class performs no operation since the endian is already a match for what the machine expects.
- Parameters:
-
pInput Pointer to a float value.
| Burger::NativeEndian::FixupAny | ( | double * | pInput | ) | [inline, static] |
Does nothing.
The Burger::SwapEndian class would swap the endian of the variable, but this class performs no operation since the endian is already a match for what the machine expects.
- Parameters:
-
pInput Pointer to a double value.
| Burger::NativeEndian::Load | ( | const Int16 * | pInput | ) | [inline, static] |
Fetch a 16 bit value from memory.
This function is usually optimized into a simple load operation. It assumes that the data is 16 bit aligned.
- Parameters:
-
pInput Pointer to an signed 16 bit value.
- Returns:
- The 16 bit signed value.
| Burger::NativeEndian::Load | ( | Word | uInput | ) | [inline, static] |
Fetch an integer value.
Pass an integer value through with no change. This function is usually optimized into oblivion.
- Parameters:
-
uInput Unsigned integer input.
- Returns:
- uInput untouched.
- See also:
- Burger::SwapEndian::Load(Word)
| Burger::NativeEndian::Load | ( | const Word64 * | pInput | ) | [inline, static] |
Fetch a 64 bit value from memory.
This function is usually optimized into a simple load operation. It assumes that the data is 64 bit aligned.
- Parameters:
-
pInput Pointer to an unsigned 64 bit value.
- Returns:
- The 64 bit unsigned value.
| Burger::NativeEndian::Load | ( | Word32 | uInput | ) | [inline, static] |
Fetch a 32 bit value.
Pass a 32 bit value through with no change. This function is usually optimized into oblivion.
- Parameters:
-
uInput Unsigned 32 bit input.
- Returns:
- uInput untouched.
- See also:
- Burger::SwapEndian::Load(Word32)
| Burger::NativeEndian::Load | ( | const Word * | pInput | ) | [inline, static] |
Fetch an unsigned integer value from memory.
This function is usually optimized into a simple load operation. It assumes that the data is aligned to the size of a native integer (Usually 32 bits).
- Parameters:
-
pInput Pointer to an unsigned integer value.
- Returns:
- The unsigned integer value.
| Burger::NativeEndian::Load | ( | Int64 | iInput | ) | [inline, static] |
Fetch a 64 bit value.
Pass a 64 bit value through with no change. This function is usually optimized into oblivion.
- Parameters:
-
iInput Signed 64 bit input.
- Returns:
- iInput untouched.
- See also:
- Burger::SwapEndian::Load(Int64)
| Burger::NativeEndian::Load | ( | const float * | pInput | ) | [inline, static] |
Fetch a float value from memory.
This function is usually optimized into a simple load operation. It assumes that the data is 32 bit aligned.
- Parameters:
-
pInput Pointer to a float value.
- Returns:
- The float value.
| Burger::NativeEndian::Load | ( | const Int32 * | pInput | ) | [inline, static] |
Fetch a 32 bit value from memory.
This function is usually optimized into a simple load operation. It assumes that the data is 32 bit aligned.
- Parameters:
-
pInput Pointer to an signed 32 bit value.
- Returns:
- The 32 bit signed value.
| Burger::NativeEndian::Load | ( | Int16 | iInput | ) | [inline, static] |
Fetch a 16 bit value.
Pass a 16 bit value through with no change. This function is usually optimized into oblivion.
- Parameters:
-
iInput Signed 16 bit input.
- Returns:
- iInput untouched.
- See also:
- Burger::SwapEndian::Load(Int16)
| Burger::NativeEndian::Load | ( | Int32 | iInput | ) | [inline, static] |
Fetch a 32 bit value.
Pass a 32 bit value through with no change. This function is usually optimized into oblivion.
- Parameters:
-
iInput Signed 32 bit input.
- Returns:
- iInput untouched.
- See also:
- Burger::SwapEndian::Load(Int32)
| Burger::NativeEndian::Load | ( | Word16 | uInput | ) | [inline, static] |
Fetch a 16 bit value.
Pass a 16 bit value through with no change. This function is usually optimized into oblivion.
- Parameters:
-
uInput Unsigned 16 bit input.
- Returns:
- uInput untouched.
- See also:
- Burger::SwapEndian::Load(Word16)
| Burger::NativeEndian::Load | ( | const double * | pInput | ) | [inline, static] |
Fetch a double value from memory.
This function is usually optimized into a simple load operation. It assumes that the data is 64 bit aligned.
- Parameters:
-
pInput Pointer to a double value.
- Returns:
- The double value.
| Burger::NativeEndian::Load | ( | const Int64 * | pInput | ) | [inline, static] |
Fetch a 64 bit value from memory.
This function is usually optimized into a simple load operation. It assumes that the data is 64 bit aligned.
- Parameters:
-
pInput Pointer to an signed 64 bit value.
- Returns:
- The 64 bit signed value.
| Burger::NativeEndian::Load | ( | float | fInput | ) | [inline, static] |
Fetch a float value.
Pass a float value through with no change. This function is usually optimized into oblivion.
- Parameters:
-
fInput A float input.
- Returns:
- fInput untouched.
- See also:
- Burger::SwapEndian::Load(float)
| Burger::NativeEndian::Load | ( | const Word16 * | pInput | ) | [inline, static] |
Fetch a 16 bit value from memory.
This function is usually optimized into a simple load operation. It assumes that the data is 16 bit aligned.
- Parameters:
-
pInput Pointer to an unsigned 16 bit value.
- Returns:
- The 16 bit unsigned value.
| Burger::NativeEndian::Load | ( | double | dInput | ) | [inline, static] |
Fetch a double value.
Pass a double value through with no change. This function is usually optimized into oblivion.
- Parameters:
-
dInput A double input.
- Returns:
- dInput untouched.
- See also:
- Burger::SwapEndian::Load(double)
| Burger::NativeEndian::Load | ( | const Word32 * | pInput | ) | [inline, static] |
Fetch a 32 bit value from memory.
This function is usually optimized into a simple load operation. It assumes that the data is 32 bit aligned.
- Parameters:
-
pInput Pointer to an unsigned 32 bit value.
- Returns:
- The 32 bit unsigned value.
| Burger::NativeEndian::Load | ( | const Int * | pInput | ) | [inline, static] |
Fetch a signed integer value from memory.
This function is usually optimized into a simple load operation. It assumes that the data is aligned to the size of a native integer (Usually 32 bits).
- Parameters:
-
pInput Pointer to a signed integer value.
- Returns:
- The signed integer value.
| Burger::NativeEndian::Load | ( | Int | iInput | ) | [inline, static] |
Fetch a signed integer value.
Pass a signed integer value through with no change. This function is usually optimized into oblivion.
- Parameters:
-
iInput Signed integer input.
- Returns:
- iInput untouched.
- See also:
- Burger::SwapEndian::Load(Int)
| Burger::NativeEndian::Load | ( | Word64 | uInput | ) | [inline, static] |
Fetch a 64 bit value.
Pass a 64 bit value through with no change. This function is usually optimized into oblivion.
- Parameters:
-
uInput Unsigned 64 bit input.
- Returns:
- uInput untouched.
- See also:
- Burger::SwapEndian::Load(Word64)
| Burger::NativeEndian::LoadAny | ( | const Int32 * | pInput | ) | [inline, static] |
Fetch a 32 bit signed value from memory with byte alignment.
Assuming the data is unaligned, it will grab data a byte at a time and reconstruct it into a 32 bit value in native endian.
- Parameters:
-
pInput Pointer to a 32 bit value.
- Returns:
- The 32 bit signed value.
Fetch a 16 bit unsigned value from memory with byte alignment.
Assuming the data is unaligned, it will grab data a byte at a time and reconstruct it into a 16 bit value in native endian.
- Parameters:
-
pInput Pointer to a 16 bit value.
- Returns:
- The 16 bit unsigned value.
Fetch a 32 bit unsigned value from memory with byte alignment.
Assuming the data is unaligned, it will grab data a byte at a time and reconstruct it into a 32 bit value in native endian.
- Parameters:
-
pInput Pointer to a 32 bit value.
- Returns:
- The 32 bit unsigned value.
| Burger::NativeEndian::LoadAny | ( | const Word * | pInput | ) | [inline, static] |
Fetch an unsigned integer value from memory with byte alignment.
Assuming the data is unaligned, it will grab data a byte at a time and reconstruct it into an unsigned integer value in native endian.
- Parameters:
-
pInput Pointer to an integer value.
- Returns:
- The unsigned integer value.
| Burger::NativeEndian::LoadAny | ( | const Int * | pInput | ) | [inline, static] |
Fetch an signed integer value from memory with byte alignment.
Assuming the data is unaligned, it will grab data a byte at a time and reconstruct it into an signed integer value in native endian.
- Parameters:
-
pInput Pointer to an integer value.
- Returns:
- The signed integer value.
| double BURGER_API Burger::NativeEndian::LoadAny | ( | const double * | pInput | ) | [static] |
Fetch a double value from memory with byte alignment.
Assuming the data is unaligned, it will grab data a byte at a time and reconstruct it into a double value in native endian.
- Parameters:
-
pInput Pointer to a double value.
- Returns:
- The double value.
| Burger::NativeEndian::LoadAny | ( | const Int16 * | pInput | ) | [inline, static] |
Fetch a 16 bit signed value from memory with byte alignment.
Assuming the data is unaligned, it will grab data a byte at a time and reconstruct it into a 16 bit value in native endian.
- Parameters:
-
pInput Pointer to a 16 bit value.
- Returns:
- The 16 bit signed value.
| Burger::NativeEndian::LoadAny | ( | const Int64 * | pInput | ) | [inline, static] |
Fetch a 64 bit signed value from memory with byte alignment.
Assuming the data is unaligned, it will grab data a byte at a time and reconstruct it into a 64 bit value in native endian.
- Parameters:
-
pInput Pointer to a 64 bit value.
- Returns:
- The 64 bit signed value.
| float BURGER_API Burger::NativeEndian::LoadAny | ( | const float * | pInput | ) | [static] |
Fetch a float value from memory with byte alignment.
Assuming the data is unaligned, it will grab data a byte at a time and reconstruct it into a float value in native endian.
- Parameters:
-
pInput Pointer to a float value.
- Returns:
- The float value.
Fetch a 64 bit unsigned value from memory with byte alignment.
Assuming the data is unaligned, it will grab data a byte at a time and reconstruct it into a 64 bit value in native endian.
- Parameters:
-
pInput Pointer to a 64 bit value.
- Returns:
- The 64 bit unsigned value.
