cetlpf.hpp File Reference

#include "cetl/cetl.hpp"
#include "cetl/pf17/cetlpf.hpp"
#include "cetl/pf20/span.hpp"

Include dependency graph for cetlpf.hpp:

Namespaces
namespace	cetl::pf20
namespace	cetl

Typedefs
template<typename T, std::size_t Extent = dynamic_extent>
using	cetl::span = cetl::pf20::span<T, Extent>

Variables
constexpr std::size_t	cetl::dynamic_extent = cetl::pf20::dynamic_extent

Detailed Description

CETL polyfill header for C++20 types.

Copyright

Copyright (C) OpenCyphal Development Team <opencyphal.org> Copyright Amazon.com Inc. or its affiliates. SPDX-License-Identifier: MIT

Warning

This header violates AUTOSAR-14 M7-3-6, A17-0-1, and A16-0-1 (and possibly other rules). Don't use CETL polyfill headers in AUTOSAR code.

polyfill headers cannot be used if CETL_H_ERASE is defined.

CETL polyfill headers will provide the CETL type as an aliased standard type in the std namespace when compiling using older C++ libraries and will automatically provide types from the standard library when compiling using newer C++ libraries. This allows for causal use of CETL as a true polyfill library but does violate certain coding standards. As such, for more critical software we recommend not using these headers but including the types you use from cetl::pf20 directly.

For example, using the polyfill header you can write a program where the code automatically switches to using the C++ 20 version of span when compiling with that standard enabled:

std::string            greeting{"Hello Dynamic World."};
 
// the cetl/pf20/cetlpf.hpp header will automatically define cetl::span
// based on the C++ standard available to the compiler. If < 20 then
// it will be the CETL version, if >= 20 then it will be the std version.
cetl::span<const char> dynamic{greeting.c_str(), 13};
auto                   print = [](const char c) { std::cout << c; };
 
// Print just the characters in the span...
std::for_each(dynamic.begin(), dynamic.end(), print);
std::cout << std::endl;
 
// or...
std::string substring{dynamic.begin(), dynamic.end()};
std::cout << substring << std::endl;

For more critical code you can define a custom span type can be easily redefined later without using the automatic polyfill header:

// Define these in a header or something...
constexpr std::size_t my_dynamic_extent = cetl::pf20::dynamic_extent;
 
template <typename T, std::size_t Extent = my_dynamic_extent>
using my_span = cetl::pf20::span<T, Extent>;
 

std::string         greeting{"Hello Dynamic World."};
 
// now use my_span instead of cetl::span and you only have one place
// to change to std::span when you upgrade your compiler.
my_span<const char> dynamic{greeting.c_str(), 13};
auto                print = [](const char c) { std::cout << c; };
 
// Print just the characters in the span...
std::for_each(dynamic.begin(), dynamic.end(), print);
std::cout << std::endl;
 
// or...
std::string substring{dynamic.begin(), dynamic.end()};
std::cout << substring << std::endl;
 

When doing this you might want to add an assert to ensure you don't forget to redefine your custom type:

static_assert(__cplusplus < CETL_CPP_STANDARD_20, "Don't use CETL if you are compiling for C++20.");

(See full example here...)