| Cqx::string_traits::allocation_traits< value_t, usings_char_traits_t > | |
| ►Cqx::string_traits::allocation_traits< char, usings_char_traits_t > | |
| Cqx::string_traits::big_string_allocation_traits< char, usings_char_traits_t > | |
| Cqx::string_traits::small_string_allocation_traits< char, usings_char_traits_t > | |
| ►Cqx::string_traits::allocation_traits< wchar_t, usings_char_traits_t > | |
| Cqx::string_traits::big_string_allocation_traits< wchar_t, usings_char_traits_t > | |
| Cqx::string_traits::small_string_allocation_traits< wchar_t, usings_char_traits_t > | |
| Cqx::base_easing_element< T > | An updatable element representing the value of the easing function at a given time |
| Cqx::base_easing_sequence< T > | Qx::base_easing_element queue |
| ►Cqx::base_iterator< container_t > | Base contiguous iterator with a container pointer and an index |
| ►Cqx::base_forward_iterator< container_t, std::conditional_t< std::same_as< void, void >, iterator< container_t >, void > > | |
| ►Cqx::iterator< container_t, derived_t > | Non-const random access iterator type |
| ►Cqx::base_dereference_iterator< iterator< container_t, dereference_iterator< container_t > > > | |
| Cqx::dereference_iterator< container_t > | |
| ►Cqx::base_return_object_iterator< iterator< container_t, return_object_iterator< container_t > > > | |
| Cqx::return_object_iterator< container_t > | |
| ►Cqx::base_forward_iterator< const container_t, std::conditional_t< std::same_as< derived_t, void >, const const_iterator< container_t >, derived_t > > | |
| ►Cqx::const_iterator< container_t, derived_t > | Const random access iterator type |
| ►Cqx::base_dereference_iterator< const_iterator< container_t, const_dereference_iterator< container_t > > > | |
| Cqx::const_dereference_iterator< container_t > | |
| ►Cqx::base_return_object_iterator< const_iterator< container_t, const_return_object_iterator< container_t > > > | |
| Cqx::const_return_object_iterator< container_t > | |
| ►Cqx::base_reverse_iterator< container_t, std::conditional_t< std::same_as< void, void >, reverse_iterator< container_t >, void > > | |
| ►Cqx::reverse_iterator< container_t, derived_t > | Non-const random access reverse iterator type |
| ►Cqx::base_dereference_iterator< reverse_iterator< container_t, reverse_dereference_iterator< container_t > > > | |
| Cqx::reverse_dereference_iterator< container_t > | |
| ►Cqx::base_return_object_iterator< reverse_iterator< container_t, reverse_return_object_iterator< container_t > > > | |
| Cqx::reverse_return_object_iterator< container_t > | |
| ►Cqx::base_reverse_iterator< const container_t, std::conditional_t< std::same_as< derived_t, void >, const const_reverse_iterator< container_t >, derived_t > > | |
| ►Cqx::const_reverse_iterator< container_t, derived_t > | Const reverse random access iterator type |
| ►Cqx::base_dereference_iterator< const_reverse_iterator< container_t, const_reverse_dereference_iterator< container_t > > > | |
| Cqx::const_reverse_dereference_iterator< container_t > | |
| ►Cqx::base_return_object_iterator< const_reverse_iterator< container_t, const_reverse_return_object_iterator< container_t > > > | |
| Cqx::const_reverse_return_object_iterator< container_t > | |
| Cqx::base_forward_iterator< container_t, derived_t > | Basic contiguous forward iterator, meaning that incrementing an iterator will lead it moving forward |
| Cqx::base_reverse_iterator< container_t, derived_t > | Basic contiguous reverse iterator, meaning that incrementing an iterator will lead it moving backward |
| ►Cbase_iterator_t | |
| Cqx::base_dereference_iterator< base_iterator_t > |
|
| Cqx::base_return_object_iterator< base_iterator_t > | This kind of iterator returns value and not reference in access methods |
| ►Cqx::base_logger_stream | Base class for logger streams |
| Cqx::cout_logger_stream | Logger stream for std::cout output |
| Cqx::debugger_logger_stream | Logger stream for a debugger output (VS: output window) |
| Cqx::file_logger_stream | Logger stream for file output |
| Cqx::base_shader_program | Shader program class |
| ►Cqx::base_subject | Base subject class |
| Cqx::subject< observer_t > | Class maintains a list of its dependents, called observers, and notifies them automatically of any state changes |
| ►Cstd::basic_format_string | |
| Cqx::basic_format_string_strong_checks< args_t... > | |
| Cqx::basic_format_string_strong_checks< char_t, args_t > | Std::basic_format_string wrapper that performs additional compile time checks |
| ►Cqx::basic_formatter | |
| Cstd::formatter< qx::basic_string< char_t, traits_t >, char_t > | |
| Cqx::basic_rect< vector_t > | |
| Cqx::basic_string< char_t, traits_t > | String class |
| Cqx::basic_string< char_type > | |
| Cqx::basic_string_hash< traits_t > | String hash object |
| Cqx::benchmark | Benchmark class |
| Cqx::string_traits::big_string_allocation_traits< value_t, usings_char_traits_t > | |
| Cqx::category | A category is a class that identifies a particular piece of code. This code can be located in different files, but united by one functionality. Objects of this class can be used in logging, asserts and profiling |
| Cqx::color | RGBA color |
| Cqx::string_traits::compare_traits< value_t, usings_char_traits_t > | |
| Cqx::string_traits::compare_traits< char, usings_char_traits_t > | |
| Cqx::string_traits::compare_traits< wchar_t, usings_char_traits_t > | |
| Cqx::components< base_component_t > | Container for components system |
| Cqx::constexpr_flag< tag_t, T, Start, End > | Constexpr flag class |
| Cqx::constexpr_sequence< tag_t, T, Start, Func > | Constexpr sequence. use unique tag for different instances |
| Ccontains | Check that tuple type contains T |
| Cqx::tuple::details::contains< T, tuple_t > | |
| ►Cqx::tuple::details::contains< T, std::tuple< args_t... > > | |
| Cqx::tuple::details::contains< T, std::tuple< U, args_t... > > | |
| Cqx::copy_qualifiers< test_t, target_t > | |
| Cqx::copy_qualifiers< const test_t, target_t > | |
| Cqx::copy_qualifiers< const volatile test_t, target_t > | |
| Cqx::copy_qualifiers< volatile test_t, target_t > | |
| Cqx::default_generic_span_traits | |
| Cqx::destruction_callback | Class for RAII: functor passed in constructor will be called in destructor |
| ►Cstd::false_type | |
| Cqx::are_same< first_t, second_t, rest_t... > | |
| Cqx::is_array_of_t< array_t, T > | |
| Cqx::is_specialization_of< test_t, reference_t > | |
| Cqx::tuple::details::contains< T, std::tuple<> > | |
| Cqx::flags< enum_t > | Wrapper for enumerations to be used as a list of flags |
| Cqx::flags< delimiter_inclusion_flags > | |
| Cqx::flags< status > | |
| Cqx::string_traits::format_string_traits< value_t, usings_char_traits_t > | |
| Cqx::string_traits::format_traits< value_t, usings_char_traits_t > | |
| Cqx::string_traits::format_traits< char, usings_char_traits_t > | |
| Cqx::string_traits::format_traits< wchar_t, usings_char_traits_t > | |
| Cqx::generic_span< T, traits_t > | Same as std::span, but may be used with containers with forward iterators |
| Cqx::geometry | |
| Cstd::hash< qx::basic_string< char_t, traits_t > > | |
| Cstd::hash< qx::basic_string_hash< traits_t > > | |
| Cstd::hash< qx::state< T > > | |
| Cqx::string_traits::hash_traits< value_t, usings_char_traits_t > | |
| ►Cqx::IBuffer | OpenGL buffer interface |
| Cqx::base_fbo | Base FBO class |
| Cqx::base_rbo | Base RBO class |
| Cqx::base_texture | Base texture class |
| Cqx::base_vao | Base VAO class |
| ►Cqx::buffer_base | Base OpenGL buffer object class |
| Cqx::base_ebo | Base EBO class |
| Cqx::base_vbo | Base VBO class |
| ►Cqx::buffer_binding_point_base | Base class for buffers with binding points |
| Cqx::base_ssbo | Base SSBO class |
| Cqx::base_ubo | Base UBO class |
| Cqx::tuple::index< tuple_t, T > | Get an index of the first occurrence of the given type |
| Cqx::tuple::index< std::tuple< T, args_t... >, T > | |
| Cqx::tuple::index< std::tuple< U, args_t... >, T > | |
| Cqx::generic_span< T, traits_t >::iterator | |
| Cqx::iterator_value< T, class > | |
| Cqx::iterator_value< T, std::enable_if_t< is_iterator< T > > > | |
| Cqx::iterator_value< T, std::enable_if_t< std::is_pointer_v< T > > > | |
| Cqx::tuple::join<... > | Appends types or another tuple to tuple |
| Cqx::tuple::join< std::tuple< first_pack_t... >, second_t, optional_args_t... > | |
| Cqx::tuple::join< std::tuple< first_pack_t... >, std::tuple< second_pack_t... > > | |
| Cqx::string_traits::length_traits< value_t, usings_char_traits_t > | |
| Cqx::string_traits::length_traits< char, usings_char_traits_t > | |
| Cqx::string_traits::length_traits< wchar_t, usings_char_traits_t > | |
| Cqx::link< T > | Std::weak_ptr wrapper that do not allow you to create strong pointer (std::shared_ptr) |
| Cqx::link< T >::lock_ptr | Std::shared_ptr wrapper |
| Cqx::log_unit | |
| Cqx::log_unit_info | |
| ►Cqx::logger | Logger class |
| Cqx::logger_singleton | Default logger instance |
| Cqx::logger_buffer | |
| Cqx::logger_color_range | |
| Cqx::moving_average< T > | Moving average is the unweighted mean of the previous K entries |
| Cqx::observer_token_data | Tokens are used to automatically detach observer when the observer object is destroyed |
| Crect | Rectangle class |
| Cqx::recursive_lambda< lambda_t > | |
| Cqx::reflection_creator< base_class_t, smart_ptr_t, args_t > | Reflection creator |
| Cqx::tuple::remove<... > | Removes all types from the second argument from the first tuple |
| Cqx::tuple::remove< std::tuple< types_t... >, std::tuple< target_t, remaining_targets_t... > > | |
| Cqx::tuple::remove< std::tuple< types_t... >, std::tuple<> > | |
| Cqx::tuple::details::remove_single<... > | |
| Cqx::tuple::details::remove_single< target_t, std::tuple< pack_t... > > | |
| Cqx::tuple::details::remove_single< target_t, std::tuple< parameter_t, pack_t... > > | |
| Cqx::rtti_naming_strategy_class_name | Returns class name string_view in get_name |
| Cqx::rtti_naming_strategy_empty | Returns empty string_view in get_name: { '\0' } |
| ►Cqx::rtti_pure_base | |
| Cqx::rtti_root< naming_strategy_t > | RTTI root class |
| Cqx::components< base_component_t >::SClassData::SCacheData | |
| Cqx::shader_base< ShaderType > | OpenGL base shader |
| Cqx::shared_proxy< data_t, synchronization_primitive_t > | A proxy class that provides access to an object stored in threads_shared and provides raii for synchronization primitives |
| Cqx::singleton_traits< T > | |
| Cqx::string_traits::small_string_allocation_traits< value_t, usings_char_traits_t > | |
| Cqx::state< T > | State abstraction class |
| Cqx::details::static_assert_between< left, value, right > | |
| Cqx::details::static_assert_two< left, right, compare_t > | |
| Cqx::details::static_assert_two< left, right, std::equal_to<> > | |
| Cqx::details::static_assert_two< left, right, std::greater<> > | |
| Cqx::details::static_assert_two< left, right, std::greater_equal<> > | |
| Cqx::details::static_assert_two< left, right, std::less<> > | |
| Cqx::details::static_assert_two< left, right, std::less_equal<> > | |
| Cqx::details::static_assert_two< left, right, std::not_equal_to<> > | |
| Cqx::static_buffer | Class contains static buffers of different types |
| Cqx::string_data< traits_t > | Represents string data |
| Cqx::string_literal< T, N > | Literal wrapper for a constant expression string |
| Cqx::details::string_to_color_converter | Helper class for string -> color conversion |
| Cqx::string_view_iterator< char_t > | Iterator class that allows to iterate over a string view using a delimiter character |
| Cqx::switch_const< T > | |
| Cqx::switch_const< const T > | |
| Cqx::switch_qualifiers< T > | |
| Cqx::switch_qualifiers< const T > | |
| Cqx::switch_qualifiers< const volatile T > | |
| Cqx::switch_qualifiers< volatile T > | |
| Cqx::switch_volatile< T > | |
| Cqx::switch_volatile< volatile T > | |
| Cqx::terminal_color | Class for colors manipulating in terminal |
| Cqx::string_traits::test_char_traits< value_t, usings_char_traits_t > | |
| Cqx::string_traits::test_char_traits< char, usings_char_traits_t > | |
| Cqx::string_traits::test_char_traits< wchar_t, usings_char_traits_t > | |
| Cqx::threads_shared< data_t, synchronization_primitive_t > | A class that provides thread-safe access to an object, including construction and destruction |
| Cqx::unique_objects_pool< T >::token | The token is used for distributed access to a unique object in the pool |
| Cqx::tuple::transform< tuple_t, transformation_t > | Get a new tuple type by transforming every type inside a given tuple |
| Cqx::tuple::transform< std::tuple< args_t... >, transformation_t > | |
| Cqx::string_traits::transform_char_traits< value_t, usings_char_traits_t > | |
| Cqx::string_traits::transform_char_traits< char, usings_char_traits_t > | |
| Cqx::string_traits::transform_char_traits< wchar_t, usings_char_traits_t > | |
| Cqx::triangular_vector< T > | Triangular vector class |
| ►Cstd::true_type | |
| ►Cqx::are_same< first_t, rest_ty... > | |
| Cqx::are_same< first_t, first_t, rest_ty... > | |
| Cqx::are_same<... > | |
| Cqx::is_array_of_t< T(&)[N], T > | |
| Cqx::is_array_of_t< T[N], T > | |
| Cqx::is_array_of_t< T[], T > | |
| Cqx::is_array_of_t< const T(&)[N], T > | |
| Cqx::is_array_of_t< const T[N], T > | |
| Cqx::is_array_of_t< const T[], T > | |
| Cqx::is_array_of_t< const volatile T(&)[N], T > | |
| Cqx::is_array_of_t< const volatile T[N], T > | |
| Cqx::is_array_of_t< const volatile T[], T > | |
| Cqx::is_array_of_t< volatile T(&)[N], T > | |
| Cqx::is_array_of_t< volatile T[N], T > | |
| Cqx::is_array_of_t< volatile T[], T > | |
| Cqx::is_specialization_of< reference_t< args_t... >, reference_t > | |
| Cqx::tuple::details::contains< T, std::tuple< T, args_t... > > | |
| Cqx::type_strings< T, char_t > | The class allows you to get strings with information about the type, including its full name, name without template parameters and a list of template parameters separately |
| Cqx::unique_objects_pool< T > | Class stores unique objects and allows access to them through tokens |
| Cqx::string_traits::usings_traits< value_t > | |
| Cqx::vector2d< T > | Continuous 2d vector |
| Cqx::vertex | |
| ►Cstd::ranges::view_interface | |
| Cqx::string_view_view< char_t > | Class that allows to iterate over a string view using a delimiter character |
| ►Cqx::args_t | |
| Cqx::visit_overload< args_t > | |
| ►Cqx::string_traits::args_t | |
| Cqx::string_traits::constructor< args_t > | |
