Namespace zmbt¶

ZMBT root namespace. More...

Namespaces¶

Type	Name
namespace	api Framework API with fixture classes and entries from main ns.
namespace	appconfig Test application configuration (work in progress)
namespace	decor Signal type decorators API.
namespace	expr Expression Language API.
namespace	lang Expression Language implementation.
namespace	logging Logging (work in progress)
namespace	mapping Signal Mapping model functionality.
namespace	reflect Reflection metafunctions.

Classes¶

Type	Name
class	Environment Controlled environment data storage.
struct	EnvironmentData Data container for the Environment .
class	Generator
class	JsonIter Boost JSON array iterator interface.
class	JsonIterZipProdBase Boost JSON array iterator base for zip or cartesian product.
class	JsonNode Mutator/accessor wrapper over shared JSON value.
class	JsonProdIter Cartesian Product Iterator.
class	JsonTraverse Boost JSON value depth-first traverser.
class	JsonZipIter Zip Iterator.
class	Param Generic Parameter Placeholder.
class	Trigger Controlled environment interface executor.
class	TriggerIfc Function wrapper. Transforms `(T...) -> R` or`(O*)(T...) -> R` to`(shared_ptr<void>, JSON) -> JSON` __
class	TriggerObj Object handler to be used with TriggerIfc .
struct	base_error ZMBT Base exception.
class	entity_id Base class for annotated key objects.
struct	environment_error Environment operation error.
struct	expression_error Expression evaluation error.
struct	expression_not_implemented Expression not implemented.
struct	has_bit_and <class T, class E>
struct	has_bit_or <class T, class E>
struct	has_bit_xor <class T, class E>
struct	has_complement <class T, class E>
struct	has_divides <class T, class E>
struct	has_equal_to <class T, class E>
struct	has_greater <class T, class E>
struct	has_greater_equal <class T, class E>
struct	has_left_shift <class T, class E>
struct	has_less <class T, class E>
struct	has_less_equal <class T, class E>
struct	has_logical_and <class T, class E>
struct	has_logical_not <class T, class E>
struct	has_logical_or <class T, class E>
struct	has_minus <class T, class E>
struct	has_modulus <class T, class E>
struct	has_multiplies <class T, class E>
struct	has_negate <class T, class E>
struct	has_not_equal_to <class T, class E>
struct	has_plus <class T, class E>
struct	has_right_shift <class T, class E>
struct	has_serialization <class T, class E>
struct	ifc_args <class T>
struct	ifc_handle <class T>
struct	ifc_host <class T, class>
struct	ifc_pointer <class T>
struct	ifc_return <class T>
class	interface_id Pointer-based interface id with type annotation.
struct	is_const_iterable <class, class> Variable template that checks if a type has begin() and end() member functions.
struct	model_error Model definition error.
class	object_id Pointer-based object id with type annotation.
struct	serialization_error Failed serialization.
struct	test_assertion_failure Failed test assertion.
struct	type_tag <class T> Type tag to pass template parameters as function arguments.

Public Types¶

Type	Name
enum	ChannelKind
enum	FileFormat
typedef std::add_const< T >	add_const
typedef typename add_const< T >::type	add_const_t
typedef std::add_cv< T >	add_cv
typedef typename add_cv< T >::type	add_cv_t
typedef std::add_lvalue_reference< T >	add_lvalue_reference
typedef typename add_lvalue_reference< T >::type	add_lvalue_reference_t
typedef std::add_pointer< T >	add_pointer
typedef typename add_pointer< T >::type	add_pointer_t
typedef std::add_rvalue_reference< T >	add_rvalue_reference
typedef typename add_rvalue_reference< T >::type	add_rvalue_reference_t
typedef std::add_volatile< T >	add_volatile
typedef typename add_volatile< T >::type	add_volatile_t
typedef integral_constant< bool, V >	bool_constant
typedef std::common_type< T... >	common_type
typedef typename common_type< T... >::type	common_type_t
typedef std::conditional< B, T, F >	conditional
typedef typename conditional< B, T, F >::type	conditional_t
typedef std::decay< T >	decay
typedef typename decay< T >::type	decay_t
typedef mp_if< mp_any< C... >, R >	first_if_any_t
typedef mp_if< mp_not< mp_any< C... > >, R >	first_if_none_t
typedef mp_if< mp_all< C... >, R >	first_if_t
typedef std::has_virtual_destructor< T >	has_virtual_destructor
typedef typename ifc_args< T >::type	ifc_args_t
typedef typename ifc_handle< T >::type	ifc_handle_t
typedef typename ifc_host< T >::type	ifc_host_t
typedef mp_any< ifc_is_fn_ref< T >, ifc_is_fn_ptr< T > >	ifc_is_fn_handle
typedef mp_all< is_pointer< T >, is_function< remove_pointer_t< D > > >	ifc_is_fn_ptr
typedef mp_all< is_lvalue_reference< T >, is_function< remove_pointer_t< D > > >	ifc_is_fn_ref
typedef mp_any< ifc_is_functor_ptr< T >, ifc_is_functor_ref< T > >	ifc_is_functor_handle
typedef mp_all< is_pointer< P >, is_class< D >, detail::support_calltraits_function< D > >	ifc_is_functor_ptr
typedef mp_all< is_reference< T >, is_class< D >, detail::support_calltraits_function< D > >	ifc_is_functor_ref
typedef is_member_pointer< D >	ifc_is_member_handle
typedef is_member_object_pointer< D >	ifc_is_pmd_handle
typedef is_member_function_pointer< D >	ifc_is_pmf_handle
typedef typename ifc_pointer< T >::type	ifc_pointer_t
typedef typename ifc_return< T >::type	ifc_return_t
typedef typename detail::tuple_indexator< T >::type	indexator_for Make indexator tuple for T.
typedef std::integral_constant< T, V >	integral_constant
typedef std::is_abstract< T >	is_abstract
typedef std::is_arithmetic< T >	is_arithmetic
typedef std::is_array< T >	is_array
typedef std::is_assignable< A, B >	is_assignable
typedef std::is_base_of< A, B >	is_base_of
typedef std::is_class< T >	is_class
typedef std::is_compound< T >	is_compound
typedef std::is_const< T >	is_const
typedef std::is_constructible< T, Args... >	is_constructible
typedef std::is_convertible< A, B >	is_convertible
typedef std::is_copy_assignable< T >	is_copy_assignable
typedef std::is_copy_constructible< T >	is_copy_constructible
typedef std::is_default_constructible< T >	is_default_constructible
typedef std::is_destructible< T >	is_destructible
typedef std::is_empty< T >	is_empty
typedef std::is_enum< T >	is_enum
typedef std::is_final< T >	is_final
typedef std::is_floating_point< T >	is_floating_point
typedef std::is_function< T >	is_function
typedef std::is_fundamental< T >	is_fundamental
typedef mp_any< ifc_is_pmf_handle< T >, ifc_is_pmd_handle< T >, ifc_is_fn_handle< T >, ifc_is_functor_handle< T > >	is_ifc_handle
typedef std::is_integral< T >	is_integral
typedef std::is_lvalue_reference< T >	is_lvalue_reference
typedef std::is_member_function_pointer< T >	is_member_function_pointer
typedef std::is_member_object_pointer< T >	is_member_object_pointer
typedef std::is_member_pointer< T >	is_member_pointer
typedef std::is_move_assignable< T >	is_move_assignable
typedef std::is_move_constructible< T >	is_move_constructible
typedef std::is_nothrow_assignable< A, B >	is_nothrow_assignable
typedef std::is_nothrow_constructible< T, Args... >	is_nothrow_constructible
typedef std::is_nothrow_copy_assignable< T >	is_nothrow_copy_assignable
typedef std::is_nothrow_copy_constructible< T >	is_nothrow_copy_constructible
typedef std::is_nothrow_default_constructible< T >	is_nothrow_default_constructible
typedef std::is_nothrow_destructible< T >	is_nothrow_destructible
typedef std::is_nothrow_move_assignable< T >	is_nothrow_move_assignable
typedef std::is_nothrow_move_constructible< T >	is_nothrow_move_constructible
typedef std::is_null_pointer< T >	is_null_pointer
typedef std::is_object< T >	is_object
typedef std::is_pointer< T >	is_pointer
typedef std::is_polymorphic< T >	is_polymorphic
typedef std::is_reference< T >	is_reference
typedef std::is_rvalue_reference< T >	is_rvalue_reference
typedef std::is_same< A, B >	is_same
typedef std::is_scalar< T >	is_scalar
typedef std::is_signed< T >	is_signed
typedef std::is_standard_layout< T >	is_standard_layout
typedef std::is_trivial< T >	is_trivial
typedef std::is_trivially_assignable< A, B >	is_trivially_assignable
typedef std::is_trivially_constructible< T, Args... >	is_trivially_constructible
typedef std::is_trivially_copy_assignable< T >	is_trivially_copy_assignable
typedef std::is_trivially_copy_constructible< T >	is_trivially_copy_constructible
typedef std::is_trivially_copyable< T >	is_trivially_copyable
typedef std::is_trivially_default_constructible< T >	is_trivially_default_constructible
typedef std::is_trivially_destructible< T >	is_trivially_destructible
typedef std::is_trivially_move_assignable< T >	is_trivially_move_assignable
typedef std::is_trivially_move_constructible< T >	is_trivially_move_constructible
typedef mp_or< mp_similar< tuple<>, T >, mp_similar< std::pair< void, void >, T > >	is_tuple
typedef mp_similar< decay_t< T >, type_tag< void > >	is_type_tag
typedef std::is_union< T >	is_union
typedef std::is_unsigned< T >	is_unsigned
typedef std::is_void< T >	is_void
typedef std::is_volatile< T >	is_volatile
typedef std::function< boost::json::array::const_iterator()>	js_array_slice_const_gen
typedef std::function< boost::json::array::iterator()>	js_array_slice_gen
typedef std::make_signed< T >	make_signed
typedef typename make_signed< T >::type	make_signed_t
typedef std::make_unsigned< T >	make_unsigned
typedef typename make_unsigned< T >::type	make_unsigned_t
typedef std::remove_const< T >	remove_const
typedef typename remove_const< T >::type	remove_const_t
typedef std::remove_cv< T >	remove_cv
typedef typename remove_cv< T >::type	remove_cv_t
typedef remove_cv_t< remove_pointer_t< T > >	remove_cvptr_t
typedef remove_cv_t< remove_reference_t< T > >	remove_cvref_t
typedef std::remove_pointer< T >	remove_pointer
typedef typename remove_pointer< T >::type	remove_pointer_t
typedef std::remove_reference< T >	remove_reference
typedef typename remove_reference< T >::type	remove_reference_t
typedef std::remove_volatile< T >	remove_volatile
typedef typename remove_volatile< T >::type	remove_volatile_t
typedef mp_if< detail::is_cal< T >, R >	require_cal
typedef mp_if< boost::json::has_value_from< T >, R >	require_json_from
typedef mp_if< mp_and< detail::maybe_obj< O >, detail::is_cal< I > >, R >	require_literal
typedef mp_if< mp_not< boost::json::has_value_from< T > >, R >	require_no_json_from
typedef mp_if< detail::not_cal< T >, R >	require_not_cal
typedef mp_if< mp_not< boost::json::is_string_like< T > >, R >	require_not_str
typedef mp_if< detail::maybe_obj< T >, R >	require_obj
typedef mp_if< boost::json::is_string_like< T >, R >	require_str
typedef std::tuple< T... >	tuple
typedef std::tuple_size< T >	tuple_size
typedef mp_transform< remove_cvref_t, L >	tuple_unqf_t
typedef std::underlying_type< T >	underlying_type
typedef typename underlying_type< T >::type	underlying_type_t

Public Attributes¶

Type	Name
constexpr add_pointer_t< remove_reference_t< ifc_host_t< T > > >	ifc_host_nullptr = `{}` Resolves to H{} for member function pointers of H, or to nullptr_t for other callables.*
constexpr type_tag< T > const	type = `{}` type tag value

Public Static Attributes¶

Type	Name
constexpr bool	has_virtual_destructor_v = `has\_virtual\_destructor <T>::value`
constexpr bool	is_abstract_v = `is\_abstract <T>::value`
constexpr bool	is_arithmetic_v = `is\_arithmetic <T>::value`
constexpr bool	is_array_v = `is\_array <T>::value`
constexpr bool	is_assignable_v = `is\_assignable <A, B>::value`
constexpr bool	is_base_of_v = `is\_base\_of <A, B>::value`
constexpr bool	is_class_v = `is\_class <T>::value`
constexpr bool	is_compound_v = `is\_compound <T>::value`
constexpr bool	is_const_v = `is\_const <T>::value`
constexpr bool	is_convertible_v = `is\_convertible <A, B>::value`
constexpr bool	is_copy_assignable_v = `is\_copy\_assignable <T>::value`
constexpr bool	is_copy_constructible_v = `is\_copy\_constructible <T>::value`
constexpr bool	is_default_constructible_v = `is\_default\_constructible <T>::value`
constexpr bool	is_destructible_v = `is\_destructible <T>::value`
constexpr bool	is_empty_v = `is\_empty <T>::value`
constexpr bool	is_enum_v = `is\_enum <T>::value`
constexpr bool	is_final_v = `is\_final <T>::value`
constexpr bool	is_floating_point_v = `is\_floating\_point <T>::value`
constexpr bool	is_function_v = `is\_function <T>::value`
constexpr bool	is_fundamental_v = `is\_fundamental <T>::value`
constexpr bool	is_integral_v = `is\_integral <T>::value`
constexpr bool	is_lvalue_reference_v = `is\_lvalue\_reference <T>::value`
constexpr bool	is_member_function_pointer_v = `is\_member\_function\_pointer <T>::value`
constexpr bool	is_member_object_pointer_v = `is\_member\_object\_pointer <T>::value`
constexpr bool	is_member_pointer_v = `is\_member\_pointer <T>::value`
constexpr bool	is_move_assignable_v = `is\_move\_assignable <T>::value`
constexpr bool	is_move_constructible_v = `is\_move\_constructible <T>::value`
constexpr bool	is_nothrow_assignable_v = `is\_nothrow\_assignable <A, B>::value`
constexpr bool	is_nothrow_copy_assignable_v = `is\_nothrow\_copy\_assignable <T>::value`
constexpr bool	is_nothrow_copy_constructible_v = `is\_nothrow\_copy\_constructible <T>::value`
constexpr bool	is_nothrow_default_constructible_v = `is\_nothrow\_default\_constructible <T>::value`
constexpr bool	is_nothrow_destructible_v = `is\_nothrow\_destructible <T>::value`
constexpr bool	is_nothrow_move_assignable_v = `is\_nothrow\_move\_assignable <T>::value`
constexpr bool	is_nothrow_move_constructible_v = `is\_nothrow\_move\_constructible <T>::value`
constexpr bool	is_null_pointer_v = `is\_null\_pointer <T>::value`
constexpr bool	is_object_v = `is\_object <T>::value`
constexpr bool	is_pointer_v = `is\_pointer <T>::value`
constexpr bool	is_polymorphic_v = `is\_polymorphic <T>::value`
constexpr bool	is_reference_v = `is\_reference <T>::value`
constexpr bool	is_rvalue_reference_v = `is\_rvalue\_reference <T>::value`
constexpr bool	is_same_v = `is\_same <A, B>::value`
constexpr bool	is_scalar_v = `is\_scalar <T>::value`
constexpr bool	is_signed_v = `is\_signed <T>::value`
constexpr bool	is_standard_layout_v = `is\_standard\_layout <T>::value`
constexpr bool	is_trivial_v = `is\_trivial <T>::value`
constexpr bool	is_trivially_assignable_v = `is\_trivially\_assignable <A, B>::value`
constexpr bool	is_trivially_copy_assignable_v = `is\_trivially\_copy\_assignable <T>::value`
constexpr bool	is_trivially_copy_constructible_v = `is\_trivially\_copy\_constructible <T>::value`
constexpr bool	is_trivially_copyable_v = `is\_trivially\_copyable <T>::value`
constexpr bool	is_trivially_default_constructible_v = `is\_trivially\_default\_constructible <T>::value`
constexpr bool	is_trivially_destructible_v = `is\_trivially\_destructible <T>::value`
constexpr bool	is_trivially_move_assignable_v = `is\_trivially\_move\_assignable <T>::value`
constexpr bool	is_trivially_move_constructible_v = `is\_trivially\_move\_constructible <T>::value`
constexpr bool	is_union_v = `is\_union <T>::value`
constexpr bool	is_unsigned_v = `is\_unsigned <T>::value`
constexpr bool	is_void_v = `is\_void <T>::value`
constexpr bool	is_volatile_v = `is\_volatile <T>::value`
constexpr size_t	tuple_size_v = `tuple\_size<T>::value`

Public Functions¶

Type	Name
void	InitZmbt (int argc, char ** argv) Initialize test application.
Environment::TypedInterfaceHandle< I >	InterfaceRecord (I const & interface, object_id const & obj={ifc_host_nullptr< I >}) Make TypedInterfaceHandle instance.
T	construct_or_default (A &&... args) Construct T from the given arguments or return default T if construction is invalid.
T	convert_tuple_to (tuple< A... > & source) Convert given tuple to a tuple of type T.
void	default_test_failure (boost::json::value const & report) default test failure handler
reflect::detail::disable_hermetic_serialization< T, T >	dejsonize (boost::json::value const & v)
reflect::detail::enable_hermetic_serialization< T, T >	dejsonize (boost::json::value const & v)
void	dejsonize< void > (boost::json::value const &)
void	dejsonize_array (boost::json::array const & jarr, T(&) array)
std::string	format (boost::json::string_view fmtstr, A &&... arg) boost::format wrapper with printf-like api
void	format_failure_report (std::ostream & os, boost::json::value const & report) default failure report formatter
auto	get_ifc_handle (T const x) Get reference to callable object.
auto	get_ifc_handle (T * x)
auto	get_ifc_handle (T & x)
auto	get_ifc_pointer (T x) Get pointer to callable object.
auto	get_ifc_pointer (T * x)
auto	get_ifc_pointer (T & x)
std::string	get_tid () get thread id in string
std::size_t	get_ts () get timestamp
reflect::detail::disable_hermetic_serialization< TT, boost::json::value >	json_from (T && t)
reflect::detail::enable_hermetic_serialization< TT, boost::json::value >	json_from (T && t)
boost::json::value	json_from (std::tuple<>)
boost::json::value	json_from_array (T const (&) array)
js_array_slice_const_gen	make_slice_const_generator (boost::json::array const & src, std::int64_t const start=0, std::int64_t const stop=-1, std::int64_t const step=1)
js_array_slice_gen	make_slice_generator (boost::json::array & src, std::int64_t const start, std::int64_t const stop=-1, std::int64_t const step=1)
boost::json::value	param_transform (Param const & param, boost::json::array const & pointers, T && value) Transform Param value of type T to json value and handle type-specific environment effects.
std::ostream &	pretty_print (std::ostream & os, boost::json::value const & jv, int const indent=0) Pretty print JSON data.
boost::json::value	real_to_number (double value)
boost::json::value	real_to_number (std::int64_t value)
boost::json::array	slice (boost::json::array const & src, boost::json::string_view jp, std::int64_t const start, std::int64_t const stop=-1, std::int64_t const step=1) Slice array with inclusive boundaries and subsignal cherry-pick.
boost::json::array	slice (boost::json::array const & src, std::int64_t const start, std::int64_t const stop=-1, std::int64_t const step=1) Slice array with inclusive boundaries.
void	tuple_exchange (T1 & target, T2 const & src)
std::string	type_name () Prettified typename.
std::string	type_name (T) Prettified typename.

Detailed Description¶

Copyright:

** **

SPDX-License-Identifier: Apache-2.0

Public Types Documentation¶

enum ChannelKind¶

enum zmbt::ChannelKind {
    Undefined,
    Args,
    Return,
    Exception,
    Timestamp,
    ThreadId,
    CallCount
};

enum FileFormat¶

enum zmbt::FileFormat {
    DeduceFromExtension,
    JSON,
    YAML,
    XML
};

typedef add_const¶

using zmbt::add_const = typedef std:: add_const <T>;

typedef add_const_t¶

using zmbt::add_const_t = typedef typename add_const <T>::type;

typedef add_cv¶

using zmbt::add_cv = typedef std:: add_cv <T>;

typedef add_cv_t¶

using zmbt::add_cv_t = typedef typename add_cv <T>::type;

typedef add_lvalue_reference¶

using zmbt::add_lvalue_reference = typedef std:: add_lvalue_reference <T>;

typedef add_lvalue_reference_t¶

using zmbt::add_lvalue_reference_t = typedef typename add_lvalue_reference <T>::type;

typedef add_pointer¶

using zmbt::add_pointer = typedef std:: add_pointer <T>;

typedef add_pointer_t¶

using zmbt::add_pointer_t = typedef typename add_pointer <T>::type;

typedef add_rvalue_reference¶

using zmbt::add_rvalue_reference = typedef std:: add_rvalue_reference <T>;

typedef add_rvalue_reference_t¶

using zmbt::add_rvalue_reference_t = typedef typename add_rvalue_reference <T>::type;

typedef add_volatile¶

using zmbt::add_volatile = typedef std:: add_volatile <T>;

typedef add_volatile_t¶

using zmbt::add_volatile_t = typedef typename add_volatile <T>::type;

typedef bool_constant¶

using zmbt::bool_constant = typedef integral_constant<bool, V>;

typedef common_type¶

using zmbt::common_type = typedef std::common_type<T...>;

typedef common_type_t¶

using zmbt::common_type_t = typedef typename common_type<T...>::type;

typedef conditional¶

using zmbt::conditional = typedef std::conditional<B, T, F>;

typedef conditional_t¶

using zmbt::conditional_t = typedef typename conditional<B, T, F>::type;

typedef decay¶

using zmbt::decay = typedef std:: decay <T>;

typedef decay_t¶

using zmbt::decay_t = typedef typename decay <T>::type;

typedef first_if_any_t¶

using zmbt::first_if_any_t = typedef mp_if<mp_any<C...>, R>;

typedef first_if_none_t¶

using zmbt::first_if_none_t = typedef mp_if<mp_not<mp_any<C...> >, R>;

typedef first_if_t¶

using zmbt::first_if_t = typedef mp_if<mp_all<C...>, R>;

typedef has_virtual_destructor¶

using zmbt::has_virtual_destructor = typedef std:: has_virtual_destructor <T>;

typedef ifc_args_t¶

using zmbt::ifc_args_t = typedef typename ifc_args<T>::type;

typedef ifc_handle_t¶

using zmbt::ifc_handle_t = typedef typename ifc_handle<T>::type;

typedef ifc_host_t¶

using zmbt::ifc_host_t = typedef typename ifc_host<T>::type;

typedef ifc_is_fn_handle¶

using zmbt::ifc_is_fn_handle = typedef mp_any< ifc_is_fn_ref<T>, ifc_is_fn_ptr<T> >;

typedef ifc_is_fn_ptr¶

using zmbt::ifc_is_fn_ptr = typedef mp_all< is_pointer<T>, is_function<remove_pointer_t<D> > >;

typedef ifc_is_fn_ref¶

using zmbt::ifc_is_fn_ref = typedef mp_all< is_lvalue_reference<T>, is_function<remove_pointer_t<D> > >;

typedef ifc_is_functor_handle¶

using zmbt::ifc_is_functor_handle = typedef mp_any< ifc_is_functor_ptr<T>, ifc_is_functor_ref<T> >;

typedef ifc_is_functor_ptr¶

using zmbt::ifc_is_functor_ptr = typedef mp_all< is_pointer<P>, is_class<D>, detail::support_calltraits_function<D> >;

typedef ifc_is_functor_ref¶

using zmbt::ifc_is_functor_ref = typedef mp_all< is_reference<T>, is_class<D>, detail::support_calltraits_function<D> >;

typedef ifc_is_member_handle¶

using zmbt::ifc_is_member_handle = typedef is_member_pointer<D>;

typedef ifc_is_pmd_handle¶

using zmbt::ifc_is_pmd_handle = typedef is_member_object_pointer<D>;

typedef ifc_is_pmf_handle¶

using zmbt::ifc_is_pmf_handle = typedef is_member_function_pointer<D>;

typedef ifc_pointer_t¶

using zmbt::ifc_pointer_t = typedef typename ifc_pointer<T>::type;

typedef ifc_return_t¶

using zmbt::ifc_return_t = typedef typename ifc_return<T>::type;

typedef indexator_for¶

Make indexator tuple for T.

using zmbt::indexator_for = typedef typename detail::tuple_indexator<T>::type;

Create std::tuple of std::integral_constant with 0, ..., N-1 values for input tuple of size N

Template parameters:

T input tuple

typedef integral_constant¶

using zmbt::integral_constant = typedef std::integral_constant<T, V>;

typedef is_abstract¶

using zmbt::is_abstract = typedef std:: is_abstract <T>;

typedef is_arithmetic¶

using zmbt::is_arithmetic = typedef std:: is_arithmetic <T>;

typedef is_array¶

using zmbt::is_array = typedef std:: is_array <T>;

typedef is_assignable¶

using zmbt::is_assignable = typedef std:: is_assignable <A, B>;

typedef is_base_of¶

using zmbt::is_base_of = typedef std:: is_base_of <A, B>;

typedef is_class¶

using zmbt::is_class = typedef std:: is_class <T>;

typedef is_compound¶

using zmbt::is_compound = typedef std:: is_compound <T>;

typedef is_const¶

using zmbt::is_const = typedef std:: is_const <T>;

typedef is_constructible¶

using zmbt::is_constructible = typedef std::is_constructible<T, Args...>;

typedef is_convertible¶

using zmbt::is_convertible = typedef std:: is_convertible <A, B>;

typedef is_copy_assignable¶

using zmbt::is_copy_assignable = typedef std:: is_copy_assignable <T>;

typedef is_copy_constructible¶

using zmbt::is_copy_constructible = typedef std:: is_copy_constructible <T>;

typedef is_default_constructible¶

using zmbt::is_default_constructible = typedef std:: is_default_constructible <T>;

typedef is_destructible¶

using zmbt::is_destructible = typedef std:: is_destructible <T>;

typedef is_empty¶

using zmbt::is_empty = typedef std:: is_empty <T>;

typedef is_enum¶

using zmbt::is_enum = typedef std:: is_enum <T>;

typedef is_final¶

using zmbt::is_final = typedef std:: is_final <T>;

typedef is_floating_point¶

using zmbt::is_floating_point = typedef std:: is_floating_point <T>;

typedef is_function¶

using zmbt::is_function = typedef std:: is_function <T>;

typedef is_fundamental¶

using zmbt::is_fundamental = typedef std:: is_fundamental <T>;

typedef is_ifc_handle¶

using zmbt::is_ifc_handle = typedef mp_any< ifc_is_pmf_handle<T>, ifc_is_pmd_handle<T>, ifc_is_fn_handle<T>, ifc_is_functor_handle<T> >;

typedef is_integral¶

using zmbt::is_integral = typedef std:: is_integral <T>;

typedef is_lvalue_reference¶

using zmbt::is_lvalue_reference = typedef std:: is_lvalue_reference <T>;

typedef is_member_function_pointer¶

using zmbt::is_member_function_pointer = typedef std:: is_member_function_pointer <T>;

typedef is_member_object_pointer¶

using zmbt::is_member_object_pointer = typedef std:: is_member_object_pointer <T>;

typedef is_member_pointer¶

using zmbt::is_member_pointer = typedef std:: is_member_pointer <T>;

typedef is_move_assignable¶

using zmbt::is_move_assignable = typedef std:: is_move_assignable <T>;

typedef is_move_constructible¶

using zmbt::is_move_constructible = typedef std:: is_move_constructible <T>;

typedef is_nothrow_assignable¶

using zmbt::is_nothrow_assignable = typedef std:: is_nothrow_assignable <A, B>;

typedef is_nothrow_constructible¶

using zmbt::is_nothrow_constructible = typedef std::is_nothrow_constructible<T, Args...>;

typedef is_nothrow_copy_assignable¶

using zmbt::is_nothrow_copy_assignable = typedef std:: is_nothrow_copy_assignable <T>;

typedef is_nothrow_copy_constructible¶

using zmbt::is_nothrow_copy_constructible = typedef std:: is_nothrow_copy_constructible <T>;

typedef is_nothrow_default_constructible¶

using zmbt::is_nothrow_default_constructible = typedef std:: is_nothrow_default_constructible <T>;

typedef is_nothrow_destructible¶

using zmbt::is_nothrow_destructible = typedef std:: is_nothrow_destructible <T>;

typedef is_nothrow_move_assignable¶

using zmbt::is_nothrow_move_assignable = typedef std:: is_nothrow_move_assignable <T>;

typedef is_nothrow_move_constructible¶

using zmbt::is_nothrow_move_constructible = typedef std:: is_nothrow_move_constructible <T>;

typedef is_null_pointer¶

using zmbt::is_null_pointer = typedef std:: is_null_pointer <T>;

typedef is_object¶

using zmbt::is_object = typedef std:: is_object <T>;

typedef is_pointer¶

using zmbt::is_pointer = typedef std:: is_pointer <T>;

typedef is_polymorphic¶

using zmbt::is_polymorphic = typedef std:: is_polymorphic <T>;

typedef is_reference¶

using zmbt::is_reference = typedef std:: is_reference <T>;

typedef is_rvalue_reference¶

using zmbt::is_rvalue_reference = typedef std:: is_rvalue_reference <T>;

typedef is_same¶

using zmbt::is_same = typedef std:: is_same <A, B>;

typedef is_scalar¶

using zmbt::is_scalar = typedef std:: is_scalar <T>;

typedef is_signed¶

using zmbt::is_signed = typedef std:: is_signed <T>;

typedef is_standard_layout¶

using zmbt::is_standard_layout = typedef std:: is_standard_layout <T>;

typedef is_trivial¶

using zmbt::is_trivial = typedef std:: is_trivial <T>;

typedef is_trivially_assignable¶

using zmbt::is_trivially_assignable = typedef std:: is_trivially_assignable <A, B>;

typedef is_trivially_constructible¶

using zmbt::is_trivially_constructible = typedef std::is_trivially_constructible<T, Args...>;

typedef is_trivially_copy_assignable¶

using zmbt::is_trivially_copy_assignable = typedef std:: is_trivially_copy_assignable <T>;

typedef is_trivially_copy_constructible¶

using zmbt::is_trivially_copy_constructible = typedef std:: is_trivially_copy_constructible <T>;

typedef is_trivially_copyable¶

using zmbt::is_trivially_copyable = typedef std:: is_trivially_copyable <T>;

typedef is_trivially_default_constructible¶

using zmbt::is_trivially_default_constructible = typedef std:: is_trivially_default_constructible <T>;

typedef is_trivially_destructible¶

using zmbt::is_trivially_destructible = typedef std:: is_trivially_destructible <T>;

typedef is_trivially_move_assignable¶

using zmbt::is_trivially_move_assignable = typedef std:: is_trivially_move_assignable <T>;

typedef is_trivially_move_constructible¶

using zmbt::is_trivially_move_constructible = typedef std:: is_trivially_move_constructible <T>;

typedef is_tuple¶

using zmbt::is_tuple = typedef mp_or< mp_similar<tuple<>, T>, mp_similar<std::pair<void, void>, T> >;

typedef is_type_tag¶

using zmbt::is_type_tag = typedef mp_similar<decay_t<T>, type_tag<void> >;

typedef is_union¶

using zmbt::is_union = typedef std:: is_union <T>;

typedef is_unsigned¶

using zmbt::is_unsigned = typedef std:: is_unsigned <T>;

typedef is_void¶

using zmbt::is_void = typedef std:: is_void <T>;

typedef is_volatile¶

using zmbt::is_volatile = typedef std:: is_volatile <T>;

typedef js_array_slice_const_gen¶

using zmbt::js_array_slice_const_gen = typedef std::function<boost::json::array::const_iterator()>;

typedef js_array_slice_gen¶

using zmbt::js_array_slice_gen = typedef std::function<boost::json::array::iterator()>;

typedef make_signed¶

using zmbt::make_signed = typedef std:: make_signed <T>;

typedef make_signed_t¶

using zmbt::make_signed_t = typedef typename make_signed <T>::type;

typedef make_unsigned¶

using zmbt::make_unsigned = typedef std:: make_unsigned <T>;

typedef make_unsigned_t¶

using zmbt::make_unsigned_t = typedef typename make_unsigned <T>::type;

typedef remove_const¶

using zmbt::remove_const = typedef std:: remove_const <T>;

typedef remove_const_t¶

using zmbt::remove_const_t = typedef typename remove_const <T>::type;

typedef remove_cv¶

using zmbt::remove_cv = typedef std:: remove_cv <T>;

typedef remove_cv_t¶

using zmbt::remove_cv_t = typedef typename remove_cv <T>::type;

typedef remove_cvptr_t¶

using zmbt::remove_cvptr_t = typedef remove_cv_t<remove_pointer_t<T> >;

typedef remove_cvref_t¶

using zmbt::remove_cvref_t = typedef remove_cv_t<remove_reference_t<T> >;

typedef remove_pointer¶

using zmbt::remove_pointer = typedef std:: remove_pointer <T>;

typedef remove_pointer_t¶

using zmbt::remove_pointer_t = typedef typename remove_pointer <T>::type;

typedef remove_reference¶

using zmbt::remove_reference = typedef std:: remove_reference <T>;

typedef remove_reference_t¶

using zmbt::remove_reference_t = typedef typename remove_reference <T>::type;

typedef remove_volatile¶

using zmbt::remove_volatile = typedef std:: remove_volatile <T>;

typedef remove_volatile_t¶

using zmbt::remove_volatile_t = typedef typename remove_volatile <T>::type;

typedef require_cal¶

using zmbt::require_cal = typedef mp_if<detail::is_cal<T>, R>;

typedef require_json_from¶

using zmbt::require_json_from = typedef mp_if<boost::json::has_value_from<T>, R>;

typedef require_literal¶

using zmbt::require_literal = typedef mp_if<mp_and<detail::maybe_obj<O>, detail::is_cal<I> >, R>;

typedef require_no_json_from¶

using zmbt::require_no_json_from = typedef mp_if<mp_not<boost::json::has_value_from<T> >, R>;

typedef require_not_cal¶

using zmbt::require_not_cal = typedef mp_if<detail::not_cal<T>, R>;

typedef require_not_str¶

using zmbt::require_not_str = typedef mp_if<mp_not<boost::json::is_string_like<T> >, R>;

typedef require_obj¶

using zmbt::require_obj = typedef mp_if<detail::maybe_obj<T>, R>;

typedef require_str¶

using zmbt::require_str = typedef mp_if<boost::json::is_string_like<T>, R>;

typedef tuple¶

using zmbt::tuple = typedef std::tuple<T...>;

typedef tuple_size¶

using zmbt::tuple_size = typedef std::tuple_size<T>;

typedef tuple_unqf_t¶

using zmbt::tuple_unqf_t = typedef mp_transform<remove_cvref_t, L>;

typedef underlying_type¶

using zmbt::underlying_type = typedef std:: underlying_type <T>;

typedef underlying_type_t¶

using zmbt::underlying_type_t = typedef typename underlying_type <T>::type;

Public Attributes Documentation¶

variable ifc_host_nullptr¶

Resolves to H*{} for member function pointers of H, or to nullptr_t for other callables.

constexpr add_pointer_t<remove_reference_t<ifc_host_t<T> > > zmbt::ifc_host_nullptr;

variable type¶

type tag value

constexpr type_tag<T> const zmbt::type;

Template parameters:

T

Public Static Attributes Documentation¶

variable has_virtual_destructor_v¶

constexpr bool zmbt::has_virtual_destructor_v;

variable is_abstract_v¶

constexpr bool zmbt::is_abstract_v;

variable is_arithmetic_v¶

constexpr bool zmbt::is_arithmetic_v;

variable is_array_v¶

constexpr bool zmbt::is_array_v;

variable is_assignable_v¶

constexpr bool zmbt::is_assignable_v;

variable is_base_of_v¶

constexpr bool zmbt::is_base_of_v;

variable is_class_v¶

constexpr bool zmbt::is_class_v;

variable is_compound_v¶

constexpr bool zmbt::is_compound_v;

variable is_const_v¶

constexpr bool zmbt::is_const_v;

variable is_convertible_v¶

constexpr bool zmbt::is_convertible_v;

variable is_copy_assignable_v¶

constexpr bool zmbt::is_copy_assignable_v;

variable is_copy_constructible_v¶

constexpr bool zmbt::is_copy_constructible_v;

variable is_default_constructible_v¶

constexpr bool zmbt::is_default_constructible_v;

variable is_destructible_v¶

constexpr bool zmbt::is_destructible_v;

variable is_empty_v¶

constexpr bool zmbt::is_empty_v;

variable is_enum_v¶

constexpr bool zmbt::is_enum_v;

variable is_final_v¶

constexpr bool zmbt::is_final_v;

variable is_floating_point_v¶

constexpr bool zmbt::is_floating_point_v;

variable is_function_v¶

constexpr bool zmbt::is_function_v;

variable is_fundamental_v¶

constexpr bool zmbt::is_fundamental_v;

variable is_integral_v¶

constexpr bool zmbt::is_integral_v;

variable is_lvalue_reference_v¶

constexpr bool zmbt::is_lvalue_reference_v;

variable is_member_function_pointer_v¶

constexpr bool zmbt::is_member_function_pointer_v;

variable is_member_object_pointer_v¶

constexpr bool zmbt::is_member_object_pointer_v;

variable is_member_pointer_v¶

constexpr bool zmbt::is_member_pointer_v;

variable is_move_assignable_v¶

constexpr bool zmbt::is_move_assignable_v;

variable is_move_constructible_v¶

constexpr bool zmbt::is_move_constructible_v;

variable is_nothrow_assignable_v¶

constexpr bool zmbt::is_nothrow_assignable_v;

variable is_nothrow_copy_assignable_v¶

constexpr bool zmbt::is_nothrow_copy_assignable_v;

variable is_nothrow_copy_constructible_v¶

constexpr bool zmbt::is_nothrow_copy_constructible_v;

variable is_nothrow_default_constructible_v¶

constexpr bool zmbt::is_nothrow_default_constructible_v;

variable is_nothrow_destructible_v¶

constexpr bool zmbt::is_nothrow_destructible_v;

variable is_nothrow_move_assignable_v¶

constexpr bool zmbt::is_nothrow_move_assignable_v;

variable is_nothrow_move_constructible_v¶

constexpr bool zmbt::is_nothrow_move_constructible_v;

variable is_null_pointer_v¶

constexpr bool zmbt::is_null_pointer_v;

variable is_object_v¶

constexpr bool zmbt::is_object_v;

variable is_pointer_v¶

constexpr bool zmbt::is_pointer_v;

variable is_polymorphic_v¶

constexpr bool zmbt::is_polymorphic_v;

variable is_reference_v¶

constexpr bool zmbt::is_reference_v;

variable is_rvalue_reference_v¶

constexpr bool zmbt::is_rvalue_reference_v;

variable is_same_v¶

constexpr bool zmbt::is_same_v;

variable is_scalar_v¶

constexpr bool zmbt::is_scalar_v;

variable is_signed_v¶

constexpr bool zmbt::is_signed_v;

variable is_standard_layout_v¶

constexpr bool zmbt::is_standard_layout_v;

variable is_trivial_v¶

constexpr bool zmbt::is_trivial_v;

variable is_trivially_assignable_v¶

constexpr bool zmbt::is_trivially_assignable_v;

variable is_trivially_copy_assignable_v¶

constexpr bool zmbt::is_trivially_copy_assignable_v;

variable is_trivially_copy_constructible_v¶

constexpr bool zmbt::is_trivially_copy_constructible_v;

variable is_trivially_copyable_v¶

constexpr bool zmbt::is_trivially_copyable_v;

variable is_trivially_default_constructible_v¶

constexpr bool zmbt::is_trivially_default_constructible_v;

variable is_trivially_destructible_v¶

constexpr bool zmbt::is_trivially_destructible_v;

variable is_trivially_move_assignable_v¶

constexpr bool zmbt::is_trivially_move_assignable_v;

variable is_trivially_move_constructible_v¶

constexpr bool zmbt::is_trivially_move_constructible_v;

variable is_union_v¶

constexpr bool zmbt::is_union_v;

variable is_unsigned_v¶

constexpr bool zmbt::is_unsigned_v;

variable is_void_v¶

constexpr bool zmbt::is_void_v;

variable is_volatile_v¶

constexpr bool zmbt::is_volatile_v;

variable tuple_size_v¶

constexpr size_t zmbt::tuple_size_v;

Public Functions Documentation¶

function InitZmbt¶

Initialize test application.

void zmbt::InitZmbt (
    int argc,
    char ** argv
)

function InterfaceRecord¶

Make TypedInterfaceHandle instance.

template<class I>
Environment::TypedInterfaceHandle < I > zmbt::InterfaceRecord (
    I const & interface,
    object_id const & obj={ ifc_host_nullptr < I >}
)

Template parameters:

I

Parameters:

obj
interface

Returns:

TypedInterfaceHandle_ _

function construct_or_default¶

Construct T from the given arguments or return default T if construction is invalid.

template<class T, class... A>
T zmbt::construct_or_default (
    A &&... args
)

function convert_tuple_to¶

Convert given tuple to a tuple of type T.

template<class T, class... A>
inline T zmbt::convert_tuple_to (
    tuple< A... > & source
)

Template parameters:

T target tuple type
A source tuple parameters

Parameters:

source input tuple

Returns:

T

function default_test_failure¶

default test failure handler

void zmbt::default_test_failure (
    boost::json::value const & report
)

function dejsonize¶

template<class T>
reflect::detail::disable_hermetic_serialization< T, T > zmbt::dejsonize (
    boost::json::value const & v
)

function dejsonize¶

template<class T>
reflect::detail::enable_hermetic_serialization< T, T > zmbt::dejsonize (
    boost::json::value const & v
)

function dejsonize< void >¶

template<>
inline void zmbt::dejsonize< void > (
    boost::json::value const &
)

function dejsonize_array¶

template<class T, std::size_t N>
void zmbt::dejsonize_array (
    boost::json::array const & jarr,
    T(&) array
)

function format¶

boost::format wrapper with printf-like api

template<class... A>
std::string zmbt::format (
    boost::json::string_view fmtstr,
    A &&... arg
)

function format_failure_report¶

default failure report formatter

void zmbt::format_failure_report (
    std::ostream & os,
    boost::json::value const & report
)

function get_ifc_handle¶

Get reference to callable object.

template<class T, class R>
auto zmbt::get_ifc_handle (
    T const x
)

function get_ifc_handle¶

template<class T, class R>
auto zmbt::get_ifc_handle (
    T * x
)

function get_ifc_handle¶

template<class T, class R>
auto zmbt::get_ifc_handle (
    T & x
)

function get_ifc_pointer¶

Get pointer to callable object.

template<class T, class R>
auto zmbt::get_ifc_pointer (
    T x
)

function get_ifc_pointer¶

template<class T, class R>
auto zmbt::get_ifc_pointer (
    T * x
)

function get_ifc_pointer¶

template<class T, class R>
auto zmbt::get_ifc_pointer (
    T & x
)

function get_tid¶

get thread id in string

std::string zmbt::get_tid ()

function get_ts¶

get timestamp

std::size_t zmbt::get_ts ()

function json_from¶

template<class T, class TT>
reflect::detail::disable_hermetic_serialization< TT, boost::json::value > zmbt::json_from (
    T && t
)

function json_from¶

template<class T, class TT>
reflect::detail::enable_hermetic_serialization< TT, boost::json::value > zmbt::json_from (
    T && t
)

function json_from¶

inline boost::json::value zmbt::json_from (
    std::tuple<>
)

function json_from_array¶

template<class T, std::size_t N>
boost::json::value zmbt::json_from_array (
    T const (&) array
)

function make_slice_const_generator¶

js_array_slice_const_gen zmbt::make_slice_const_generator (
    boost::json::array const & src,
    std::int64_t const start=0,
    std::int64_t const stop=-1,
    std::int64_t const step=1
)

function make_slice_generator¶

js_array_slice_gen zmbt::make_slice_generator (
    boost::json::array & src,
    std::int64_t const start,
    std::int64_t const stop=-1,
    std::int64_t const step=1
)

function param_transform¶

Transform Param value of type T to json value and handle type-specific environment effects.

template<class T>
boost::json::value zmbt::param_transform (
    Param const & param,
    boost::json::array const & pointers,
    T && value
)

function pretty_print¶

Pretty print JSON data.

std::ostream & zmbt::pretty_print (
    std::ostream & os,
    boost::json::value const & jv,
    int const indent=0
)

Parameters:

os
jv
indent initial indent

Returns:

std::ostream&

function real_to_number¶

boost::json::value zmbt::real_to_number (
    double value
)

Convert a double to a JSON number, storing result as uint64_t or int64_t if possible.

function real_to_number¶

boost::json::value zmbt::real_to_number (
    std::int64_t value
)

Convert a signed integer to JSON number, storing result as uint64_t if possible.

function slice¶

Slice array with inclusive boundaries and subsignal cherry-pick.

boost::json::array zmbt::slice (
    boost::json::array const & src,
    boost::json::string_view jp,
    std::int64_t const start,
    std::int64_t const stop=-1,
    std::int64_t const step=1
)

Parameters:

src source array
jp JSON Pointer for subsignal cherry-pick
start start index, 0-based, inclusive; negative value yields reverse index;
stop stop index, 0-based, inclusive; negative value yields reverse index;
step step value, negative value yields reverse iteration

Returns:

slice array

function slice¶

Slice array with inclusive boundaries.

boost::json::array zmbt::slice (
    boost::json::array const & src,
    std::int64_t const start,
    std::int64_t const stop=-1,
    std::int64_t const step=1
)

Parameters:

src source array
start start index, 0-based, inclusive; negative value yields reverse index;
stop stop index, 0-based, inclusive; negative value yields reverse index;
step step value, negative value yields reverse iteration

Returns:

slice array

function tuple_exchange¶

template<class T1, class T2>
void zmbt::tuple_exchange (
    T1 & target,
    T2 const & src
)

function type_name¶

Prettified typename.

template<class T>
inline std::string zmbt::type_name ()

Template parameters:

T

Returns:

std::string

function type_name¶

Prettified typename.

template<class T>
inline std::string zmbt::type_name (
    T
)

Template parameters:

T

Returns:

std::string

The documentation for this class was generated from the following file zmbt-framework/zmbt-framework/backends/cxx/include/zmbt/api/model_test.hpp