The literals.h File Reference

C++ header file with declarations for the µTest++ user-defined literals and type wrappers. More...

Included Headers

#include <cstdint>
#include "type-traits.h"
#include "math.h"

Namespaces Index

namespace	micro_os_plus
	The primary namespace for the µOS++ framework. More...
namespace	micro_os_plus::micro_test_plus
	Primary namespace for the µTest++ testing framework. More...
namespace	micro_os_plus::micro_test_plus::literals
	User-defined literals and type wrappers for the µTest++ testing framework. More...

Classes Index

struct	_t<T>
	Deprecated generic strongly-typed wrapper for explicit type conversion. More...
struct	to_t<T>
	Generic strongly-typed wrapper for explicit type conversion. More...

Operators Index

constexpr auto	operator""_b (const char *name, decltype(sizeof("")) size)
	User-defined literal operator to convert to bool. More...
template <char... Cs>
constexpr auto	operator""_c ()
	User-defined literal operator to convert to char. More...
template <char... Cs>
constexpr auto	operator""_d ()
	User-defined literal operator to convert to double. More...
template <char... Cs>
constexpr auto	operator""_f ()
	User-defined literal operator to convert to float. More...
template <char... Cs>
constexpr auto	operator""_i ()
	User-defined literal operator to convert to int. More...
template <char... Cs>
constexpr auto	operator""_i16 ()
	User-defined literal operator to convert to int16_t. More...
template <char... Cs>
constexpr auto	operator""_i32 ()
	User-defined literal operator to convert to int32_t. More...
template <char... Cs>
constexpr auto	operator""_i64 ()
	User-defined literal operator to convert to int64_t. More...
template <char... Cs>
constexpr auto	operator""_i8 ()
	User-defined literal operator to convert to int8_t. More...
template <char... Cs>
constexpr auto	operator""_l ()
	User-defined literal operator to convert to long. More...
template <char... Cs>
constexpr auto	operator""_ld ()
	User-defined literal operator to convert to long double. More...
template <char... Cs>
constexpr auto	operator""_ll ()
	User-defined literal operator to convert to long long. More...
template <char... Cs>
constexpr auto	operator""_s ()
	User-defined literal operator to convert to short. More...
template <char... Cs>
constexpr auto	operator""_sc ()
	User-defined literal operator to convert to signed char. More...
template <char... Cs>
constexpr auto	operator""_u ()
	User-defined literal operator to convert to unsigned. More...
template <char... Cs>
constexpr auto	operator""_u16 ()
	User-defined literal operator to convert to uint16_t. More...
template <char... Cs>
constexpr auto	operator""_u32 ()
	User-defined literal operator to convert to uint32_t. More...
template <char... Cs>
constexpr auto	operator""_u64 ()
	User-defined literal operator to convert to uint64_t. More...
template <char... Cs>
constexpr auto	operator""_u8 ()
	User-defined literal operator to convert to uint8_t. More...
template <char... Cs>
constexpr auto	operator""_uc ()
	User-defined literal operator to convert to unsigned char. More...
template <char... Cs>
constexpr auto	operator""_ul ()
	User-defined literal operator to convert to unsigned long. More...
template <char... Cs>
constexpr auto	operator""_ull ()
	User-defined literal operator to convert to unsigned long long. More...
template <char... Cs>
constexpr auto	operator""_us ()
	User-defined literal operator to convert to unsigned short. More...

Deprecated Type Wrappers Index

using	_b = type_traits::value< bool >
	Strongly-typed wrapper for bool values. More...
using	_c = type_traits::value< char >
	Strongly-typed wrapper for char values. More...
using	_d = type_traits::value< double >
	Strongly-typed wrapper for double values. More...
using	_f = type_traits::value< float >
	Strongly-typed wrapper for float values. More...
using	_i = type_traits::value< int >
	Strongly-typed wrapper for int values. More...
using	_i16 = type_traits::value< std::int16_t >
	Strongly-typed wrapper for std::int16_t values. More...
using	_i32 = type_traits::value< std::int32_t >
	Strongly-typed wrapper for std::int32_t values. More...
using	_i64 = type_traits::value< std::int64_t >
	Strongly-typed wrapper for std::int64_t values. More...
using	_i8 = type_traits::value< std::int8_t >
	Strongly-typed wrapper for std::int8_t values. More...
using	_l = type_traits::value< long >
	Strongly-typed wrapper for long values. More...
using	_ld = type_traits::value< long double >
	Strongly-typed wrapper for long double values. More...
using	_ll = type_traits::value< long long >
	Strongly-typed wrapper for long long values. More...
using	_s = type_traits::value< short >
	Strongly-typed wrapper for short values. More...
using	_sc = type_traits::value< signed char >
	Strongly-typed wrapper for signed char values. More...
using	_u = type_traits::value< unsigned >
	Strongly-typed wrapper for unsigned values. More...
using	_u16 = type_traits::value< std::uint16_t >
	Strongly-typed wrapper for std::uint16_t values. More...
using	_u32 = type_traits::value< std::uint32_t >
	Strongly-typed wrapper for std::uint32_t values. More...
using	_u64 = type_traits::value< std::uint64_t >
	Strongly-typed wrapper for std::uint64_t values. More...
using	_u8 = type_traits::value< std::uint8_t >
	Strongly-typed wrapper for std::uint8_t values. More...
using	_uc = type_traits::value< unsigned char >
	Strongly-typed wrapper for unsigned char values. More...
using	_ul = type_traits::value< unsigned long >
	Strongly-typed wrapper for unsigned long values. More...
using	_ull = type_traits::value< unsigned long long >
	Strongly-typed wrapper for unsigned long long values. More...
using	_us = type_traits::value< unsigned short >
	Strongly-typed wrapper for unsigned short values. More...

Type Wrappers Index

using	to_b = type_traits::value< bool >
	Strongly-typed wrapper for bool values. More...
using	to_c = type_traits::value< char >
	Strongly-typed wrapper for char values. More...
using	to_d = type_traits::value< double >
	Strongly-typed wrapper for double values. More...
using	to_f = type_traits::value< float >
	Strongly-typed wrapper for float values. More...
using	to_i = type_traits::value< int >
	Strongly-typed wrapper for int values. More...
using	to_i16 = type_traits::value< std::int16_t >
	Strongly-typed wrapper for std::int16_t values. More...
using	to_i32 = type_traits::value< std::int32_t >
	Strongly-typed wrapper for std::int32_t values. More...
using	to_i64 = type_traits::value< std::int64_t >
	Strongly-typed wrapper for std::int64_t values. More...
using	to_i8 = type_traits::value< std::int8_t >
	Strongly-typed wrapper for std::int8_t values. More...
using	to_l = type_traits::value< long >
	Strongly-typed wrapper for long values. More...
using	to_ld = type_traits::value< long double >
	Strongly-typed wrapper for long double values. More...
using	to_ll = type_traits::value< long long >
	Strongly-typed wrapper for long long values. More...
using	to_s = type_traits::value< short >
	Strongly-typed wrapper for short values. More...
using	to_sc = type_traits::value< signed char >
	Strongly-typed wrapper for signed char values. More...
using	to_u = type_traits::value< unsigned >
	Strongly-typed wrapper for unsigned values. More...
using	to_u16 = type_traits::value< std::uint16_t >
	Strongly-typed wrapper for std::uint16_t values. More...
using	to_u32 = type_traits::value< std::uint32_t >
	Strongly-typed wrapper for std::uint32_t values. More...
using	to_u64 = type_traits::value< std::uint64_t >
	Strongly-typed wrapper for std::uint64_t values. More...
using	to_u8 = type_traits::value< std::uint8_t >
	Strongly-typed wrapper for std::uint8_t values. More...
using	to_uc = type_traits::value< unsigned char >
	Strongly-typed wrapper for unsigned char values. More...
using	to_ul = type_traits::value< unsigned long >
	Strongly-typed wrapper for unsigned long values. More...
using	to_ull = type_traits::value< unsigned long long >
	Strongly-typed wrapper for unsigned long long values. More...
using	to_us = type_traits::value< unsigned short >
	Strongly-typed wrapper for unsigned short values. More...

Description

C++ header file with declarations for the µTest++ user-defined literals and type wrappers.

This header provides the declarations for the user-defined literal operators and type wrappers used within the µTest++ framework. It defines interfaces for generating strongly-typed integral, floating-point, and boolean constants at compile time, enabling expressive and type-safe test expressions.

The declared literal operators support a wide range of C++ fundamental types, allowing constants to be suffixed with type-specific identifiers (such as _i, _u16, _f, _d, _b, etc.) to produce values that integrate seamlessly with the µTest++ comparators and reporting mechanisms.

In addition to literal operators, this header declares both deprecated and modern type wrappers for explicit type conversion, supporting enhanced clarity and type safety in test conditions. The preferred to_* forms are recommended for new code, while the older _i, _u8, etc. aliases are retained for backwards compatibility.

All definitions reside within the micro_os_plus::micro_test_plus::literals namespace, ensuring clear separation from user code and minimising the risk of naming conflicts.

The header files are organised within the include/micro-os-plus/micro-test-plus folder to maintain a structured and modular codebase.

This file is intended for internal use within the framework and should not be included directly by user code.

File Listing

The file content with the documentation metadata removed is:

1/*

2 * This file is part of the µOS++ project (https://micro-os-plus.github.io/).

3 * Copyright (c) 2021 Liviu Ionescu. All rights reserved.

4 *

5 * Permission to use, copy, modify, and/or distribute this software

6 * for any purpose is hereby granted, under the terms of the MIT license.

7 *

8 * If a copy of the license was not distributed with this file, it can

9 * be obtained from https://opensource.org/licenses/mit.

10 *

11 * Major parts of the code are inspired from v1.1.8 of the Boost UT project,

12 * released under the terms of the Boost Version 1 Software License,

13 * which can be obtained from https://www.boost.org/LICENSE_1_0.txt.

14 */

15

16// ----------------------------------------------------------------------------

17

52

53#ifndef MICRO_TEST_PLUS_LITERALS_H_

54#define MICRO_TEST_PLUS_LITERALS_H_

55

56// ----------------------------------------------------------------------------

57

58#ifdef __cplusplus

59

60// ----------------------------------------------------------------------------

61

62#include <cstdint>

63#include "type-traits.h"

64#include "math.h"

65

66// ----------------------------------------------------------------------------

67

68#if defined(__GNUC__)

69#pragma GCC diagnostic push

70#pragma GCC diagnostic ignored "-Waggregate-return"

71#if defined(__clang__)

72#pragma clang diagnostic ignored "-Wc++98-compat"

73#pragma clang diagnostic ignored "-Wc++98-compat-pedantic"

74#endif

75#endif

76

77namespace micro_os_plus::micro_test_plus

78{

79 // --------------------------------------------------------------------------

80

106 namespace literals

107 {

118 template <char... Cs>

119 [[nodiscard]] constexpr auto

120 operator""_i ();

121

132 template <char... Cs>

133 [[nodiscard]] constexpr auto

134 operator""_s ();

135

146 template <char... Cs>

147 [[nodiscard]] constexpr auto

148 operator""_c ();

149

160 template <char... Cs>

161 [[nodiscard]] constexpr auto

162 operator""_sc ();

163

174 template <char... Cs>

175 [[nodiscard]] constexpr auto

176 operator""_l ();

177

188 template <char... Cs>

189 [[nodiscard]] constexpr auto

190 operator""_ll ();

191

202 template <char... Cs>

203 [[nodiscard]] constexpr auto

204 operator""_u ();

205

216 template <char... Cs>

217 [[nodiscard]] constexpr auto

218 operator""_uc ();

219

230 template <char... Cs>

231 [[nodiscard]] constexpr auto

232 operator""_us ();

233

244 template <char... Cs>

245 [[nodiscard]] constexpr auto

246 operator""_ul ();

247

258 template <char... Cs>

259 [[nodiscard]] constexpr auto

260 operator""_ull ();

261

272 template <char... Cs>

273 [[nodiscard]] constexpr auto

274 operator""_i8 ();

275

286 template <char... Cs>

287 [[nodiscard]] constexpr auto

288 operator""_i16 ();

289

300 template <char... Cs>

301 [[nodiscard]] constexpr auto

302 operator""_i32 ();

303

314 template <char... Cs>

315 [[nodiscard]] constexpr auto

316 operator""_i64 ();

317

329 template <char... Cs>

330 [[nodiscard]] constexpr auto

331 operator""_u8 ();

332

343 template <char... Cs>

344 [[nodiscard]] constexpr auto

345 operator""_u16 ();

346

357 template <char... Cs>

358 [[nodiscard]] constexpr auto

359 operator""_u32 ();

360

371 template <char... Cs>

372 [[nodiscard]] constexpr auto

373 operator""_u64 ();

374

385 template <char... Cs>

386 [[nodiscard]] constexpr auto

387 operator""_f ();

388

399 template <char... Cs>

400 [[nodiscard]] constexpr auto

401 operator""_d ();

402

413 template <char... Cs>

414 [[nodiscard]] constexpr auto

415 operator""_ld ();

416

426 constexpr auto

427 operator""_b (const char* name, decltype (sizeof ("")) size);

428

429 // ------------------------------------------------------------------------

430 } // namespace literals

431

432 // --------------------------------------------------------------------------

433

434#if defined(__GNUC__)

435#pragma GCC diagnostic push

436#if defined(__clang__)

437#pragma clang diagnostic ignored "-Wdocumentation-deprecated-sync"

438#endif

439#endif

440

445

462

468 using _b = type_traits::value<bool>;

469

475 using _c = type_traits::value<char>;

476

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

483

489 using _s = type_traits::value<short>;

490

496 using _i = type_traits::value<int>;

497

503 using _l = type_traits::value<long>;

504

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

511

517 using _u = type_traits::value<unsigned>;

518

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

525

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

532

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

539

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

546

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

553

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

560

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

567

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

574

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

581

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

588

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

595

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

602

607 using _f = type_traits::value<float>;

608

613 using _d = type_traits::value<double>;

614

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

621

638 template <class T>

639 struct _t : type_traits::value<T>

640 {

650 constexpr explicit _t (const T& t) : type_traits::value<T>{ t }

651 {

652 }

653 };

654

655#if defined(__GNUC__)

656#pragma GCC diagnostic pop

657#endif

658

684

690 using to_b = type_traits::value<bool>;

691

697 using to_c = type_traits::value<char>;

698

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

705

711 using to_s = type_traits::value<short>;

712

718 using to_i = type_traits::value<int>;

719

725 using to_l = type_traits::value<long>;

726

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

733

739 using to_u = type_traits::value<unsigned>;

740

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

747

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

754

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

761

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

768

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

775

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

782

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

789

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

796

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

803

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

810

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

817

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

824

830 using to_f = type_traits::value<float>;

831

837 using to_d = type_traits::value<double>;

838

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

845

849

880 template <class T>

881 struct to_t : type_traits::value<T>

882 {

892 constexpr explicit to_t (const T& t) : type_traits::value<T>{ t }

893 {

894 }

895 };

896

897 // --------------------------------------------------------------------------

898} // namespace micro_os_plus::micro_test_plus

899

900#if defined(__GNUC__)

901#pragma GCC diagnostic pop

902#endif

903

904// ----------------------------------------------------------------------------

905

906#endif // __cplusplus

907

908// ----------------------------------------------------------------------------

909

910#endif // MICRO_TEST_PLUS_LITERALS_H_

911

912// ----------------------------------------------------------------------------

---

Generated via docusaurus-plugin-doxygen by Doxygen 1.14.0.