Common.h File Reference

#include <memory>
#include <utility>

Include dependency graph for Common.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	FourCC< a, b, c, d >
	Creates a four-character code (FourCC) value from template parameters. More...

Namespaces
namespace	uniot
	Contains all classes and functions related to the Uniot Core.

Macros
#define	COUNT_OF(arr)
	Calculates the number of elements in a statically allocated array.
#define	ARRAY_ELEMENT_SAFE(arr, index)
	Provides safe array access with bounds checking.
#define	FOURCC(name)
	Creates a FourCC constant from a string literal.
#define	ALIAS_IMPLICIT_FUNCTION(high, low)
	Creates an alias for a function that forwards all arguments implicitly.
#define	ALIAS_EXPLICIT_FUNCTION(high, low)
	Creates an alias for a template function that forwards all arguments explicitly.

Functions
template<typename... Args>
void	UNUSED (Args &&...args)
	Utility function to mark function parameters as intentionally unused.
uint32_t	CRC32 (const void *data, size_t length, uint32_t crc=0)
	Calculates CRC32-C (Castagnoli) checksum for data integrity verification.
template<typename T>
using	uniot::UniquePointer = std::unique_ptr<T>
	Type alias for std::unique_ptr with cleaner syntax.
template<typename T>
using	uniot::SharedPointer = std::shared_ptr<T>
	Type alias for std::shared_ptr with cleaner syntax.
template<typename T_First, typename T_Second>
using	uniot::Pair = std::pair<T_First, T_Second>
	Type alias for std::pair with cleaner syntax.
template<typename T, typename... Args>
auto	uniot::MakeShared (Args &&...args) -> decltype(std::make_shared< T >(std::forward< Args >(args)...))
	Creates a shared pointer instance, alias for std::make_shared.
template<typename T, typename... Args>
auto	uniot::MakeUnique (Args &&...args) -> decltype(std::make_unique< T >(std::forward< Args >(args)...))
	Creates a unique pointer instance, alias for std::make_unique.
template<typename... Args>
auto	uniot::MakePair (Args &&...args) -> decltype(std::make_pair(std::forward< Args >(args)...))
	Creates a pair instance, alias for std::make_pair.