WallyHackenslacker/Aerofoil
1
0
Fork 0
mirror of https://github.com/elasota/Aerofoil.git synced 2025-09-23 14:53:52 +00:00
Code Issues Projects Releases Wiki Activity

Normalize line endings

Browse Source 
This commit contains only the result of `git add --renormalize .`

`git show --ignore-space-change` can verify that this commit only
changes whitespace.
This commit is contained in:
Diomendius
2024-07-31 19:35:12 +12:00
parent bb7b663daf
commit 1b18a87495
822 changed files with 323794 additions and 323794 deletions
Download Patch File Download Diff File Expand all files Collapse all files

490
PortabilityLayer/PLLittleEndian.h
View File

@@ -1,245 +1,245 @@
#pragma once
#include <stdint.h>
template<class T>
struct LEInteger
{
public:
LEInteger();
LEInteger(const LEInteger<T> &other);
explicit LEInteger(T i);
operator T() const;
LEInteger<T> &operator=(T value);
template<class TOther>
LEInteger<T> &operator+=(TOther value);
template<class TOther>
LEInteger<T> &operator-=(TOther value);
template<class TOther>
LEInteger<T> &operator*=(TOther value);
template<class TOther>
LEInteger<T> &operator/=(TOther value);
template<class TOther>
LEInteger<T> &operator%=(TOther value);
LEInteger<T>& operator--();
LEInteger<T> operator--(int);
LEInteger<T>& operator++();
LEInteger<T> operator++(int);
private:
uint8_t m_leValueBytes[sizeof(T)];
};
template<class T>
struct LEInteger_SwapHelper
{
};
#include "ByteSwap.h"
template<>
struct LEInteger_SwapHelper<int16_t>
{
inline static void Swap(int16_t &v)
{
PortabilityLayer::ByteSwap::LittleInt16(v);
}
};
template<>
struct LEInteger_SwapHelper<int32_t>
{
inline static void Swap(int32_t &v)
{
PortabilityLayer::ByteSwap::LittleInt32(v);
}
};
template<>
struct LEInteger_SwapHelper<uint16_t>
{
inline static void Swap(uint16_t &v)
{
PortabilityLayer::ByteSwap::LittleUInt16(v);
}
};
template<>
struct LEInteger_SwapHelper<uint32_t>
{
inline static void Swap(uint32_t &v)
{
PortabilityLayer::ByteSwap::LittleUInt32(v);
}
};
#include <string.h>
template<class T>
inline LEInteger<T>::LEInteger()
{
memset(m_leValueBytes, 0, sizeof(T));
}
template<class T>
inline LEInteger<T>::LEInteger(const LEInteger<T> &other)
{
memcpy(m_leValueBytes, other.m_leValueBytes, sizeof(T));
}
template<class T>
inline LEInteger<T>::LEInteger(T i)
{
LEInteger_SwapHelper<T>::Swap(i);
memcpy(m_leValueBytes, &i, sizeof(T));
}
template<class T>
inline LEInteger<T>::operator T() const
{
T result;
memcpy(&result, m_leValueBytes, sizeof(T));
LEInteger_SwapHelper<T>::Swap(result);
return result;
}
template<class T>
inline LEInteger<T> &LEInteger<T>::operator=(T value)
{
LEInteger_SwapHelper<T>::Swap(value);
memcpy(m_leValueBytes, &value, sizeof(T));
return *this;
}
template<class T>
template<class TOther>
LEInteger<T> &LEInteger<T>::operator+=(TOther value)
{
T storedValue;
memcpy(&storedValue, m_leValueBytes, sizeof(T));
LEInteger_SwapHelper<T>::Swap(storedValue);
storedValue += value;
LEInteger_SwapHelper<T>::Swap(storedValue);
memcpy(m_leValueBytes, &storedValue, sizeof(T));
return *this;
}
template<class T>
template<class TOther>
LEInteger<T> &LEInteger<T>::operator-=(TOther value)
{
T storedValue;
memcpy(&storedValue, m_leValueBytes, sizeof(T));
LEInteger_SwapHelper<T>::Swap(storedValue);
storedValue -= value;
LEInteger_SwapHelper<T>::Swap(storedValue);
memcpy(m_leValueBytes, &storedValue, sizeof(T));
return *this;
}
template<class T>
template<class TOther>
LEInteger<T> &LEInteger<T>::operator*=(TOther value)
{
T storedValue;
memcpy(&storedValue, m_leValueBytes, sizeof(T));
LEInteger_SwapHelper<T>::Swap(storedValue);
storedValue *= value;
LEInteger_SwapHelper<T>::Swap(storedValue);
memcpy(m_leValueBytes, &storedValue, sizeof(T));
return *this;
}
template<class T>
template<class TOther>
LEInteger<T> &LEInteger<T>::operator/=(TOther value)
{
T storedValue;
memcpy(&storedValue, m_leValueBytes, sizeof(T));
LEInteger_SwapHelper<T>::Swap(storedValue);
storedValue /= value;
LEInteger_SwapHelper<T>::Swap(storedValue);
memcpy(m_leValueBytes, &storedValue, sizeof(T));
return *this;
}
template<class T>
template<class TOther>
LEInteger<T> &LEInteger<T>::operator%=(TOther value)
{
T storedValue;
memcpy(&storedValue, m_leValueBytes, sizeof(T));
LEInteger_SwapHelper<T>::Swap(storedValue);
storedValue %= value;
LEInteger_SwapHelper<T>::Swap(storedValue);
memcpy(m_leValueBytes, &storedValue, sizeof(T));
return *this;
}
template<class T>
LEInteger<T>& LEInteger<T>::operator--()
{
T storedValue;
memcpy(&storedValue, m_leValueBytes, sizeof(T));
LEInteger_SwapHelper<T>::Swap(storedValue);
storedValue--;
LEInteger_SwapHelper<T>::Swap(storedValue);
memcpy(m_leValueBytes, &storedValue, sizeof(T));
return *this;
}
template<class T>
LEInteger<T> LEInteger<T>::operator--(int)
{
LEInteger<T> orig(*this);
--(*this);
return orig;
}
template<class T>
LEInteger<T>& LEInteger<T>::operator++()
{
T storedValue;
memcpy(&storedValue, m_leValueBytes, sizeof(T));
LEInteger_SwapHelper<T>::Swap(storedValue);
storedValue++;
LEInteger_SwapHelper<T>::Swap(storedValue);
memcpy(m_leValueBytes, &storedValue, sizeof(T));
return *this;
}
template<class T>
LEInteger<T> LEInteger<T>::operator++(int)
{
LEInteger<T> orig(*this);
++(*this);
return orig;
}
typedef LEInteger<int16_t> LEInt16_t;
typedef LEInteger<int32_t> LEInt32_t;
typedef LEInteger<uint16_t> LEUInt16_t;
typedef LEInteger<uint32_t> LEUInt32_t;
#pragma once
#include <stdint.h>
template<class T>
struct LEInteger
{
public:
LEInteger();
LEInteger(const LEInteger<T> &other);
explicit LEInteger(T i);
operator T() const;
LEInteger<T> &operator=(T value);
template<class TOther>
LEInteger<T> &operator+=(TOther value);
template<class TOther>
LEInteger<T> &operator-=(TOther value);
template<class TOther>
LEInteger<T> &operator*=(TOther value);
template<class TOther>
LEInteger<T> &operator/=(TOther value);
template<class TOther>
LEInteger<T> &operator%=(TOther value);
LEInteger<T>& operator--();
LEInteger<T> operator--(int);
LEInteger<T>& operator++();
LEInteger<T> operator++(int);
private:
uint8_t m_leValueBytes[sizeof(T)];
};
template<class T>
struct LEInteger_SwapHelper
{
};
#include "ByteSwap.h"
template<>
struct LEInteger_SwapHelper<int16_t>
{
inline static void Swap(int16_t &v)
{
PortabilityLayer::ByteSwap::LittleInt16(v);
}
};
template<>
struct LEInteger_SwapHelper<int32_t>
{
inline static void Swap(int32_t &v)
{
PortabilityLayer::ByteSwap::LittleInt32(v);
}
};
template<>
struct LEInteger_SwapHelper<uint16_t>
{
inline static void Swap(uint16_t &v)
{
PortabilityLayer::ByteSwap::LittleUInt16(v);
}
};
template<>
struct LEInteger_SwapHelper<uint32_t>
{
inline static void Swap(uint32_t &v)
{
PortabilityLayer::ByteSwap::LittleUInt32(v);
}
};
#include <string.h>
template<class T>
inline LEInteger<T>::LEInteger()
{
memset(m_leValueBytes, 0, sizeof(T));
}
template<class T>
inline LEInteger<T>::LEInteger(const LEInteger<T> &other)
{
memcpy(m_leValueBytes, other.m_leValueBytes, sizeof(T));
}
template<class T>
inline LEInteger<T>::LEInteger(T i)
{
LEInteger_SwapHelper<T>::Swap(i);
memcpy(m_leValueBytes, &i, sizeof(T));
}
template<class T>
inline LEInteger<T>::operator T() const
{
T result;
memcpy(&result, m_leValueBytes, sizeof(T));
LEInteger_SwapHelper<T>::Swap(result);
return result;
}
template<class T>
inline LEInteger<T> &LEInteger<T>::operator=(T value)
{
LEInteger_SwapHelper<T>::Swap(value);
memcpy(m_leValueBytes, &value, sizeof(T));
return *this;
}
template<class T>
template<class TOther>
LEInteger<T> &LEInteger<T>::operator+=(TOther value)
{
T storedValue;
memcpy(&storedValue, m_leValueBytes, sizeof(T));
LEInteger_SwapHelper<T>::Swap(storedValue);
storedValue += value;
LEInteger_SwapHelper<T>::Swap(storedValue);
memcpy(m_leValueBytes, &storedValue, sizeof(T));
return *this;
}
template<class T>
template<class TOther>
LEInteger<T> &LEInteger<T>::operator-=(TOther value)
{
T storedValue;
memcpy(&storedValue, m_leValueBytes, sizeof(T));
LEInteger_SwapHelper<T>::Swap(storedValue);
storedValue -= value;
LEInteger_SwapHelper<T>::Swap(storedValue);
memcpy(m_leValueBytes, &storedValue, sizeof(T));
return *this;
}
template<class T>
template<class TOther>
LEInteger<T> &LEInteger<T>::operator*=(TOther value)
{
T storedValue;
memcpy(&storedValue, m_leValueBytes, sizeof(T));
LEInteger_SwapHelper<T>::Swap(storedValue);
storedValue *= value;
LEInteger_SwapHelper<T>::Swap(storedValue);
memcpy(m_leValueBytes, &storedValue, sizeof(T));
return *this;
}
template<class T>
template<class TOther>
LEInteger<T> &LEInteger<T>::operator/=(TOther value)
{
T storedValue;
memcpy(&storedValue, m_leValueBytes, sizeof(T));
LEInteger_SwapHelper<T>::Swap(storedValue);
storedValue /= value;
LEInteger_SwapHelper<T>::Swap(storedValue);
memcpy(m_leValueBytes, &storedValue, sizeof(T));
return *this;
}
template<class T>
template<class TOther>
LEInteger<T> &LEInteger<T>::operator%=(TOther value)
{
T storedValue;
memcpy(&storedValue, m_leValueBytes, sizeof(T));
LEInteger_SwapHelper<T>::Swap(storedValue);
storedValue %= value;
LEInteger_SwapHelper<T>::Swap(storedValue);
memcpy(m_leValueBytes, &storedValue, sizeof(T));
return *this;
}
template<class T>
LEInteger<T>& LEInteger<T>::operator--()
{
T storedValue;
memcpy(&storedValue, m_leValueBytes, sizeof(T));
LEInteger_SwapHelper<T>::Swap(storedValue);
storedValue--;
LEInteger_SwapHelper<T>::Swap(storedValue);
memcpy(m_leValueBytes, &storedValue, sizeof(T));
return *this;
}
template<class T>
LEInteger<T> LEInteger<T>::operator--(int)
{
LEInteger<T> orig(*this);
--(*this);
return orig;
}
template<class T>
LEInteger<T>& LEInteger<T>::operator++()
{
T storedValue;
memcpy(&storedValue, m_leValueBytes, sizeof(T));
LEInteger_SwapHelper<T>::Swap(storedValue);
storedValue++;
LEInteger_SwapHelper<T>::Swap(storedValue);
memcpy(m_leValueBytes, &storedValue, sizeof(T));
return *this;
}
template<class T>
LEInteger<T> LEInteger<T>::operator++(int)
{
LEInteger<T> orig(*this);
++(*this);
return orig;
}
typedef LEInteger<int16_t> LEInt16_t;
typedef LEInteger<int32_t> LEInt32_t;
typedef LEInteger<uint16_t> LEUInt16_t;
typedef LEInteger<uint32_t> LEUInt32_t;