BuiltInTypes.h

Go to the documentation of this file.

//-
// =============================================================================
// Copyright 2024 Autodesk, Inc. All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// =============================================================================
//+
 
 
#ifndef AMINO_BUILTIN_TYPES_H
#define AMINO_BUILTIN_TYPES_H
 
#include <type_traits>
 
namespace Amino {
 
//==============================================================================
// TYPE ALIASES
//==============================================================================
 
 
using char_t = signed char;
 
using short_t = signed short;
 
using int_t = signed int;
 
using long_t = signed long long;
 
using uchar_t = unsigned char;
 
using ushort_t = unsigned short;
 
using uint_t = unsigned int;
 
using ulong_t = unsigned long long;
 
using float_t = float;
 
using double_t = double;
 
using bool_t = bool;
 
using enum_underlying_t = int_t;
 
enum class enum_t : enum_underlying_t {};
 
 
//==============================================================================
// STATIC ASSERTIONS
//==============================================================================
 
// These assertions are present mainly for the purposes of verifying that the
// setting of the end-user compiler are appropriate. This validates the
// assumptions made by the Amino compiler.
 
static_assert(
    std::is_same<std::underlying_type_t<enum_t>, enum_underlying_t>::value,
    "enum_t's underlying type mismatch.");
 
// clang-format off
static_assert(sizeof(char_t  ) == 1,   "char_t should be a  8-bit integer");
static_assert(sizeof(short_t ) == 2,  "short_t should be a 16-bit integer");
static_assert(sizeof(int_t   ) == 4,    "int_t should be a 32-bit integer");
static_assert(sizeof(long_t  ) == 8,   "long_t should be a 64-bit integer");
 
static_assert(sizeof(uchar_t ) == 1,  "uchar_t should be a  8-bit integer");
static_assert(sizeof(ushort_t) == 2, "ushort_t should be a 16-bit integer");
static_assert(sizeof(uint_t  ) == 4,   "uint_t should be a 32-bit integer");
static_assert(sizeof(ulong_t ) == 8,  "ulong_t should be a 64-bit integer");
 
static_assert(sizeof(float_t ) == 4,  "float_t should be a 32-bit number");
static_assert(sizeof(double_t) == 8, "double_t should be a 64-bit number");
 
static_assert(sizeof(bool_t  ) == 1, "bool_t should occupy one byte");
static_assert(sizeof(enum_t  ) == 4, "enum_t should be a 32-bit integer");
// clang-format on
 
// clang-format off
static_assert(std::is_integral<char_t  >::value,   "char_t should be an integer");
static_assert(std::is_integral<short_t >::value,  "short_t should be an integer");
static_assert(std::is_integral<int_t   >::value,    "int_t should be an integer");
static_assert(std::is_integral<long_t  >::value,   "long_t should be an integer");
static_assert(std::is_integral<uchar_t >::value,  "uchar_t should be an integer");
static_assert(std::is_integral<ushort_t>::value, "ushort_t should be an integer");
static_assert(std::is_integral<uint_t  >::value,   "uint_t should be an integer");
static_assert(std::is_integral<ulong_t >::value,  "ulong_t should be an integer");
static_assert(std::is_integral<bool_t  >::value,   "bool_t should be an integer");
// clang-format on
 
static_assert(
    std::is_floating_point<float_t>::value,
    "float_t should be a floating point number");
static_assert(
    std::is_floating_point<double_t>::value,
    "double_t should be a floating point number");
static_assert(
    std::is_integral<enum_underlying_t>::value,
    "enum_t's underlying type should be an integer");
 
// clang-format off
static_assert(std::is_signed<char_t >::value,  "char_t should be signed");
static_assert(std::is_signed<short_t>::value, "short_t should be signed");
static_assert(std::is_signed<int_t  >::value,   "int_t should be signed");
static_assert(std::is_signed<long_t >::value,  "long_t should be signed");
 
static_assert(std::is_unsigned<uchar_t >::value,  "uchar_t should be unsigned");
static_assert(std::is_unsigned<ushort_t>::value, "ushort_t should be unsigned");
static_assert(std::is_unsigned<uint_t  >::value,   "uint_t should be unsigned");
static_assert(std::is_unsigned<ulong_t >::value,  "ulong_t should be unsigned");
 
static_assert(std::is_unsigned<bool_t >::value,    "bool_t should be unsigned");
// clang-format on
 
static_assert(
    std::is_signed<enum_underlying_t>::value,
    "enum_t's underlying type should be signed");
 
} // namespace Amino
 
#endif // AMINO_AMINOBUILTINTYPES_H