literals.h

Go to the documentation of this file.

/*
 * This file is part of the µOS++ project (https://micro-os-plus.github.io/).
 * Copyright (c) 2021 Liviu Ionescu. All rights reserved.
 *
 * Permission to use, copy, modify, and/or distribute this software
 * for any purpose is hereby granted, under the terms of the MIT license.
 *
 * If a copy of the license was not distributed with this file, it can
 * be obtained from https://opensource.org/licenses/mit.
 *
 * Major parts of the code are inspired from v1.1.8 of the Boost UT project,
 * released under the terms of the Boost Version 1.0 Software License,
 * which can be obtained from https://www.boost.org/LICENSE_1_0.txt.
 */
 
// ----------------------------------------------------------------------------

 
#ifndef MICRO_TEST_PLUS_LITERALS_H_
#define MICRO_TEST_PLUS_LITERALS_H_
 
// ----------------------------------------------------------------------------
 
#ifdef __cplusplus
 
// ----------------------------------------------------------------------------
 
#include <cstdint>
#include "type-traits.h"
#include "math.h"
 
// ----------------------------------------------------------------------------
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Waggregate-return"
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wc++98-compat"
#pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
#endif
#endif
 
namespace micro_os_plus::micro_test_plus
{
  // --------------------------------------------------------------------------

  namespace literals
  {
    template <char... Cs>
    [[nodiscard]] constexpr auto
    operator""_i ();

    template <char... Cs>
    [[nodiscard]] constexpr auto
    operator""_s ();

    template <char... Cs>
    [[nodiscard]] constexpr auto
    operator""_c ();

    template <char... Cs>
    [[nodiscard]] constexpr auto
    operator""_sc ();

    template <char... Cs>
    [[nodiscard]] constexpr auto
    operator""_l ();

    template <char... Cs>
    [[nodiscard]] constexpr auto
    operator""_ll ();

    template <char... Cs>
    [[nodiscard]] constexpr auto
    operator""_u ();

    template <char... Cs>
    [[nodiscard]] constexpr auto
    operator""_uc ();

    template <char... Cs>
    [[nodiscard]] constexpr auto
    operator""_us ();

    template <char... Cs>
    [[nodiscard]] constexpr auto
    operator""_ul ();

    template <char... Cs>
    [[nodiscard]] constexpr auto
    operator""_ull ();

    template <char... Cs>
    [[nodiscard]] constexpr auto
    operator""_i8 ();

    template <char... Cs>
    [[nodiscard]] constexpr auto
    operator""_i16 ();

    template <char... Cs>
    [[nodiscard]] constexpr auto
    operator""_i32 ();

    template <char... Cs>
    [[nodiscard]] constexpr auto
    operator""_i64 ();

    template <char... Cs>
    [[nodiscard]] constexpr auto
    operator""_u8 ();

    template <char... Cs>
    [[nodiscard]] constexpr auto
    operator""_u16 ();

    template <char... Cs>
    [[nodiscard]] constexpr auto
    operator""_u32 ();

    template <char... Cs>
    [[nodiscard]] constexpr auto
    operator""_u64 ();

    template <char... Cs>
    [[nodiscard]] constexpr auto
    operator""_f ();

    template <char... Cs>
    [[nodiscard]] constexpr auto
    operator""_d ();

    template <char... Cs>
    [[nodiscard]] constexpr auto
    operator""_ld ();

    constexpr auto
    operator""_b (const char* name, decltype (sizeof ("")) size);
 
    // ------------------------------------------------------------------------
  } // namespace literals
 
  // --------------------------------------------------------------------------
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wdocumentation-deprecated-sync"
#endif
#endif



  using _b = type_traits::value<bool>;

  using _c = type_traits::value<char>;

  using _sc = type_traits::value<signed char>;

  using _s = type_traits::value<short>;

  using _i = type_traits::value<int>;

  using _l = type_traits::value<long>;

  using _ll = type_traits::value<long long>;

  using _u = type_traits::value<unsigned>;

  using _uc = type_traits::value<unsigned char>;

  using _us = type_traits::value<unsigned short>;

  using _ul = type_traits::value<unsigned long>;

  using _ull = type_traits::value<unsigned long long>;

  using _i8 = type_traits::value<std::int8_t>;

  using _i16 = type_traits::value<std::int16_t>;

  using _i32 = type_traits::value<std::int32_t>;

  using _i64 = type_traits::value<std::int64_t>;

  using _u8 = type_traits::value<std::uint8_t>;

  using _u16 = type_traits::value<std::uint16_t>;

  using _u32 = type_traits::value<std::uint32_t>;

  using _u64 = type_traits::value<std::uint64_t>;

  using _f = type_traits::value<float>;

  using _d = type_traits::value<double>;

  using _ld = type_traits::value<long double>;

  template <class T>
  struct _t : type_traits::value<T>
  {
    constexpr explicit _t (const T& t) : type_traits::value<T>{ t }
    {
    }
  };
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif


  using to_b = type_traits::value<bool>;

  using to_c = type_traits::value<char>;

  using to_sc = type_traits::value<signed char>;

  using to_s = type_traits::value<short>;

  using to_i = type_traits::value<int>;

  using to_l = type_traits::value<long>;

  using to_ll = type_traits::value<long long>;

  using to_u = type_traits::value<unsigned>;

  using to_uc = type_traits::value<unsigned char>;

  using to_us = type_traits::value<unsigned short>;

  using to_ul = type_traits::value<unsigned long>;

  using to_ull = type_traits::value<unsigned long long>;

  using to_i8 = type_traits::value<std::int8_t>;

  using to_i16 = type_traits::value<std::int16_t>;

  using to_i32 = type_traits::value<std::int32_t>;

  using to_i64 = type_traits::value<std::int64_t>;

  using to_u8 = type_traits::value<std::uint8_t>;

  using to_u16 = type_traits::value<std::uint16_t>;

  using to_u32 = type_traits::value<std::uint32_t>;

  using to_u64 = type_traits::value<std::uint64_t>;

  using to_f = type_traits::value<float>;

  using to_d = type_traits::value<double>;

  using to_ld = type_traits::value<long double>;


  template <class T>
  struct to_t : type_traits::value<T>
  {
    constexpr explicit to_t (const T& t) : type_traits::value<T>{ t }
    {
    }
  };
 
  // --------------------------------------------------------------------------
} // namespace micro_os_plus::micro_test_plus
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
 
// ----------------------------------------------------------------------------
 
#endif // __cplusplus
 
// ----------------------------------------------------------------------------
 
#endif // MICRO_TEST_PLUS_LITERALS_H_
 
// ----------------------------------------------------------------------------