# Juliet\include\Core\Common\CoreTypes

## Source Files
- Header: `Juliet\include\Core\Common\CoreTypes.h`

## AI Description
The `CoreTypes.h` header file in the Juliet project is designed to provide a unified set of fundamental data types and utilities for common operations such as byte manipulation, size calculations, and limits. The primary purpose of this component is to ensure consistency and ease of use across different parts of the application by providing clear and standardized definitions for basic data types like `uint8`, `int8`, `size_t`, etc.

The header file includes several key components:

1. **Data Types**:
   - `Byte`: A byte type aliasing `std::byte` from the C++ Standard Library, which is a portable way to represent bytes.
   - `uint8`, `uint16`, `uint32`, `uint64`: Aliases for unsigned 8-bit, 16-bit, 32-bit, and 64-bit integers, respectively. These types are used for representing data in various formats such as network packets or file sizes.
   - `int8`, `int16`, `int32`, `int64`: Aliases for signed 8-bit, 16-bit, 32-bit, and 64-bit integers. These types are suitable for handling integer values in applications that require signed data.

2. **Size and Index Types**:
   - `size_t` and `index_t`: Aliasing `std::size_t` from the C++ Standard Library, which is a type used to represent the size of objects or collections. This type ensures that all sizes are handled consistently across different platforms.
   - These types are used for indexing arrays, managing memory allocations, and other operations where size information is crucial.

3. **ByteBuffer**:
   - A struct `ByteBuffer` is defined to encapsulate a byte buffer along with its size. This structure is useful for handling binary data efficiently in applications that require dynamic memory management or serialization/deserialization of data.

4. **Function Pointer Type**:
   - A function pointer type `FunctionPtr` is defined using `auto (*)(void) -? void`. This type is used to represent pointers to functions that take no arguments and return void, which is commonly used for callbacks or event handlers in applications.

5. **Limits Calculation Functions**:
   - The `MaxValueOf?Type?` template function calculates the maximum value that can be represented by a given integer type using `std::numeric_limits`. This utility function simplifies the process of finding the upper limit of different data types, making it easier to handle and validate data within the application.

6. **Size Conversion Macros**:
   - The macros `Kilobytes` and `Megabytes` are defined to convert between kilobytes and megabytes. These macros provide a convenient way to perform size calculations without having to manually multiply by 1024 each time.

The design of this header file is aimed at promoting consistency in data types across the project, ensuring that all parts of

## Symbols

### Global Scope

#### Classes, Structs & Unions
- `struct ByteBuffer`

