Detailed Description

This file is based on the public domain MurmurHash3 algorithm https://github.com/PeterScott/murmur3/blob/master/murmur3.c

Namespaces
namespace	detail

namespace	qt

Classes
struct	aligned_pod_allocator
	An allocator which guarantees that the memory is aligned on Align. More...

struct	bad_request_error
	Used when a bad network request is done on a local server. More...

class	callback_container
	The callback_container class. More...

struct	connection_error
	The connection_error class. More...

class	constant_curve
	The constant_curve class A curve that always return a same single value. More...

struct	context
	If using the library, you should create this class at some point. More...

class	curve
	The curve class. More...

class	curve_abstract
	The curve_abstract class. More...

struct	domain
	domain A domain of values More...

struct	domain_value_set_creation_visitor
	The domain_value_set_creation_visitor struct. More...

class	enum_map
	A container useful for mapping contiguous enums to strings without using too much memory. More...

struct	execution_error
	The execution_error class. More...

class	flat_set_state
	The flat_state class. More...

struct	generic_clamp

struct	gpu_buffer_handle
	Handle to a GPU buffer (vertex, index, uniform, storage) More...

struct	gpu_texture_handle
	Handle to a GPU texture with sampler state. More...

struct	invalid_access_error
	The invalid_access_error struct. More...

struct	invalid_node_error
	The invalid_node_error class. More...

struct	invalid_value_type_error
	The invalid_value_type_error class. More...

struct	kalman_point_filter
	N independent position-velocity Kalman filters: a tracked N-D point. More...

struct	kalman_pv_filter
	Scalar constant-velocity Kalman filter, one axis of a tracked point. More...

struct	list_clamp

class	locked_container
	Thread-safe read-only reference to a container. More...

struct	match_candidate
	One candidate pairing for greedy bipartite assignment. More...

struct	median_filter
	Running median over the last `N` samples. More...

struct	merger_impl
	Merge ///. More...

struct	message
	The message struct. More...

struct	moving_average_filter
	Simple moving average over the last `N` samples. More...

struct	multi_filter
	Applies one independent `Filter` per component of a vector-valued signal. More...

struct	node_not_found_error
	Used when a requested node could not be found. More...

struct	one_euro_filter
	One-euro filter: a low-pass whose cutoff rises with the speed of the signal. More...

struct	one_pole_filter
	First-order low-pass. The building block for everything below. More...

struct	pair
	A most simple pair type, to reduce binary bloat. More...

struct	parse_error
	The parse_error class. More...

struct	quantification_point

struct	recabler

class	state
	The state class. More...

class	time_event
	The time_event class. More...

class	time_interval
	The time_interval class. More...

class	time_process
	The time_process class. More...

class	time_sync
	time_sync is use to describe temporal structure to synchronize each attached #time_event evaluation. More...

struct	time_value
	The time_value class. More...

struct	track_events
	Lifecycle notifications of one step. Ids, not indices: by the time an exit is reported the track is no longer in tracks(). More...

struct	unit_t

class	value
	The value class. More...

struct	value_with_unit

struct	websocket_heartbeat
	Sends websocket "alive" messages at regular intervals. More...

struct	websocket_log_sink
	A sink to use with spdlog, that will send its log messages over websockets. More...

Typedefs
using	musical_sync = double

using	audio_mapping = ossia::int_vector

using	fft_plan = void *

using	fft_real = double

using	fft_complex = double[2]

using	pan_weight = ossia::small_vector< double, 2 >

using	destination_t = ossia::nullable_variant< ossia::net::parameter_base , ossia::traversal::path, ossia::net::node_base >

using	node_ptr = std::shared_ptr< graph_node >

using	edge_ptr = std::shared_ptr< graph_edge >

using	inlet_ptr = inlet *

using	outlet_ptr = outlet *

using	delay_line_type = ossia::nullable_variant< audio_delay_line, midi_delay_line, value_delay_line, geometry_delay_line >

using	mesh_list_ptr = std::shared_ptr< mesh_list >

using	geometry_filter_list_ptr = std::shared_ptr< geometry_filter_list >

using	buffer_resource_ptr = std::shared_ptr< const buffer_resource >

using	material_component_ptr = std::shared_ptr< const material_component >

using	skeleton_component_ptr = std::shared_ptr< const skeleton_component >

using	scene_property_map = ossia::flat_map< std::string, ossia::value >

using	mesh_component_ptr = std::shared_ptr< const mesh_component >

using	light_component_ptr = std::shared_ptr< const light_component >

using	camera_component_ptr = std::shared_ptr< const camera_component >

using	animation_component_ptr = std::shared_ptr< const animation_component >

using	gaussian_splat_component_ptr = std::shared_ptr< const gaussian_splat_component >

using	voxel_field_component_ptr = std::shared_ptr< const voxel_field_component >

using	primitive_cloud_component_ptr = std::shared_ptr< const primitive_cloud_component >

using	point_cloud_component_ptr = std::shared_ptr< const point_cloud_component >

using	volume_component_ptr = std::shared_ptr< const volume_component >

using	instance_component_ptr = std::shared_ptr< const instance_component >

using	scene_data_ptr = std::shared_ptr< const scene_data >

using	scene_node_ptr = std::shared_ptr< const scene_node >

using	scene_payload = ossia::variant< scene_node_ptr, mesh_component_ptr, material_component_ptr, light_component_ptr, camera_component_ptr, skeleton_component_ptr, animation_component_ptr, instance_component_ptr, scene_data_ptr, gaussian_splat_component_ptr, voxel_field_component_ptr, point_cloud_component_ptr, volume_component_ptr, primitive_cloud_component_ptr, scene_transform >

using	scene_collection_ptr = std::shared_ptr< const scene_collection >

using	scene_state_ptr = std::shared_ptr< const scene_state >

using	boost_pool = boost::pool< boost::default_user_allocator_malloc_free >

using	task_function = smallfun::function< void(ossia::graph_node &), sizeof(void ) 4 >

using	filtered_graph_t = std::decay_t< decltype(boost::filtered_graph(std::declval< graph_t >(), no_delay_edges{nullptr}))>

using	tc_graph = graph_static< tc_update< fast_tc >, static_exec >

using	bfs_graph = graph_static< bfs_update, static_exec >

using	logged_tc_graph = graph_static< tc_update< fast_tc >, static_exec_logger >

using	graph_t = boost::adjacency_list< boost::smallvecS, boost::smallvecS, boost::directedS, node_ptr, std::shared_ptr< graph_edge > >

using	graph_vertex_t = graph_t::vertex_descriptor

using	graph_edge_t = graph_t::edge_descriptor

template<typename T , typename V >
using	dense_shared_ptr_map = ankerl::unordered_dense::map< std::shared_ptr< T >, V, egur_hash, pointer_equal, std::vector< std::pair< std::shared_ptr< T >, V > > >

using	node_map = ossia::dense_shared_ptr_map< ossia::graph_node, graph_vertex_t >

using	edge_map = ossia::dense_shared_ptr_map< ossia::graph_edge, graph_edge_t >

using	node_flat_set = ossia::flat_set< graph_node * >

using	token_request_vec = ossia::small_vector< token_request, 4 >

using	simple_token_request_vec = ossia::small_vector< simple_token_request, 4 >

using	inlets = ossia::small_vector< inlet_ptr, 2 >

using	outlets = ossia::small_vector< outlet_ptr, 2 >

using	audio_channel = ossia::pod_vector< double >

using	audio_vector = ossia::small_vector< audio_channel, 2 >

using	audio_sample = float

using	audio_array = ossia::small_vector< ossia::pod_vector< audio_sample >, 2 >

template<typename T >
using	audio_span = ossia::small_vector< std::span< const T >, 8 >

template<typename T >
using	mutable_audio_span = ossia::small_vector< std::span< T >, 8 >

using	audio_handle = std::shared_ptr< audio_data >

using	repitch_stretcher = raw_stretcher

using	rubberband_stretcher = raw_stretcher

using	quarter_note = double

using	quantification_points = ossia::small_vector< quantification_point, 8 >

using	transport_info_fun = smallfun::function< void(const tick_transport_info &)>

template<typename T >
using	value_vector = ossia::small_vector< T, 4 >

template<typename Vector >
using	iterator_t = typename std::remove_reference< Vector >::type::iterator

using	any = std::any

using	any_map = string_map< ossia::any >
	A container to store any kind of data indexed by a string.

using	extended_attributes = any_map

template<typename Value >
using	case_insensitive_string_map = ossia::hash_map< std::string, Value, case_insensitive_hash, case_insensitive_equal >

using	destination_index = ossia::small_vector< int32_t, 2 >

template<typename K , typename V , typename Compare = std::less<void>, typename Alloc = std::allocator<std::pair<K, V>>>
using	flat_map = boost::container::flat_map< K, V, Compare, Alloc >

template<typename K , typename V >
using	flat_multimap = boost::container::flat_multimap< K, V >

template<typename K , typename Compare = std::less<void>>
using	flat_multiset = boost::container::flat_multiset< K, Compare >

template<typename K , typename Comparator = std::less<K>>
using	flat_set = boost::container::flat_set< K, Comparator >

template<typename K , typename H = ossia::hash<K>, typename E = ossia::equal_to<K>, typename A = std::allocator<K>>
using	hash_set = ankerl::unordered_dense::set< K, H, E, A >

template<typename K , typename V , typename H = ossia::hash<K>, typename E = ossia::equal_to<K>, typename A = std::allocator<std::pair<K, V>>>
using	hash_map = ankerl::unordered_dense::map< K, V, H, E, A >

template<typename K , typename V , typename H = ossia::hash<K>, typename E = ossia::equal_to<K>, typename A = void>
using	hash_multimap = std::unordered_multimap< K, V, H, E >

using	json_writer = rapidjson::Writer< rapidjson::StringBuffer, rapidjson::UTF8<>, rapidjson::UTF8<>, rapidjson::CrtAllocator, rapidjson::WriteFlag::kWriteNanAndInfFlag >

template<typename T , size_t MAX_BLOCK_SIZE = 512>
using	spsc_queue = moodycamel::ReaderWriterQueue< T, MAX_BLOCK_SIZE >

template<typename T >
using	mpmc_queue = moodycamel::ConcurrentQueue< T >

template<typename T >
using	blocking_mpmc_queue = moodycamel::BlockingConcurrentQueue< T >

using	logger_type = bruh_logger

using	mutex_t = std::mutex

using	shared_mutex_t = std::mutex

using	lock_t = std::lock_guard< mutex_t >

using	write_lock_t = std::lock_guard< mutex_t >

using	read_lock_t = std::lock_guard< mutex_t >

using	none_t = decltype(std::nullopt)

template<typename T >
using	pod_vector = boost::container::vector< T, pod_allocator_avx2< T > >

using	int_vector = pod_vector< int >

using	float_vector = pod_vector< float >

using	double_vector = pod_vector< double >

template<typename T >
using	ptr_container = std::vector< std::shared_ptr< T >, std::allocator< std::shared_ptr< T > > >

template<typename T , std::size_t N>
using	small_ptr_container = ossia::small_vector< std::shared_ptr< T >, N >

template<typename T >
using	ptr_set = ossia::hash_set< T, egur_hash, pointer_equal >

template<typename T , typename V >
using	ptr_map = ossia::hash_map< T, V, egur_hash, pointer_equal >

template<typename K , typename V , std::size_t N, typename Compare = std::less<void>>
using	small_flat_map = boost::container::flat_map< K, V, Compare, ossia::small_vector< std::pair< K, V >, N > >

template<typename K , typename V , std::size_t N, typename Compare = std::less<void>>
using	static_flat_map = boost::container::flat_map< K, V, Compare, ossia::static_vector< std::pair< K, V >, N > >

template<typename T , std::size_t N>
using	small_vector = boost::container::small_vector< T, N >

template<typename T , std::size_t N>
using	small_pod_vector = boost::container::small_vector< T, N, pod_allocator< T > >

template<typename T , std::size_t N>
using	static_vector = boost::container::static_vector< T, N >

template<typename Value >
using	string_map = ossia::hash_map< std::string, Value, string_hash, string_equal >

template<typename Value >
using	string_view_map = ossia::hash_map< std::string_view, Value, string_hash, string_equal >

using	string_view = std::string_view

using	thread_specs = ossia::flat_map< thread_type, thread_spec >

template<typename T , typename Compare = std::less<void>>
using	timed_vec = ossia::flat_map< int64_t, T, Compare >

template<typename T , std::size_t N, typename Compare = std::less<void>>
using	small_timed_vec = ossia::small_flat_map< int64_t, T, N, Compare >

template<typename T , auto func>
using	unique_handle = std::unique_ptr< T, libremidi::deleter< func > >

using	monostate = ossia_variant_alias::monostate

template<typename... Args>
using	variant = ossia_variant_alias::variant< Args... >

template<typename... Args>
using	slow_variant = ossia_variant_alias::variant< Args... >

template<std::size_t N, typename T >
using	variant_element = ossia_variant_alias::variant_alternative< N, T >

template<std::size_t N, typename T >
using	variant_element_t = ossia_variant_alias::variant_alternative_t< N, T >

template<typename K , typename V >
using	curve_map = ossia::flat_map< K, V >

using	curve_type = std::pair< ossia::curve_segment_type, ossia::curve_segment_type >

using	curve_ptr = std::shared_ptr< ossia::curve_abstract >

using	curve_segment = smallfun::function< Y(double, Y, Y), 24 >

using	expression_ptr = std::unique_ptr< expressions::expression_base >

using	expression = expressions::expression_base

using	clock_type = std::chrono::steady_clock

using	mark_start_discontinuous = mark_discontinuous<&graph_node::set_start_discontinuous >

using	mark_end_discontinuous = mark_discontinuous<&graph_node::set_end_discontinuous >

using	past_events_map = ossia::flat_multimap< time_value, time_event * >

using	DateMap = ossia::ptr_map< time_sync *, ossia::time_value >

using	EventPtr = std::shared_ptr< ossia::time_event >

using	IntervalPtr = std::shared_ptr< ossia::time_interval >

using	interval_set = ossia::flat_set< time_interval * >

using	sync_set = ossia::flat_set< time_sync * >

using	small_sync_vec = ossia::small_vector< time_sync *, 4 >

using	small_event_vec = std::vector< time_event * >

using	overtick_map = ossia::flat_map< time_sync *, overtick >

using	scenario_graph_vertex = time_sync *

using	scenario_graph_edge = time_interval *

using	scenario_graph_t = boost::adjacency_list< boost::smallvecS, boost::smallvecS, boost::undirectedS, scenario_graph_vertex, scenario_graph_edge >

using	time_signature_map = ossia::flat_map< ossia::time_value, time_signature >

using	physical_time = int64_t

using	state_element = ossia::nullable_variant< message, state, piecewise_message, piecewise_vec_message< 2 >, piecewise_vec_message< 3 >, piecewise_vec_message< 4 > >

template<std::size_t N>
using	state_element_by_index = typename ossia::variant_element_t< N, ossia::state_element >

using	bundle = std::span< bundle_element >

using	value_callback = std::function< void(const value &)>

using	extended_type = std::string
	How a low-level type should be interpreted.

using	complex_type = ossia::nullable_variant< ossia::val_type, ossia::unit_t, ossia::extended_type >

template<typename T , typename U >
using	enable_if_same_dataspace = std::enable_if_t< std::is_same< typename T::dataspace_type, typename U::dataspace_type >::value >

template<typename T , typename U >
using	enable_if_different_dataspace = std::enable_if_t< !std::is_same< typename T::dataspace_type, typename U::dataspace_type >::value >

using	degree = strong_value< degree_u >

using	radian = strong_value< radian_u >

using	argb = strong_value< argb_u >

using	rgba = strong_value< rgba_u >

using	rgba8 = strong_value< rgba8_u >

using	rgb = strong_value< rgb_u >

using	bgr = strong_value< bgr_u >

using	argb8 = strong_value< argb8_u >

using	hsv = strong_value< hsv_u >

using	cmy8 = strong_value< cmy8_u >

using	hsl = strong_value< hsl_u >

using	cmyk8 = strong_value< cmyk8_u >

using	xyz = strong_value< xyz_u >

using	yxy = strong_value< yxy_u >

using	hunter_lab = strong_value< hunter_lab_u >

using	cie_lab = strong_value< cie_lab_u >

using	cie_luv = strong_value< cie_luv_u >

using	meter_u = distance_ratio< std::ratio< 1 > >

using	kilometer_u = distance_ratio< std::kilo >

using	decimeter_u = distance_ratio< std::deci >

using	centimeter_u = distance_ratio< std::centi >

using	millimeter_u = distance_ratio< std::milli >

using	micrometer_u = distance_ratio< std::micro >

using	nanometer_u = distance_ratio< std::nano >

using	picometer_u = distance_ratio< std::pico >

using	inch_u = distance_ratio< std::ratio< 254, 10000 > >

using	foot_u = distance_ratio< std::ratio< 254 *12, 10000 > >

using	mile_u = distance_ratio< std::ratio< 254 12 5280, 10000 > >

using	meter = strong_value< meter_u >

using	kilometer = strong_value< kilometer_u >

using	decimeter = strong_value< decimeter_u >

using	centimeter = strong_value< centimeter_u >

using	millimeter = strong_value< millimeter_u >

using	micrometer = strong_value< micrometer_u >

using	nanometer = strong_value< nanometer_u >

using	picometer = strong_value< picometer_u >

using	inch = strong_value< inch_u >

using	foot = strong_value< foot_u >

using	mile = strong_value< mile_u >

using	linear = strong_value< linear_u >

using	midigain = strong_value< midigain_u >

using	decibel = strong_value< decibel_u >

using	decibel_raw = strong_value< decibel_raw_u >

using	quaternion = strong_value< quaternion_u >

using	euler = strong_value< euler_u >

using	axis = strong_value< axis_u >

using	cartesian_3d = strong_value< cartesian_3d_u >

using	cartesian_2d = strong_value< cartesian_2d_u >

using	spherical = strong_value< spherical_u >

using	polar = strong_value< polar_u >

using	aed = strong_value< aed_u >

using	ad = strong_value< ad_u >

using	opengl = strong_value< opengl_u >

using	cylindrical = strong_value< cylindrical_u >

using	azd = strong_value< azd_u >

using	meter_per_second_u = speed_ratio< std::ratio< 1 > >

using	miles_per_hour_u = speed_ratio< std::ratio< 254 12 5280, 3600 *10000 > >

using	kilometer_per_hour_u = speed_ratio< std::ratio< 1000, 3600 > >

using	knot_u = speed_ratio< std::ratio< 1852, 3600 > >

using	foot_per_hour_u = speed_ratio< std::ratio< 254 12, 3600 10000 > >

using	foot_per_second_u = speed_ratio< std::ratio< 254 *12, 10000 > >

using	meter_per_second = strong_value< meter_per_second_u >

using	miles_per_hour = strong_value< miles_per_hour_u >

using	kilometer_per_hour = strong_value< kilometer_per_hour_u >

using	knot = strong_value< knot_u >

using	foot_per_second = strong_value< foot_per_second_u >

using	foot_per_hour = strong_value< foot_per_hour_u >

using	second = strong_value< second_u >

using	bark = strong_value< bark_u >

using	bpm = strong_value< bpm_u >

using	cent = strong_value< cent_u >

using	frequency = strong_value< frequency_u >

using	mel = strong_value< mel_u >

using	midi_pitch = strong_value< midi_pitch_u >

using	millisecond = strong_value< millisecond_u >

using	playback_speed = strong_value< playback_speed_u >

using	unit_parse_symbols_t = boost::spirit::qi::symbols< char, ossia::destination_qualifiers >

using	angle_u_list = boost::mp11::mp_list< degree_u, radian_u >

using	color_u_list = boost::mp11::mp_list< argb_u, rgba_u, rgb_u, bgr_u, argb8_u, rgba8_u, hsv_u, cmy8_u, xyz_u >

using	distance_u_list = boost::mp11::mp_list< meter_u, kilometer_u, decimeter_u, centimeter_u, millimeter_u, micrometer_u, nanometer_u, picometer_u, inch_u, foot_u, mile_u >

using	gain_u_list = boost::mp11::mp_list< linear_u, midigain_u, decibel_u, decibel_raw_u >

using	orientation_u_list = boost::mp11::mp_list< quaternion_u, euler_u, axis_u >

using	position_u_list = boost::mp11::mp_list< cartesian_3d_u, cartesian_2d_u, spherical_u, polar_u, aed_u, ad_u, opengl_u, cylindrical_u, azd_u >

using	speed_u_list = boost::mp11::mp_list< meter_per_second_u, miles_per_hour_u, kilometer_per_hour_u, knot_u, foot_per_second_u, foot_per_hour_u >

using	timing_u_list = boost::mp11::mp_list< second_u, bark_u, bpm_u, cent_u, frequency_u, mel_u, midi_pitch_u, millisecond_u, playback_speed_u >

using	dataspace_variant_u_list = boost::mp11::mp_list< distance_u, position_u, speed_u, orientation_u, angle_u, color_u, gain_u, timing_u >

using	dataspace_u_list = boost::mp11::mp_list< distance_u_list, position_u_list, speed_u_list, orientation_u_list, angle_u_list, color_u_list, gain_u_list, timing_u_list >

using	angle_list = boost::mp11::mp_list< degree, radian >

using	color_list = boost::mp11::mp_list< argb, rgba, rgb, bgr, argb8, rgba8, hsv, cmy8, xyz >

using	distance_list = boost::mp11::mp_list< meter, kilometer, decimeter, centimeter, millimeter, micrometer, nanometer, picometer, inch, foot, mile >

using	gain_list = boost::mp11::mp_list< linear, midigain, decibel, decibel_raw >

using	orientation_list = boost::mp11::mp_list< quaternion, euler, axis >

using	position_list = boost::mp11::mp_list< cartesian_3d, cartesian_2d, spherical, polar, aed, ad, opengl, cylindrical, azd >

using	speed_list = boost::mp11::mp_list< meter_per_second, miles_per_hour, kilometer_per_hour, knot, foot_per_second, foot_per_hour >

using	time_list = boost::mp11::mp_list< second, bark, bpm, cent, frequency, mel, midi_pitch, millisecond, playback_speed >

using	dataspace_list = boost::mp11::mp_list< distance_list, position_list, speed_list, orientation_list, angle_list, color_list, gain_list, time_list >

using	strong_value_variant_list = boost::mp11::mp_list< ossia::value, distance, position, speed, orientation, angle, color, gain, ossia::timing >

using	value_map_element = std::pair< std::string, ossia::value >

using	value_variant = value_variant_type

using	vec2f = std::array< float, 2ul >

using	vec3f = std::array< float, 3ul >

using	vec4f = std::array< float, 4ul >

Enumerations
enum	transport_mode { none , client , master }

enum	transport_status { stopped , starting , playing }

enum	audio_stretch_mode : int8_t { None , RubberBandStandard , RubberBandPercussive , Repitch , RubberBandStandardHQ , RubberBandPercussiveHQ , RepitchMediumQ , RepitchFastestQ }

enum class	attribute_semantic : uint16_t { position = 0 , normal = 1 , tangent = 2 , bitangent = 3 , texcoord0 = 100 , texcoord1 = texcoord0 + 1 , texcoord2 = texcoord0 + 2 , texcoord3 = texcoord0 + 3 , texcoord4 = texcoord0 + 4 , texcoord5 = texcoord0 + 5 , texcoord6 = texcoord0 + 6 , texcoord7 = texcoord0 + 7 , color0 = 200 , color1 = color0 + 1 , color2 = color0 + 2 , color3 = color0 + 3 , joints0 = 300 , joints1 = joints0 + 1 , weights0 = 400 , weights1 = weights0 + 1 , morph_position = 500 , morph_normal = morph_position + 1 , morph_tangent = morph_position + 2 , morph_texcoord = morph_position + 3 , morph_color = morph_position + 4 , rotation = 600 , rotation_extra = rotation + 1 , scale = rotation + 2 , uniform_scale = rotation + 3 , up = rotation + 4 , pivot = rotation + 5 , transform_matrix = rotation + 6 , translation = rotation + 7 , velocity = 1000 , acceleration = velocity + 1 , force = velocity + 2 , mass = velocity + 3 , age = velocity + 4 , lifetime = velocity + 5 , birth_time = velocity + 6 , particle_id = velocity + 7 , drag = velocity + 8 , angular_velocity = velocity + 9 , previous_position = velocity + 10 , rest_position = velocity + 11 , target_position = velocity + 12 , previous_velocity = velocity + 13 , state = velocity + 14 , collision_count = velocity + 15 , collision_normal = velocity + 16 , sleep = velocity + 17 , sprite_size = 1100 , sprite_rotation = sprite_size + 1 , sprite_facing = sprite_size + 2 , sprite_index = sprite_size + 3 , width = sprite_size + 4 , opacity = sprite_size + 5 , emissive = sprite_size + 6 , emissive_strength = sprite_size + 7 , roughness = 1200 , metallic = roughness + 1 , ambient_occlusion = roughness + 2 , specular = roughness + 3 , subsurface = roughness + 4 , clearcoat = roughness + 5 , clearcoat_roughness = roughness + 6 , anisotropy = roughness + 7 , anisotropy_direction = roughness + 8 , ior = roughness + 9 , transmission = roughness + 10 , thickness = roughness + 11 , material_id = roughness + 22 , sh_dc = 1300 , sh_coeffs = sh_dc + 1 , covariance_3d = sh_dc + 2 , sh_degree = sh_dc + 3 , density = 1400 , temperature = density + 1 , fuel = density + 2 , pressure = density + 3 , divergence = density + 4 , sdf_distance = density + 5 , voxel_color = density + 6 , name = 1600 , piece_id = name + 1 , line_id = name + 2 , prim_id = name + 3 , point_id = name + 4 , group_mask = name + 5 , instance_id = name + 6 , selection = 1700 , instance_color0 = 1800 , instance_color1 = instance_color0 + 1 , instance_color2 = instance_color0 + 2 , instance_color3 = instance_color0 + 3 , instance_custom0 = instance_color0 + 4 , instance_custom1 = instance_color0 + 5 , instance_custom2 = instance_color0 + 6 , instance_custom3 = instance_color0 + 7 , instance_draw_id = instance_color0 + 8 , fx0 = 2000 , fx1 = fx0 + 1 , fx2 = fx0 + 2 , fx3 = fx0 + 3 , fx4 = fx0 + 4 , fx5 = fx0 + 5 , fx6 = fx0 + 6 , fx7 = fx0 + 7 , custom = 0xFFFF }

enum class	vertex_format : uint8_t { float1 , float2 , float3 , float4 , half1 , half2 , half3 , half4 , unorm8x1 , unorm8x2 , unorm8x4 , snorm8x1 , snorm8x2 , snorm8x4 , uint8x1 , uint8x2 , uint8x4 , uint16x1 , uint16x2 , uint16x4 , uint32x1 , uint32x2 , uint32x3 , uint32x4 , sint8x1 , sint8x2 , sint8x4 , sint16x1 , sint16x2 , sint16x4 , sint32x1 , sint32x2 , sint32x3 , sint32x4 , rgb10a2_unorm , rg11b10_float , user_struct }

enum class	primitive_topology : uint8_t { points , lines , line_strip , triangles , triangle_strip , triangle_fan , patches , meshlets }

enum class	index_format : uint8_t { none , uint16 , uint32 }

enum class	alpha_mode : uint8_t { opaque_ , mask , blend }

enum class	light_type : uint8_t { directional , point , spot , rect_area , disk_area , sphere_area , cylinder_area , dome }

enum class	light_decay : uint8_t { none , linear , quadratic , cubic }

enum class	camera_projection : uint8_t { perspective , orthographic , fulldome }

enum class	skinning_method : uint8_t { linear_blend , dual_quaternion }

enum class	animation_interpolation : uint8_t { step , linear , cubic_spline }

enum class	animation_target : uint8_t { translation , rotation , scale , weights , custom }

enum class	scene_purpose : uint8_t { default_ = 0 , render = 1 , proxy = 2 , guide = 3 }

enum class	node_ordering { topological , temporal , hierarchical }

enum	texture_filter { NONE , NEAREST , LINEAR }

enum	texture_address_mode { REPEAT , CLAMP_TO_EDGE , MIRROR }

enum	texture_format { RGBA8 , BGRA8 , R8 , RG8 , R16 , RG16 , RED_OR_ALPHA8 , RGBA16F , RGBA32F , R16F , R32F , RGB10A2 , D16 , D24 , D24S8 , D32F }

enum	data_mix_method : int8_t { mix_append , mix_replace , mix_merge }

enum class	thread_type : unsigned char { Net = 'N' , Midi = 'M' , Gpu = 'G' , GpuTask = 'g' , Audio = 'A' , AudioTask = 'a' , Ui = 'U' , UiTask = 'u' , Render = 'R' , RenderTask = 'r' }

enum class	curve_segment_type { INT , FLOAT , DOUBLE , BOOL , INT64 , ANY }
	The curve_segment_type enum. More...

enum	progress_mode { PROGRESS_MIN , PROGRESS_MAX }

enum class	sync_status { NOT_READY , RETRY , DONE }

enum class	track_state : std::uint8_t { provisional , confirmed , coasting , revived , lost , expired }

enum class	track_motion_gate : std::uint8_t { off , max_speed , mahalanobis }

enum class	track_slot_allocation : std::uint8_t { lowest_free , round_robin , nearest_vacated }

enum class	track_slot_steal : std::uint8_t { never , stalest , lowest_confidence }

enum class	val_type : int8_t { FLOAT , INT , VEC2F , VEC3F , VEC4F , IMPULSE , BOOL , STRING , LIST , MAP , NONE = std::numeric_limits<int8_t>::max() }
	Enum to represent the types that a value can take. More...

enum class	parameter_type : int8_t { MESSAGE , AUDIO , MIDI , TEXTURE , GEOMETRY }
	Possible types of parameters / ports.

enum class	access_mode : int8_t { BI , GET , SET }
	Address behaviors at crossing domain boundaries time. More...

enum class	bounding_mode : int8_t { FREE , CLIP , WRAP , FOLD , CLAMP_LOW , CLAMP_HIGH }
	Address behaviors at crossing domain boundaries. More...

enum	repetition_filter : bool { OFF = false , ON = true }
	If enabled, sending twice the same value will only send it once by network.

Functions
OSSIA_EXPORT std::string	get_commit_sha ()

OSSIA_EXPORT std::string	get_commit_date ()

ossia::audio_engine *	make_audio_engine (std::string proto, std::string name, std::string req_in, std::string req_out, int &inputs, int &outputs, int &rate, int &bs)

spdlog::logger &	logger () noexcept
	Where the errors will be logged. Default is stderr.

std::shared_ptr< spdlog::logger >	logger_ptr () noexcept

OSSIA_EXPORT void	ensure_vector_sizes (const audio_vector &src_vec, audio_vector &sink_vec)

OSSIA_EXPORT void	mix (const audio_vector &src_vec, audio_vector &sink_vec)

void	process_control_value (ossia::value &v, const ossia::domain &source_domain, const ossia::domain &sink_domain) noexcept

void	process_control_value (ossia::value &v, const ossia::complex_type &source_type, const ossia::complex_type &sink_type) noexcept

void	process_control_value (ossia::value &v, const ossia::domain &source_domain, const ossia::domain &sink_domain, const ossia::complex_type &source_type, const ossia::complex_type &sink_type) noexcept

template<typename Fun , typename NodeFun , typename DeviceList_T >
bool	apply_to_destination (const destination_t &address, const DeviceList_T &devices, Fun f, NodeFun nf)

std::vector< ossia::net::node_base * >	list_destinations (const destination_t &address, const ossia::small_vector< ossia::net::device_base *, 4 > &devices)

ossia::net::node_base *	get_first_destination (const destination_t &address, const ossia::small_vector< ossia::net::device_base *, 4 > &devices)

void	to_state_element (ossia::net::parameter_base &p, const ossia::typed_value &v, std::vector< state_element > &out)

ossia::message	to_state_element (ossia::net::parameter_base &p, ossia::typed_value &&v)

ossia::message	to_state_element (ossia::net::parameter_base &p, const ossia::typed_value &v)

template<typename SampleFormat , int N>
constexpr SampleFormat	float_to_sample (ossia::audio_sample sample) noexcept

template<>
constexpr uint8_t	float_to_sample< uint8_t, 8 > (ossia::audio_sample sample) noexcept

template<>
constexpr int16_t	float_to_sample< int16_t, 16 > (ossia::audio_sample sample) noexcept

template<>
constexpr int32_t	float_to_sample< int32_t, 24 > (ossia::audio_sample x) noexcept

template<>
constexpr int32_t	float_to_sample< int32_t, 32 > (audio_sample x) noexcept

template<>
constexpr float	float_to_sample< float, 32 > (float sample) noexcept

template<typename SampleFormat , int N, int ByteIncrement, typename InputFormat > requires (sizeof(SampleFormat) == ByteIncrement)
void	interleave (const InputFormat const OSSIA_RESTRICT in, SampleFormat *OSSIA_RESTRICT out, int channels, int bs)

template<typename SampleFormat , int N, int ByteIncrement, typename InputFormat > requires (sizeof(SampleFormat) != ByteIncrement)
void	interleave (const InputFormat const OSSIA_RESTRICT in, SampleFormat *out, int channels, int bs)

template<typename SampleFormat , int N, typename InputFormat >
void	convert (const InputFormat const OSSIA_RESTRICT in, SampleFormat *OSSIA_RESTRICT out, int channels, int bs)

template<typename Fin >
void	for_each_inlet (const ossia::graph_node &node, Fin &&fin) noexcept

template<typename Fin >
bool	any_of_inlet (const ossia::graph_node &node, Fin &&fin) noexcept

template<typename Fin >
bool	all_of_inlet (const ossia::graph_node &node, Fin &&fin) noexcept

template<typename Fout >
void	for_each_outlet (const ossia::graph_node &node, Fout &&fout) noexcept

template<typename Fout >
bool	any_of_outlet (const ossia::graph_node &node, Fout &&fout) noexcept

template<typename Fout >
bool	all_of_outlet (const ossia::graph_node &node, Fout &&fout) noexcept

const ossia::value &	last (const ossia::value_vector< ossia::timed_value > &vec)

uint64_t	mint_stable_id () noexcept

std::string_view	semantic_to_name (attribute_semantic s) noexcept

attribute_semantic	name_to_semantic (std::string_view name) noexcept

scene_spec	wrap_geometry_as_scene (const geometry_spec &geom)

geometry_spec	extract_first_geometry (const scene_spec &scene)

scene_spec	merge_scenes (std::span< const scene_spec > scenes)

aabb	compute_aabb_from_positions (const float *positions, std::size_t vertex_count) noexcept

std::shared_ptr< bench_map >	bench_ptr ()

std::shared_ptr< ossia::graph_interface >	make_graph_impl (const ossia::graph_setup_options &opt)

std::shared_ptr< ossia::graph_interface >	make_graph_par_impl (const ossia::graph_setup_options &opt)

std::shared_ptr< ossia::graph_interface >	make_graph (const ossia::graph_setup_options &opt)

smallfun::function< void(unsigned long, double), 128 >	make_tick (const tick_setup_options &settings, ossia::execution_state &st, ossia::graph_interface &gb, ossia::time_interval &itv, ossia::scenario &root, ossia::transport_info_fun transport)

void	remove_vertex (typename graph_t::vertex_descriptor v, graph_t &g)

template<typename VertexListGraph , typename FilteredGraph , typename OutputIterator >
void	custom_topological_sort (FilteredGraph &g, OutputIterator result, std::vector< boost::default_color_type > &color_map, std::vector< boost::detail::DFSVertexInfo< VertexListGraph, FilteredGraph > > &stack)

template<typename T >
auto	apply_con (const T &visitor, ossia::connection &con)

template<typename T >
auto	apply_con (const T &visitor, const ossia::connection &con)

template<typename Graph_T , typename IO >
void	print_graph (Graph_T &g, IO &stream)

template<typename T >
void	resize_and_fill (T &vec, const std::size_t N)

template<typename T >
void	resize_and_fill (std::vector< std::vector< T > > &vec, const std::size_t N)

template<typename T >
void	resize_and_fill (std::vector< std::vector< T > > &vec, const std::size_t N, const std::size_t init_num, T init_val)

template<typename Graph , typename GraphTC , typename G_to_TC_VertexMap , typename VertexIndexMap >
void	transitive_closure (const Graph &g, GraphTC &tc, G_to_TC_VertexMap g_to_tc_map, VertexIndexMap index_map, TransitiveClosureState< Graph, GraphTC > &state)

template<typename Graph , typename GraphTC >
void	transitive_closure (const Graph &g, GraphTC &tc, TransitiveClosureState< Graph, GraphTC > &tc_state)

auto	make_strict_edge (graph_interface &g, int pout, int pin, ossia::node_ptr nout, ossia::node_ptr nin)

auto	make_glutton_edge (graph_interface &g, int pout, int pin, ossia::node_ptr nout, ossia::node_ptr nin)

auto	make_delayed_strict_edge (graph_interface &g, int pout, int pin, ossia::node_ptr nout, ossia::node_ptr nin)

auto	make_delayed_glutton_edge (graph_interface &g, int pout, int pin, ossia::node_ptr nout, ossia::node_ptr nin)

bool	operator== (const token_request_vec &lhs, const simple_token_request_vec &rhs)

bool	operator!= (const token_request_vec &lhs, const simple_token_request_vec &rhs)

bool	operator== (const simple_token_request_vec &lhs, const token_request_vec &rhs)

bool	operator!= (const simple_token_request_vec &lhs, const token_request_vec &rhs)

template<typename T , typename... Args> requires std::is_constructible_v<T, Args...>
auto	make_node (const execution_state &st, Args &&... args)

void	process_audio_out_mono (ossia::audio_port &i, ossia::audio_outlet &audio_out)

void	process_audio_out_general (ossia::audio_port &i, ossia::audio_outlet &audio_out)

void	process_audio_out_mono (ossia::audio_outlet &audio_out)

void	process_audio_out_general (ossia::audio_outlet &audio_out)

template<typename SampleFormat , int N>
constexpr audio_sample	sample_to_float (SampleFormat i)

template<>
constexpr audio_sample	sample_to_float< uint8_t, 8 > (uint8_t i)

template<>
constexpr audio_sample	sample_to_float< int16_t, 16 > (int16_t i)

template<>
constexpr audio_sample	sample_to_float< int32_t, 24 > (int32_t i)

template<>
constexpr audio_sample	sample_to_float< int32_t, 32 > (int32_t i)

template<>
constexpr audio_sample	sample_to_float< float, 32 > (float i)

template<>
constexpr audio_sample	sample_to_float< double, 64 > (double i)

void	read_u8 (ossia::mutable_audio_span< float > &ap, void *data, int64_t samples)

void	read_s16 (ossia::mutable_audio_span< float > &ap, void *data, int64_t samples)

void	read_s24 (ossia::mutable_audio_span< float > &ap, void *data, int64_t samples)

void	read_s32 (ossia::mutable_audio_span< float > &ap, void *data, int64_t samples)

void	read_f32 (ossia::mutable_audio_span< float > &ap, void *data, int64_t samples)

void	read_f64 (ossia::mutable_audio_span< float > &ap, void *data, int64_t samples)

bool	operator== (const token_request &lhs, const token_request &rhs)

bool	operator!= (const token_request &lhs, const token_request &rhs)

template<typename Vector , typename Value >
auto	find (Vector &&v, const Value &val) noexcept

template<typename Vector , typename Fun >
auto	find_if (Vector &&v, Fun &&fun)

template<typename Vector , typename Value >
auto *	ptr_find (Vector &&v, const Value &val) noexcept

template<typename Vector , typename Fun >
auto *	ptr_find_if (Vector &&v, Fun &&fun)

template<typename Vector , typename Value >
bool	contains (Vector &&v, const Value &val) noexcept

template<typename Vector , typename Value >
void	remove_one (Vector &&v, const Value &val)

template<typename Vector , typename Function >
void	remove_one_if (Vector &v, const Function &val)

template<typename Vector , typename Value >
void	remove_erase (Vector &v, const Value &val)

template<typename Vector , typename Function >
void	remove_erase_if (Vector &v, const Function &val)

template<typename Vector , typename Fun >
void	erase_if (Vector &r, Fun f)

template<typename Vector , typename Fun >
bool	any_of (Vector &&v, Fun &&fun) noexcept

template<typename Vector , typename Fun >
auto	all_of (Vector &&v, Fun &&fun) noexcept

template<typename Vector , typename Fun >
bool	none_of (Vector &&v, Fun &&fun) noexcept

template<typename Vector , typename Fun >
auto	remove_if (Vector &&v, Fun &&fun)

template<typename Vector , typename Fun >
auto	count_if (Vector &&v, Fun &&fun)

template<typename Vector , typename Fun >
auto	max_element (Vector &&v, Fun &&fun)

template<typename Vector >
auto	sort (Vector &&v)

template<typename Vector , typename T >
auto	fill (Vector &&v, const T &val)

template<typename Vector >
auto	unique (Vector &&v)

template<typename Vector , typename Fun >
auto	sort (Vector &&v, Fun &&fun)

template<typename Vector , typename OutputIterator , typename Fun >
auto	transform (Vector &&v, OutputIterator it, Fun f)

template<typename Array1 , typename Array2 >
auto	equal (const Array1 &v, const Array2 &v2) noexcept

template<typename Vector1 , typename Vector2 >
void	copy (const Vector1 &source, Vector2 &destination)

template<typename Vector1 , typename Vector2 , typename Pred >
void	copy_if (const Vector1 &source, Vector2 &destination, Pred predicate)

template<typename T , typename K >
auto	last_before (T &&container, const K &k)

template<typename T , typename K >
auto	find_key (T &&vec, const K &key) noexcept

template<typename T , typename K0 , typename K1 >
auto	find_key (T &&vec, const K0 &k0, const K1 &k1) noexcept

template<class F , std::size_t... Is>
void	for_each_in_range (F &&func, std::index_sequence< Is... >)

template<std::size_t N, typename F >
void	for_each_in_range (F &&func)

template<class T , std::size_t N>
constexpr std::array< std::remove_cv_t< T >, N >	to_array (T(&a)[N]) noexcept

template<typename... Args>
constexpr std::array< const char *, sizeof...(Args)>	make_array (Args &&... args) noexcept

template<typename T >
void	remove_duplicates (T &vec)

template<typename T , typename Comp >
void	remove_duplicates (T &vec, Comp comparator)

template<typename Container , typename K , typename Comp , typename... Args>
auto	emplace_sorted (Container &vec, const K &k, Comp &&comp, Args &&... args) -> decltype(auto)

template<typename D , template< typename, typename > typename S, typename T , typename Alloc >
auto	insert_at_end (D &dest, S< T, Alloc > &&src)

template<typename T >
void	change_item_position (T &v, size_t oldIndex, size_t newIndex)

template<typename Container , typename Item >
int	index_in_container (Container &vec, Item i) noexcept

bool	has_attribute (const any_map &e, std::string_view str) noexcept
	Checks if an attribute is present.

void	set_attribute (any_map &e, std::string_view str)
	Sets a bool-like attribute. It should be checked for with has_attribute.

void	set_attribute (any_map &e, std::string_view str, std::nullopt_t)
	Removes an attribute in an any_map.

void	unset_attribute (any_map &e, std::string_view str)
	Remove an attribute.

template<typename T >
auto	get_attribute (const any_map &e, std::string_view name)
	get_attribute Get an attribute of an any_map.

template<typename T >
std::optional< T >	get_optional_attribute (const any_map &e, std::string_view name)
	get_optional_attribute Maybe get an attribute of an any_map.

template<typename T >
void	set_attribute (any_map &e, std::string_view str, const T &val)
	Sets an attribute in an any_map.

template<typename T >
void	set_attribute (any_map &e, std::string_view str, T &&val)
	Sets an attribute in an any_map.

template<typename T >
void	set_optional_attribute (any_map &e, std::string_view str, const std::optional< T > &opt)
	Sets an attribute if opt has a value, else remove the attribute.

template<typename T >
void	set_optional_attribute (any_map &e, std::string_view str, std::optional< T > &&opt)

struct	TS_CAPABILITY ("mutex") audio_spin_mutex

template<typename T , typename U >
const auto &	closest_element (const T &vec, const U &val) noexcept

template<typename T , typename U >
auto	closest_element_it (const T &vec, const U &val) noexcept

template<typename T , typename U >
auto	closest_next_element (T it, T end, const U &val) noexcept

template<typename T , typename U > requires requires(T it) { it->first; it->second; }
auto	closest_next_element (T it, T end, const U &val) noexcept

constexpr small_string	to_lower (std::string_view arr)

void	disable_fpe ()

void	reset_default_fpu_state ()

template<template< typename... > typename T, typename... Args, typename F >
constexpr void	for_each (T< Args... >, F f)

template<template< typename... > typename T, typename... Args, typename F >
constexpr void	for_each_tagged (T< Args... >, F f)

template<typename... Args, typename F >
constexpr void	for_each_type (F f)

template<template< typename... > typename T, typename... Args, typename F >
constexpr void	for_each_type (T< Args... >, F f)

template<typename... Args, typename F >
constexpr void	for_each_type_tagged (F f)

template<typename... Args, typename F >
constexpr void	for_each_type_if (F &&f)

template<typename... Args, typename F >
constexpr void	for_each_type_if_tagged (F &&f)

template<class Tuple , class F >
void	for_each_in_tuple (Tuple &&tuple, F &&func)

template<class F , class T1 , std::size_t... I1s, class T2 >
void	for_each_in_tuples_impl (T1 &&t1, T2 &&t2, F &&func, std::index_sequence< I1s... >)

template<class F , template< class... > class T1, class... T1s, template< class... > class T2, class... T2s>
void	for_each_in_tuples (T1< T1s... > &&t1, T2< T2s... > &&t2, F &&func)

template<class F , template< class... > class T1, class... T1s, std::size_t... I1s, template< class... > class T2, class... T2s>
void	for_each_in_tuples_ref_impl (T1< T1s... > &t1, T2< T2s... > &t2, F &&func, std::index_sequence< I1s... >)

template<class F , template< class... > class T1, class... T1s, template< class... > class T2, class... T2s>
void	for_each_in_tuples_ref (T1< T1s... > &t1, T2< T2s... > &t2, F &&func)

template<template< class... > class T1, class... T1s, std::size_t... I1s, template< class... > class T2, class... T2s>
auto	concat_tuples_impl (T1< T1s... > &t1, T2< T2s... > &t2, std::index_sequence< I1s... >)

template<template< class... > class T1, class... T1s, template< class... > class T2, class... T2s>
void	concat_tuples (T1< T1s... > &t1, T2< T2s... > &t2)

template<class F , template< class... > class T1, class... T1s, std::size_t... I1s, typename U , std::size_t N>
void	tuple_array_func_impl (T1< T1s... > &t1, std::array< U, N > &t2, F &&func, std::index_sequence< I1s... >)

template<class F , template< class... > class T1, class... T1s, typename U , std::size_t N>
void	tuple_array_func (T1< T1s... > &&t1, std::array< U, N > &t2, F &&func)

OSSIA_INLINE uint64_t	hash_bytes (const void *data, std::size_t size) noexcept

OSSIA_INLINE uint64_t	hash_string (std::string_view sv) noexcept

template<typename T >
OSSIA_INLINE uint64_t	hash_trivial (const T &v) noexcept

template<typename T >
OSSIA_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK constexpr void	hash_combine (std::size_t &seed, const T &k) noexcept

template<typename T >
OSSIA_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK constexpr void	hash_combine (std::size_t &seed, const T *k) noexcept

OSSIA_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK constexpr void	hash_combine (uint64_t &seed, uint8_t k) noexcept

OSSIA_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK constexpr void	hash_combine (uint64_t &seed, int8_t k) noexcept

OSSIA_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK constexpr void	hash_combine (uint64_t &seed, uint16_t k) noexcept

OSSIA_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK constexpr void	hash_combine (uint64_t &seed, int16_t k) noexcept

OSSIA_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK constexpr void	hash_combine (uint64_t &seed, uint32_t k) noexcept

OSSIA_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK constexpr void	hash_combine (uint64_t &seed, int32_t k) noexcept

OSSIA_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK constexpr void	hash_combine (uint64_t &seed, int64_t k) noexcept

OSSIA_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK constexpr void	hash_combine (uint32_t &seed, uint8_t k) noexcept

OSSIA_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK constexpr void	hash_combine (uint32_t &seed, int8_t k) noexcept

OSSIA_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK constexpr void	hash_combine (uint32_t &seed, uint16_t k) noexcept

OSSIA_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK constexpr void	hash_combine (uint32_t &seed, int16_t k) noexcept

OSSIA_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK constexpr void	hash_combine (uint32_t &seed, int32_t k) noexcept

OSSIA_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK constexpr void	hash_combine (uint32_t &seed, uint64_t k) noexcept

OSSIA_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK constexpr void	hash_combine (uint32_t &seed, int64_t k) noexcept

OSSIA_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK constexpr void	hash_combine (uint32_t &h1, uint32_t k1) noexcept

OSSIA_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK constexpr void	hash_combine (uint64_t &h, uint64_t k) noexcept

template<typename T >
T	ipow (T x, int N) noexcept

template<typename T >
auto	norm (T x, T y) noexcept

template<typename T >
auto	norm (T x, T y, T z) noexcept

constexpr size_t	constexpr_log2 (size_t n) noexcept

template<typename T >
constexpr size_t	constexpr_abs (T n) noexcept

template<typename T >
constexpr int64_t	constexpr_floor (T val) noexcept

template<typename T >
constexpr int64_t	constexpr_ceil (T f)

template<class T , class U >
OSSIA_INLINE constexpr auto	max (const T a, const U b) noexcept -> typename std::conditional<(sizeof(T) > sizeof(U)), T, U >::type
	max function tailored for values

template<class T , class U >
OSSIA_INLINE constexpr auto	min (const T a, const U b) noexcept -> typename std::conditional<(sizeof(T) > sizeof(U)), T, U >::type
	min function tailored for values

template<class T >
OSSIA_INLINE constexpr T	clamp (T d, const T min, const T max) noexcept
	clamp Returns the value bounded by a min and a max

template<class T >
OSSIA_INLINE constexpr T	wrap (const T val, const T low, const T high) noexcept

template<class T >
OSSIA_INLINE constexpr T	fold (const T val, const T low, const T high) noexcept

template<class T >
OSSIA_INLINE constexpr std::pair< T, T >	div (T num, T denom) noexcept

OSSIA_INLINE float	log_to_normalized (float min, float range, float val) noexcept

OSSIA_INLINE float	normalized_to_log (float min, float range, float val) noexcept

template<typename T , typename R >
constexpr OSSIA_INLINE bool	valid_index (T idx, const R &range) noexcept

template<template< typename... > typename Sequence, template< typename... > typename Tuple, typename... Args>
auto	list_of_tuple_to_tuple_of_list (const Sequence< Tuple< Args... > > &lst)

OSSIA_MAXIMUM_INLINE constexpr bool	operator== (nullable_variant_index lhs, nullable_variant_index rhs) noexcept

OSSIA_MAXIMUM_INLINE constexpr bool	operator!= (nullable_variant_index lhs, nullable_variant_index rhs) noexcept

OSSIA_MAXIMUM_INLINE constexpr bool	operator< (nullable_variant_index lhs, nullable_variant_index rhs) noexcept

template<typename F , typename... Args>
OSSIA_MAXIMUM_INLINE auto	apply (F &&visitor, ossia::nullable_variant< Args... > &variant) -> decltype(auto)

template<typename F , typename... Args>
OSSIA_MAXIMUM_INLINE auto	apply (F &&visitor, const ossia::nullable_variant< Args... > &variant) -> decltype(auto)

template<typename F , typename... Args>
OSSIA_MAXIMUM_INLINE auto	apply (F &&visitor, ossia::nullable_variant< Args... > &&variant) -> decltype(auto)

template<typename F , typename... Args>
OSSIA_MAXIMUM_INLINE auto	apply_nonnull (F &&visitor, ossia::nullable_variant< Args... > &variant) -> decltype(auto)

template<typename F , typename... Args>
OSSIA_MAXIMUM_INLINE auto	apply_nonnull (F &&visitor, const ossia::nullable_variant< Args... > &variant) -> decltype(auto)

template<typename F , typename... Args>
OSSIA_MAXIMUM_INLINE auto	apply_nonnull (F &&visitor, ossia::nullable_variant< Args... > &&variant) -> decltype(auto)

template<typename F , typename... Args>
OSSIA_MAXIMUM_INLINE auto	apply_nonnull (F &&visitor, ossia::nullable_variant< Args... > &v1, ossia::nullable_variant< Args... > &v2) -> decltype(auto)

template<typename F , typename... Args>
OSSIA_MAXIMUM_INLINE auto	apply_nonnull (F &&visitor, const ossia::nullable_variant< Args... > &v1, const ossia::nullable_variant< Args... > &v2) -> decltype(auto)

template<typename F , typename... Args>
OSSIA_MAXIMUM_INLINE auto	apply_nonnull (F &&visitor, ossia::nullable_variant< Args... > &&v1, const ossia::nullable_variant< Args... > &&v2) -> decltype(auto)

template<typename... Ts>
OSSIA_MAXIMUM_INLINE constexpr bool	operator== (const nullable_variant< Ts... > &lhs, const nullable_variant< Ts... > &rhs)

template<typename... Ts>
OSSIA_MAXIMUM_INLINE constexpr bool	operator!= (const nullable_variant< Ts... > &lhs, const nullable_variant< Ts... > &rhs)

template<typename... Ts>
OSSIA_MAXIMUM_INLINE constexpr bool	operator< (const nullable_variant< Ts... > &lhs, const nullable_variant< Ts... > &rhs)

template<typename... Ts>
OSSIA_MAXIMUM_INLINE constexpr bool	operator> (const nullable_variant< Ts... > &lhs, const nullable_variant< Ts... > &rhs)

template<typename... Ts>
OSSIA_MAXIMUM_INLINE constexpr bool	operator<= (const nullable_variant< Ts... > &lhs, const nullable_variant< Ts... > &rhs)

template<typename... Ts>
OSSIA_MAXIMUM_INLINE constexpr bool	operator>= (const nullable_variant< Ts... > &lhs, const nullable_variant< Ts... > &rhs)

template<typename L , typename... Ts>
OSSIA_MAXIMUM_INLINE constexpr bool	operator== (const L &lhs, const nullable_variant< Ts... > &rhs)

template<typename L , typename... Ts>
OSSIA_MAXIMUM_INLINE constexpr bool	operator!= (const L &lhs, const nullable_variant< Ts... > &rhs)

template<typename L , typename... Ts>
OSSIA_MAXIMUM_INLINE constexpr bool	operator< (const L &lhs, const nullable_variant< Ts... > &rhs)

template<typename L , typename... Ts>
OSSIA_MAXIMUM_INLINE constexpr bool	operator> (const L &lhs, const nullable_variant< Ts... > &rhs)

template<typename L , typename... Ts>
OSSIA_MAXIMUM_INLINE constexpr bool	operator<= (const L &lhs, const nullable_variant< Ts... > &rhs)

template<typename L , typename... Ts>
OSSIA_MAXIMUM_INLINE constexpr bool	operator>= (const L &lhs, const nullable_variant< Ts... > &rhs)

template<typename R , typename... Ts>
OSSIA_MAXIMUM_INLINE constexpr bool	operator== (const nullable_variant< Ts... > &lhs, const R &rhs)

template<typename R , typename... Ts>
OSSIA_MAXIMUM_INLINE constexpr bool	operator!= (const nullable_variant< Ts... > &lhs, const R &rhs)

template<typename R , typename... Ts>
OSSIA_MAXIMUM_INLINE constexpr bool	operator< (const nullable_variant< Ts... > &lhs, const R &rhs)

template<typename R , typename... Ts>
OSSIA_MAXIMUM_INLINE constexpr bool	operator> (const nullable_variant< Ts... > &lhs, const R &rhs)

template<typename R , typename... Ts>
OSSIA_MAXIMUM_INLINE constexpr bool	operator<= (const nullable_variant< Ts... > &lhs, const R &rhs)

template<typename R , typename... Ts>
OSSIA_MAXIMUM_INLINE constexpr bool	operator>= (const nullable_variant< Ts... > &lhs, const R &rhs)

template<typename Opt , typename Arg >
auto	get_value_or (const Opt &opt, Arg &&arg)

template<>
std::optional< int >	parse_relax< int > (std::string_view v)

template<>
std::optional< float >	parse_relax< float > (std::string_view v)

template<>
std::optional< double >	parse_relax< double > (std::string_view v)

template<std::size_t Align = pod_vector_alignment, typename T >
T *	assume_aligned (T *p) noexcept
	Tell the optimizer that p is aligned on Align bytes.

template<typename T >
T *	aligned_data (pod_vector< T > &v) noexcept
	v.data(), with the alignment guarantee made visible to the optimizer

template<typename T >
const T *	aligned_data (const pod_vector< T > &v) noexcept

uint64_t	now_ns ()

constexpr bool	string_starts_with (std::string_view src, std::string_view prefix) noexcept

template<std::size_t N>
constexpr std::string_view	make_string_view (const char(&str)[N]) noexcept

template<typename... Args>
constexpr std::array< std::string_view, sizeof...(Args)>	make_string_array (Args &&... args) noexcept

void	set_thread_realtime (std::thread &t, int prio, bool algo_fifo)

void	set_thread_name (std::thread &t, std::string_view name)

void	set_thread_name (std::string_view name)

void	set_thread_pinned (int cpu)

int	get_pid ()

std::string	get_exe_path ()

std::string	get_exe_folder ()

std::string	get_module_path ()

thread_type	get_current_thread_type ()

void	ensure_current_thread (thread_type kind)

void	ensure_current_thread_kind (thread_type kind)

void	set_thread_pinned (thread_type spec, int thread_index)

const thread_specs &	get_thread_specs () noexcept

template<class T , class = std::enable_if_t< std::is_class<T>::value && std::is_standard_layout<T>::value>>
auto	to_tuple (T &&object) noexcept

template<typename Functor >
auto	apply (Functor &&functor, const behavior &var) -> decltype(auto)

template<typename Functor >
auto	apply (Functor &&functor, behavior &var) -> decltype(auto)

template<typename Functor >
auto	apply (Functor &&functor, behavior &&var) -> decltype(auto)

template<typename Functor >
auto	apply_nonnull (Functor &&functor, const behavior &var) -> decltype(auto)

template<typename Functor >
auto	apply_nonnull (Functor &&functor, behavior &var) -> decltype(auto)

template<typename Functor >
auto	apply_nonnull (Functor &&functor, behavior &&var) -> decltype(auto)

template<typename Easing , typename Y >
constexpr auto	make_easing (Y start, Y end) noexcept

template<typename Y >
constexpr void	make_easing (auto &res, std::string_view easing, Y start, Y end) noexcept

template<typename Y >
constexpr void	make_easing (auto &res, std::string_view easing) noexcept

void	process_offset (time_sync &timesync, ossia::time_value offset, past_events_map &pastEvents, ossia::flat_set< ossia::time_event * > &seen_events)

int	is_timesync_ready (time_sync &sync, small_event_vec &pendingEvents, bool &maximalDurationReached)

void	remove_vertex (typename scenario_graph_t::vertex_descriptor v, scenario_graph_t &g)

constexpr auto	operator& (ossia::time_event::status lhs, ossia::time_event::status rhs) noexcept

std::optional< ossia::time_signature >	get_time_signature (const std::string_view &v)

constexpr time_value	operator""_tv (long double v) noexcept

constexpr time_value	operator""_tv (unsigned long long v) noexcept

constexpr time_value	abs (time_value t) noexcept

constexpr time_value	norm (time_value t1, time_value t2) noexcept

constexpr int64_t	to_sample (ossia::time_value t, double rate) noexcept

bool	same_vec_type (const ossia::value &lhs, const ossia::value &rhs)

ossia::state_element &	get_state_element (ossia::flat_set_state::iterator iterator)

bool	operator== (const state &lhs, const state &rhs)

bool	operator!= (const state &lhs, const state &rhs)

void	flatten_and_filter (state &, const state_element &element)
	append each message of the state to the current state in order to eliminate address redundancy

void	flatten_and_filter (ossia::state &state, state_element &&element)

void	merge_flatten_and_filter (state &, const state_element &element)
	These will also merge single addresses.

void	merge_flatten_and_filter (ossia::state &state, state_element &&element)

auto	begin (state &s)

auto	begin (const state &s)

auto	end (state &s)

auto	end (const state &s)

ossia::state_element &	get_state_element (ossia::state_element *iterator)

void	launch (state_element &e)
	launch Launch a state_element

std::ostream &	print (std::ostream &os, const state_element &dt)
	print Print a state_element

ossia::state_element &	get_state_element (std::vector< ossia::state_element >::iterator iterator)

template<typename T >
OSSIA_INLINE T	lowpass_alpha (T cutoff, T dt) noexcept
	Smoothing factor of a first-order low-pass, for a sample spaced `dt` seconds from the previous one.

template<typename T >
OSSIA_INLINE T	lag_alpha (T tau, T dt) noexcept
	Smoothing factor of a first-order lag with a given time constant.

template<typename T >
OSSIA_INLINE T	unwrap_angle (T a, T reference) noexcept
	Move `a` onto the branch closest to `reference`.

OSSIA_INLINE bool	safe_isnan (double val) noexcept

OSSIA_INLINE bool	safe_isfinite (double val) noexcept

OSSIA_INLINE bool	safe_isinf (double val) noexcept

void	greedy_assignment (std::vector< match_candidate > &candidates, std::int32_t track_match, std::size_t n_tracks, char det_used, std::size_t n_dets) noexcept
	Greedy bipartite matching: repeatedly take the cheapest remaining candidate whose track and detection are both still free.

template<typename Functor >
auto	apply (Functor &&functor, const value_variant_type &arg0, const behavior_variant_type &arg1)

ossia::val_type	underlying_type (const complex_type &t)

net::parameter_base *	setup_parameter (const complex_type &t, ossia::net::node_base &node)
	Creates a parameter in a node according to a complex type.

const ossia::net::parameter_data *	default_parameter_for_type (std::string_view type)

net::parameter_base *	try_setup_parameter (std::string_view t, ossia::net::node_base &node)
	Creates a parameter in a node according to heuristics.

net::parameter_base *	create_parameter (net::node_base &parent, std::string_view node, std::string_view str)

void	update_parameter_type (const complex_type &t, ossia::net::parameter_base &node)
	Change the type of a parameter according to a complex type.

ossia::value	convert (const ossia::value &v, const ossia::complex_type &source_t, const ossia::complex_type &dest_t)

extended_type	generic_buffer_type ()

extended_type	filesystem_path_type ()

extended_type	url_type ()

extended_type	float_array_type ()

extended_type	float_list_type ()
	Means that the array should be interpreted as a dynamic float list.

extended_type	integer_list_type ()
	Means that the array should be interpreted as a dynamic int list.

extended_type	string_list_type ()
	Means that the array should be interpreted as a dynamic string list.

extended_type	u8_blob_type ()

extended_type	list_type ()
	Means that the array is a dynamic array (e.g. ossia::val_type::LIST)

extended_type	nil_type ()
	Means that the value is an impulse with OSC type-tag NIL.

extended_type	empty_type ()
	Means that the value is an impulse with no OSC type-tag (,\0\0\0)

std::vector< ossia::val_type >	underlying_type (const extended_type &)
	Returns the possible implementation types for this high-level type.

template<typename Value_T >
ossia::value	bound_value (const ossia::domain &dom, Value_T &&base_val, ossia::bounding_mode mode)

template<typename Addr_T >
ossia::value	bound_value (const Addr_T &addr, const ossia::value &v)

template<typename Addr_T >
ossia::value	bound_value (const Addr_T &addr, ossia::value &&v)

template<typename T >
void	scale (T &value, double src_min, double src_max, double dst_min, double dst_max)

template<typename T , typename U >
auto	constrain (T &value, const std::vector< U > &acceptable)

void	map_value (value &source, const ossia::destination_index &idx, const domain &source_domain, const domain &target_domain)

template<typename T , typename U >
std::enable_if_t< is_unit< T >::value &&is_unit< U >::value, bool >	operator== (T, U)

template<typename T , typename U >
std::enable_if_t< is_unit< T >::value &&is_unit< U >::value, bool >	operator!= (T, U)

template<typename T >
std::enable_if_t< is_unit< T >::value, bool >	operator== (T, T)

template<typename T >
std::enable_if_t< is_unit< T >::value, bool >	operator!= (T, T)

OSSIA_EXPORT const unit_parse_symbols_t &	get_unit_parser ()

template<typename Functor >
auto	apply (Functor &&functor, const strong_value_variant &arg0, const unit_variant &arg1)

template<typename Functor >
auto	apply (Functor &&functor, const value_variant_type &arg0, const angle_u &arg1)

template<typename Functor >
auto	apply (Functor &&functor, const value_variant_type &arg0, const color_u &arg1)

template<typename Functor >
auto	apply (Functor &&functor, const value_variant_type &arg0, const distance_u &arg1)

template<typename Functor >
auto	apply (Functor &&functor, const value_variant_type &arg0, const gain_u &arg1)

template<typename Functor >
auto	apply (Functor &&functor, const value_variant_type &arg0, const orientation_u &arg1)

template<typename Functor >
auto	apply (Functor &&functor, const value_variant_type &arg0, const position_u &arg1)

template<typename Functor >
auto	apply (Functor &&functor, const value_variant_type &arg0, const speed_u &arg1)

template<typename Functor >
auto	apply (Functor &&functor, const value_variant_type &arg0, const timing_u &arg1)

template<typename Functor >
auto	apply (Functor &&functor, const angle &arg0, const angle_u &arg1)

template<typename Functor >
auto	apply (Functor &&functor, const color &arg0, const color_u &arg1)

template<typename Functor >
auto	apply (Functor &&functor, const distance &arg0, const distance_u &arg1)

template<typename Functor >
auto	apply (Functor &&functor, const gain &arg0, const gain_u &arg1)

template<typename Functor >
auto	apply (Functor &&functor, const orientation &arg0, const orientation_u &arg1)

template<typename Functor >
auto	apply (Functor &&functor, const position &arg0, const position_u &arg1)

template<typename Functor >
auto	apply (Functor &&functor, const speed &arg0, const speed_u &arg1)

template<typename Functor >
auto	apply (Functor &&functor, const timing &arg0, const timing_u &arg1)

template<typename Functor >
auto	apply (Functor &&functor, const angle &arg0, const value_variant_type &arg1)

template<typename Functor >
auto	apply (Functor &&functor, const color &arg0, const value_variant_type &arg1)

template<typename Functor >
auto	apply (Functor &&functor, const distance &arg0, const value_variant_type &arg1)

template<typename Functor >
auto	apply (Functor &&functor, const gain &arg0, const value_variant_type &arg1)

template<typename Functor >
auto	apply (Functor &&functor, const orientation &arg0, const value_variant_type &arg1)

template<typename Functor >
auto	apply (Functor &&functor, const position &arg0, const value_variant_type &arg1)

template<typename Functor >
auto	apply (Functor &&functor, const speed &arg0, const value_variant_type &arg1)

template<typename Functor >
auto	apply (Functor &&functor, const timing &arg0, const value_variant_type &arg1)

bool	check_units_convertible (const ossia::unit_t &lhs, const ossia::unit_t &rhs)
	Checks ///.

std::string_view	get_dataspace_text (const unit_t &u)
	Parse ///.

std::string_view	get_unit_text (const ossia::unit_t &)
	get_unit_text

std::string_view	get_unit_accessors (const ossia::unit_t &)
	get_unit_accessors

std::string_view	get_pretty_unit_text (const ossia::unit_t &)
	get_pretty_unit_text Unit for human readability and debugging

unit_t	parse_unit (std::string_view text, const ossia::unit_t &dataspace)
	parse_unit Takes a text and a dataspace and gives a corresponding unit.

template<typename T >
ossia::unit_t	parse_unit (std::string_view text, T dataspace)
	parse_unit Alternative if we already have a dataspace type at hand.

unit_t	parse_pretty_unit (std::string_view text)
	parse_pretty_unit Create a unit from a valid unit in the format of get_pretty_unit_text

unit_t	parse_dataspace (std::string_view text)
	parse_dataspace

ossia::domain	get_unit_default_domain (const ossia::unit_t &unit)

char	get_unit_accessor (const ossia::unit_t &, uint8_t n)
	get_unit_accessor Return the character corresponding to the accessor

value_with_unit	make_value (const ossia::value &v, const ossia::unit_t &u)
	Convert ///.

unit_t	make_unit (uint64_t dataspace, uint64_t unit)
	get_unit Create an unit from indexes in the variant

val_type	matching_type (const ossia::unit_t &u)
	underlying_type Get the implementation type of an unit

value_with_unit	convert (const ossia::value_with_unit &v, const ossia::unit_t &t)
	convert Convert a value to another unit in the same dataspace

value	to_value (const ossia::value_with_unit &v)
	convert Convert a value + unit to a simple value

unit_t	to_unit (const ossia::value_with_unit &v)
	to_unit Get the unit part of a value_with_unit

std::string	to_pretty_string (const ossia::value_with_unit &v)
	to_pretty_string Pretty string of unit & value

ossia::value_with_unit	merge (const ossia::value_with_unit &, const ossia::value &, ossia::destination_index)
	merge Merge a computed value in a unit-aware value

ossia::value_with_unit	merge (const value_with_unit &vu, const ossia::vec2f &val, std::bitset< 2 > idx)

ossia::value_with_unit	merge (const value_with_unit &vu, const ossia::vec3f &val, std::bitset< 3 > idx)

ossia::value_with_unit	merge (const value_with_unit &vu, const ossia::vec4f &val, std::bitset< 4 > idx)

ossia::value	convert (const ossia::value &v, const ossia::unit_t &source_unit, const ossia::unit_t &destination_unit)
	convert Convert a value to another unit.

template OSSIA_EXPORT ossia::unit_t	parse_unit (std::string_view, ossia::color_u)

template OSSIA_EXPORT ossia::unit_t	parse_unit (std::string_view, ossia::distance_u)

template OSSIA_EXPORT ossia::unit_t	parse_unit (std::string_view, ossia::position_u)

template OSSIA_EXPORT ossia::unit_t	parse_unit (std::string_view, ossia::speed_u)

template OSSIA_EXPORT ossia::unit_t	parse_unit (std::string_view, ossia::orientation_u)

template OSSIA_EXPORT ossia::unit_t	parse_unit (std::string_view, ossia::angle_u)

template OSSIA_EXPORT ossia::unit_t	parse_unit (std::string_view, ossia::gain_u)

template OSSIA_EXPORT ossia::unit_t	parse_unit (std::string_view, ossia::timing_u)

template<typename T >
OSSIA_EXPORT ossia::unit_t	parse_unit (std::string_view text, T dataspace)
	parse_unit Alternative if we already have a dataspace type at hand.

ossia::val_type	matching_type (ossia::unit_t &&u)

template<typename T >
T	convert (float f)

ossia::value	clamp (const ossia::value &val, const ossia::value &min, const ossia::value &max)

ossia::value	clamp (ossia::value &&val, const ossia::value &min, const ossia::value &max)

ossia::value	clamp_max (const ossia::value &val, const ossia::value &max)

ossia::value	clamp_max (ossia::value &&val, const ossia::value &max)

ossia::value	clamp_min (const ossia::value &val, const ossia::value &min)

ossia::value	clamp_min (ossia::value &&val, const ossia::value &min)

template<typename T >
auto &	move (const T &t)

value	get_min (const domain &dom)

value	get_max (const domain &dom)

std::pair< std::optional< float >, std::optional< float > >	get_float_minmax (const domain &dom)

void	set_min (domain &dom, const ossia::value &val)

void	set_max (domain &dom, const ossia::value &val)

void	set_values (domain &dom, const std::vector< ossia::value > &val)

std::vector< ossia::value >	get_values (const domain &dom)

domain	make_domain (const ossia::value &min, const ossia::value &max)

domain	make_domain (std::vector< std::string > s)

domain	make_domain (std::span< const char * > span)

domain	make_domain (const std::vector< ossia::value > &vals)

domain	make_domain (const ossia::value &min, const ossia::value &max, const std::vector< ossia::value > &vals)

domain	make_domain_from_osc (const ossia::small_vector< ossia::value, 2 > &val, const ossia::value &cur)

ossia::domain	make_domain_from_minmax (const std::vector< ossia::value > &min, const std::vector< ossia::value > &max, ossia::val_type v)

value	apply_domain (const domain &dom, bounding_mode b, const ossia::value &val)

value	apply_domain (const domain &dom, bounding_mode b, ossia::value &&val)

domain	init_domain (ossia::val_type type)

template<typename Functor >
auto	apply (Functor &&functor, const domain &var) -> decltype(auto)

template<typename Functor >
auto	apply (Functor &&functor, domain &var) -> decltype(auto)

template<typename Functor >
auto	apply (Functor &&functor, domain &&var) -> decltype(auto)

template<typename Functor >
auto	apply_nonnull (Functor &&functor, const domain &var) -> decltype(auto)

template<typename Functor >
auto	apply_nonnull (Functor &&functor, domain &var) -> decltype(auto)

template<typename Functor >
auto	apply_nonnull (Functor &&functor, domain &&var) -> decltype(auto)

OSSIA_EXPORT ossia::value	wrap (const ossia::value &val, const ossia::value &min, const ossia::value &max)

OSSIA_EXPORT ossia::value	fold (const ossia::value &val, const ossia::value &min, const ossia::value &max)

OSSIA_EXPORT ossia::value	wrap (ossia::value &&val, const ossia::value &min, const ossia::value &max)

OSSIA_EXPORT ossia::value	fold (ossia::value &&val, const ossia::value &min, const ossia::value &max)

domain	convert_domain (const domain &dom, ossia::val_type newtype)

void	convert_compatible_domain (domain &dom, ossia::val_type newtype)

template<typename T >
bool	operator!= (const domain_base< T > &lhs, const domain_base< T > &rhs)

splitted_host_and_port	url_to_host_and_port (std::string_view url)

template<typename Proto >
std::optional< resolved_url >	resolve_sync_v4 (const std::string_view host, const std::string_view port)

template OSSIA_EXPORT std::optional< resolved_url >	resolve_sync_v4< boost::asio::ip::tcp > (const std::string_view host, const std::string_view port)

template OSSIA_EXPORT std::optional< resolved_url >	resolve_sync_v4< boost::asio::ip::udp > (const std::string_view host, const std::string_view port)

template<typename Proto >
OSSIA_EXPORT std::optional< resolved_url >	resolve_sync_v4 (const std::string_view host, const std::string_view port)

void	resolve_host_in_transport (auto &conf)

OSSIA_EXPORT bool	operator== (const destination &, const destination &) noexcept

OSSIA_EXPORT bool	operator!= (const destination &, const destination &) noexcept

OSSIA_EXPORT bool	operator== (const destination &, const ossia::net::parameter_base &) noexcept

OSSIA_EXPORT bool	operator!= (const destination &, const ossia::net::parameter_base &) noexcept

OSSIA_EXPORT std::string	to_pretty_string (const destination &d) noexcept

template<typename T >
T	convert (const ossia::value &val)
	convert Convert a value to the given type.

template<typename T >
void	convert_inplace (ossia::value &val)

template<typename T >
T	convert (const T &cur, const ossia::value &val)

template<typename T >
T	convert (const std::vector< ossia::value > &val)
	convert Convert lists to array<float, 2/3/4>

template<typename Fun , typename... Args>
auto	lift (ossia::val_type type, Fun f, Args &&... args)

template<typename Fun , typename... Args>
auto	lift_inplace (ossia::val_type type, Fun f, Args &&... args)

template<typename T >
constexpr bool	operator== (const T &, const ossia::impulse &)

template<typename T >
constexpr bool	operator!= (const T &, const ossia::impulse &)

template<typename T >
constexpr bool	operator> (const T &, const ossia::impulse &)

template<typename T >
constexpr bool	operator>= (const T &, const ossia::impulse &)

template<typename T >
constexpr bool	operator< (const T &, const ossia::impulse &)

template<typename T >
constexpr bool	operator<= (const T &, const ossia::impulse &)

template<typename T >
constexpr bool	operator== (const ossia::impulse &, const T &)

template<typename T >
constexpr bool	operator!= (const ossia::impulse &, const T &)

template<typename T >
constexpr bool	operator> (const ossia::impulse &, const T &)

template<typename T >
constexpr bool	operator>= (const ossia::impulse &, const T &)

template<typename T >
constexpr bool	operator< (const ossia::impulse &, const T &)

template<typename T >
constexpr bool	operator<= (const ossia::impulse &, const T &)

template OSSIA_EXPORT impulse	convert< ossia::impulse > (const ossia::value &val)

template OSSIA_EXPORT int32_t	convert< int32_t > (const ossia::value &val)

template OSSIA_EXPORT float	convert< float > (const ossia::value &val)

template OSSIA_EXPORT double	convert< double > (const ossia::value &val)

template OSSIA_EXPORT bool	convert< bool > (const ossia::value &val)

template OSSIA_EXPORT value_map_type	convert< value_map_type > (const ossia::value &val)

template OSSIA_EXPORT std::string	convert< std::string > (const ossia::value &val)

template OSSIA_EXPORT std::vector< ossia::value >	convert< std::vector< ossia::value > > (const ossia::value &val)

template OSSIA_EXPORT std::array< float, 2 >	convert< std::array< float, 2 > > (const ossia::value &val)

template OSSIA_EXPORT std::array< float, 3 >	convert< std::array< float, 3 > > (const ossia::value &val)

template OSSIA_EXPORT std::array< float, 4 >	convert< std::array< float, 4 > > (const ossia::value &val)

template OSSIA_EXPORT impulse	convert< ossia::impulse > (const ossia::impulse &, const ossia::value &val)

template OSSIA_EXPORT int32_t	convert< int32_t > (const int32_t &, const ossia::value &val)

template OSSIA_EXPORT float	convert< float > (const float &, const ossia::value &val)

template OSSIA_EXPORT double	convert< double > (const double &, const ossia::value &val)

template OSSIA_EXPORT bool	convert< bool > (const bool &, const ossia::value &val)

template OSSIA_EXPORT value_map_type	convert< value_map_type > (const value_map_type &, const ossia::value &val)

template OSSIA_EXPORT std::string	convert< std::string > (const std::string &, const ossia::value &val)

template OSSIA_EXPORT std::vector< ossia::value >	convert< std::vector< ossia::value > > (const std::vector< ossia::value > &, const ossia::value &val)

template OSSIA_EXPORT std::array< float, 2 >	convert< std::array< float, 2 > > (const std::array< float, 2 > &, const ossia::value &val)

template OSSIA_EXPORT std::array< float, 3 >	convert< std::array< float, 3 > > (const std::array< float, 3 > &, const ossia::value &val)

template OSSIA_EXPORT std::array< float, 4 >	convert< std::array< float, 4 > > (const std::array< float, 4 > &, const ossia::value &val)

template OSSIA_EXPORT std::array< float, 2 >	convert< std::array< float, 2 > > (const std::vector< ossia::value > &val)

template OSSIA_EXPORT std::array< float, 3 >	convert< std::array< float, 3 > > (const std::vector< ossia::value > &val)

template OSSIA_EXPORT std::array< float, 4 >	convert< std::array< float, 4 > > (const std::vector< ossia::value > &val)

std::string	to_pretty_string (const destination_index &index)

bool	operator== (const value &lhs, const value &rhs)

bool	operator!= (const value &lhs, const value &rhs)

bool	operator> (const value &lhs, const value &rhs)

bool	operator>= (const value &lhs, const value &rhs)

bool	operator< (const value &lhs, const value &rhs)

bool	operator<= (const value &lhs, const value &rhs)

ossia::value	get_value_at_index (const ossia::value &val, const ossia::destination_index &idx)
	get_value_at_index

bool	is_numeric (const ossia::value &v)
	is_numeric True if the value is of a numeric type (int, bool, float, char...)

bool	is_array (const ossia::value &v)
	is_numeric True if the value is of an array type (list, vec...)

ossia::value	convert (const ossia::value &val, const ossia::value &cur)

ossia::value	convert (const ossia::value &val, ossia::val_type newtype)

void	convert_inplace (ossia::value &val, ossia::val_type newtype)

void	convert_inplace (ossia::value &val, const ossia::value &cur)

OSSIA_EXPORT std::string	value_to_pretty_string (const ossia::value &val)
	getValueAsString Returns a string corresponding to the value

OSSIA_EXPORT ossia::value	parse_pretty_value (std::string_view str)

ossia::value	init_value (ossia::val_type type)

template<typename T >
OSSIA_EXPORT T	convert (const ossia::value &val)
	convert Convert a value to the given type.

template<typename T >
OSSIA_EXPORT T	convert (const T &cur, const ossia::value &val)

template<typename T >
OSSIA_EXPORT T	convert (const std::vector< ossia::value > &val)
	convert Convert lists to array<float, 2/3/4>

template<typename T , typename U >
vec2f	make_vec (T f1, U f2)

template<typename T , typename U , typename V >
vec3f	make_vec (T f1, U f2, V f3)

template<typename T , typename U , typename V , typename W >
vec4f	make_vec (T f1, U f2, V f3, W f4)

template<std::size_t N>
std::array< float, N >	fill_vec (float f)

template<typename Impl , typename Parent >
auto	make_parameter (Parent &parent)

template<typename T , typename... Args>
auto	make (PhidgetHandle phid, ossia::net::device_base &dev, ossia::net::node_base &par_node)

bool	operator== (phidget_id lhs, phidget_id rhs)

Variables
const constexpr auto	pi = 3.141592653589793238462643383279502884

const constexpr auto	two_pi = 6.283185307179586476925286766559005768

const constexpr auto	half_pi = 1.570796326794896619231321691639751442

const constexpr auto	rad_to_deg = 5.729577951308232087679815481410517033e+01

const constexpr auto	deg_to_rad = 1.745329251994329576923690768488612713e-02

const constexpr auto	ln_2 = 6.931471805599453094172321214581765680e-01

const constexpr auto	sqrt_2 = 1.414213562373095048801688724209698078e+00

constexpr std::size_t	pod_vector_alignment = 32
	Alignment guaranteed by pod_allocator_avx2, and thus by ossia::pod_vector.

boost::unordered::concurrent_flat_map< std::thread::id, thread_type, std::hash< std::thread::id > >	g_thread_types

const constexpr time_value	Infinite {time_value::infinity}

const constexpr time_value	Zero {0}

const constexpr time_value	One {1}

Typedef Documentation

◆ destination_index

using ossia::destination_index = typedef ossia::small_vector<int32_t, 2>

Identifies an element in a nested list. For instance :

List_A{
 List_B{1, 2, 3},
 List_C{
   List_D{4},
   List_E{5}
 }
}
 
destination_index{}        => List_A
destination_index{0}       => List_B
destination_index{0, 1}    => '1'
destination_index{0, 2}    => '2'
destination_index{0, 3}    => '3'
destination_index{1}       => List_C
destination_index{1, 0}    => List_D
destination_index{1, 0, 0} => '4'
destination_index{1, 1}    => List_E
destination_index{1, 1, 0} => '5'

◆ expression

ossia::expression

An expression is a formula that checks truth values according to values in a network tree.

For instance :

(a:/b == 50) && !(c:/d < e:/f)

Expressions are built with factories found in expression.hpp :

make_expression_true : a constant "true" node.
make_expression_false : a constant "false" node.
make_expression_atom : a relational comparison node (==, <=, !=, etc...) between two ossia::value.
make_expression_pulse : a node that becomes true if a message is received opn a given address since the last time update() has been called on it.
make_expression_not : standard logical not operator.
make_expression_composition : standard logical and, or, xor, operators between two expressions..

See also: expression_atom; expression_bool; expression_composition; expression_not; expression_pulse

◆ state_element

ossia::state_element

A variant of elements that are meant to be triggered during execution of a score.

See also: message; state; state_element.hpp

Enumeration Type Documentation

◆ curve_segment_type

enum class ossia::curve_segment_type

strong

The curve_segment_type enum.

Represents the result type of either the X or Y parameter of a curve.

◆ track_state

enum class ossia::track_state : std::uint8_t

strong

Enumerator
provisional	Seen, but not yet confirmed: usable for triggers, flagged.
confirmed	Passed M-of-N + time confirmation: the stable set.
coasting	Missed recently; position is the Kalman prediction.
revived	Re-acquired after being lost (transient, one frame).
lost	Past the coast window; kept for revival, not emitted.
expired	Terminal; the track is removed right after this is set.

◆ track_motion_gate

enum class ossia::track_motion_gate : std::uint8_t

strong

Enumerator
off	No motion gate: nearest-neighbour within the cost ranking.
max_speed	Analytic: displacement <= max_speed * dt * (1 + lost/coast).
mahalanobis	Kalman gating distance against a chi-square threshold.

◆ track_slot_allocation

enum class ossia::track_slot_allocation : std::uint8_t

strong

Enumerator
lowest_free	Lowest free slot index (cv.jit-style, deterministic).
round_robin	Cycle through the slots, spreading reuse over time.
nearest_vacated	Prefer a recently-vacated slot near the track's position.

◆ track_slot_steal

enum class ossia::track_slot_steal : std::uint8_t

strong

Enumerator
never	A confirmed track without a free slot stays unslotted.
stalest	Steal from the track unseen for the longest time.
lowest_confidence	Steal from the track with the lowest confidence.

◆ val_type

enum class ossia::val_type : int8_t

strong

Enum to represent the types that a value can take.

Note

If changing this, also take care of changing :

val_type in qml_context
ossia_type in ossia-c.h
ossia::val_type

Enumerator
INT	float
VEC2F	int32_t
VEC3F	array<float, 2>
VEC4F	array<float, 3>
IMPULSE	array<float, 4>
BOOL	ossia::impulse
STRING	bool
LIST	std::string
MAP	std::vector<value>
NONE	map<string, value>

◆ access_mode

enum class ossia::access_mode : int8_t

strong

Address behaviors at crossing domain boundaries time.

Enumerator

GET

The value can be retrieved and changed.

SET

The value can be retrieved.

The value can be changed

◆ bounding_mode

enum class ossia::bounding_mode : int8_t

strong

Address behaviors at crossing domain boundaries.

Enumerator
CLIP	The bounds are ignored.
WRAP	See also ossia::clamp
FOLD	See also ossia::wrap
CLAMP_LOW	See also ossia::fold
CLAMP_HIGH	See also ossia::clamp_min

Function Documentation

◆ logger()

OSSIA_EXPORT logger_type & ossia::logger ( )

noexcept

Where the errors will be logged. Default is stderr.

It is also accessible through spdlog::get("ossia");

The logger is first created in ossia::context construction.

◆ float_to_sample()

template<typename SampleFormat , int N>

constexpr SampleFormat ossia::float_to_sample ( ossia::audio_sample sample )

constexprnoexcept

Generic versions found on KVR static inline int quantize(double x, int w) { const double range = exp2((double) w);

return (int) clamp(floor(x * range * 0.5), - range * 0.5, range * 0.5 - 1.0); }

static inline double dequantize(int n, int w) { const double range = exp2((double) w);

return ((2.0 * (double) n + range) / (range - 1.0)) - 1.0; }

◆ get_attribute()

template<typename T >

auto ossia::get_attribute	(	const any_map &	e,
		std::string_view	name
	)

get_attribute Get an attribute of an any_map.

Example :

auto desc = get_attribute<description>(e, "description");

The value will be default-constructed if it is not found (e.g. empty string, 0...)

◆ get_optional_attribute()

template<typename T >

std::optional< T > ossia::get_optional_attribute	(	const any_map &	e,
		std::string_view	name
	)

get_optional_attribute Maybe get an attribute of an any_map.

Example :

auto desc = get_optional_attribute<description>(e, "description");
if(desc)
  std::cerr << "The description is: " << *desc << "\n";

The value will be an empty std::optional if it is not found.

◆ assume_aligned()

template<std::size_t Align = pod_vector_alignment, typename T >

T * ossia::assume_aligned ( T * p )

inlinenoexcept

Tell the optimizer that p is aligned on Align bytes.

Undefined behaviour if it is not: only use on memory that came out of aligned_pod_allocator, that is, anything stored in an ossia::pod_vector. The compiler cannot infer this by itself as the alignment does not survive the round-trip through the container member pointer.

◆ flatten_and_filter()

OSSIA_EXPORT void ossia::flatten_and_filter	(	state &	,
		const state_element &	element
	)

append each message of the state to the current state in order to eliminate address redundancy

Parameters

std::shared_ptr<State>	the State to fill
std::shared_ptr<StateElement>	the StateElement to store

◆ lowpass_alpha()

template<typename T >

OSSIA_INLINE T ossia::lowpass_alpha	(	T	cutoff,
		T	dt
	)

noexcept

Smoothing factor of a first-order low-pass, for a sample spaced dt seconds from the previous one.

Parameters

cutoff	Cutoff frequency, in Hz. Must be > 0.
dt	Time since the previous sample, in seconds. Must be > 0.

Returns: alpha in ]0, 1[ ; 1 would be passthrough, 0 a frozen output.

◆ lag_alpha()

template<typename T >

OSSIA_INLINE T ossia::lag_alpha	(	T	tau,
		T	dt
	)

noexcept

Smoothing factor of a first-order lag with a given time constant.

Equivalent to lowpass_alpha(1 / (2 * pi * tau), dt), spelled in the unit that is usually more natural when a UI exposes a "smoothing time" instead of a cutoff.

Parameters

tau	Time constant, in seconds. Must be > 0.
dt	Time since the previous sample, in seconds. Must be > 0.

◆ unwrap_angle()

template<typename T >

OSSIA_INLINE T ossia::unwrap_angle	(	T	a,
		T	reference
	)

noexcept

Move a onto the branch closest to reference.

Angles wrap, so a naive filter run over them lurches by a full turn every time the signal crosses the discontinuity. Unwrapping against the previous value first makes them safe to smooth.

Branchless, unlike the usual while-loop form.

◆ greedy_assignment()

void ossia::greedy_assignment	(	std::vector< match_candidate > &	candidates,
		std::int32_t *	track_match,
		std::size_t	n_tracks,
		char *	det_used,
		std::size_t	n_dets
	)

inlinenoexcept

Greedy bipartite matching: repeatedly take the cheapest remaining candidate whose track and detection are both still free.

The candidate list is sorted in place (stable, so ties keep insertion order and results are deterministic). Not optimal like Hungarian, but within a fraction of it for tracking workloads (ByteTrack itself ships greedy variants) and O(K log K) with no allocation beyond the caller's buffers.

Parameters

candidates	Gated candidate pairs; entries with an already-matched track/detection are skipped.
track_match	Per-track matched detection index, -1 if unmatched. Pre-filled entries (>= 0) are treated as taken.
n_tracks	Size of `track_match`.
det_used	Per-detection taken flag.
n_dets	Size of `det_used`.

◆ underlying_type()

OSSIA_EXPORT ossia::val_type ossia::underlying_type ( const complex_type & t )

Get the implementation type of a high level type. If unknown will be ossia::impulse.

◆ generic_buffer_type()

OSSIA_EXPORT extended_type ossia::generic_buffer_type ( )

Represents a "raw" data buffer, that should not be interpreted as a readable string. Only meaningful for strings.

◆ filesystem_path_type()

OSSIA_EXPORT extended_type ossia::filesystem_path_type ( )

Represents a filesystem path : "c:\\windows\\virus.exe", "../../share/pony.png", etc. Only meaningful for strings.

◆ url_type()

OSSIA_EXPORT extended_type ossia::url_type ( )

Represents an URL or URI : "http://foo.com/whatever", "120.10.10.15:123/foo", "mailto:john.smith@ossia.io"

◆ float_array_type()

OSSIA_EXPORT extended_type ossia::float_array_type ( )

Means that the array should be interpreted as a fixed float array (e.g. vec2f, etc)

◆ u8_blob_type()

OSSIA_EXPORT extended_type ossia::u8_blob_type ( )

Means that the blob should be a u8 blob, e.g. each value of the array is a u8 value in an OSC blob

◆ check_units_convertible()

OSSIA_EXPORT bool ossia::check_units_convertible	(	const ossia::unit_t &	,
		const ossia::unit_t &
	)

Checks ///.

Check if two units are convertible into each other.

i.e. if they are in the same dataspace

◆ get_dataspace_text()

OSSIA_EXPORT std::string_view ossia::get_dataspace_text ( const ossia::unit_t & )

Parse ///.

get_dataspace_text

Returns: Text corresponding to the dataspace. For instance "color" or "gain".

◆ get_unit_text()

OSSIA_EXPORT std::string_view ossia::get_unit_text ( const ossia::unit_t & )

get_unit_text

Returns: Text corresponding to the unit. For instance "rgb" or "cartesian3D".

◆ get_unit_accessors()

OSSIA_EXPORT std::string_view ossia::get_unit_accessors ( const ossia::unit_t & )

get_unit_accessors

Returns: If the unit has an array-like type (e.g. RGB color, XY point), this returns a string of array attributes. Else an empty string.

◆ get_pretty_unit_text()

OSSIA_EXPORT std::string_view ossia::get_pretty_unit_text ( const ossia::unit_t & )

get_pretty_unit_text Unit for human readability and debugging

Format is dataspace.unit, e.g. distance.m/s or color.rgb

◆ parse_unit() [1/3]

OSSIA_EXPORT ossia::unit_t ossia::parse_unit	(	std::string_view	text,
		const ossia::unit_t &	dataspace
	)

parse_unit Takes a text and a dataspace and gives a corresponding unit.

Parameters

text	The text to parse
dataspace	A dataspace such as ossia::color_u, ossia::distance_u...

Returns: Corresponding unit, or the same unit as input if it was not found.

◆ parse_unit() [2/3]

template<typename T >

ossia::unit_t ossia::parse_unit	(	std::string_view	text,
		T	dataspace
	)

parse_unit Alternative if we already have a dataspace type at hand.

Note: T should be a dataspace, such as ossia::color_u.

Todo:: In 2020 enforce this with concepts...

◆ parse_dataspace()

OSSIA_EXPORT ossia::unit_t ossia::parse_dataspace ( std::string_view text )

parse_dataspace

Parameters

text	Something like color, etc.

Returns: A value corresponding to the dataspace, without any specific unit.

◆ get_unit_accessor()

OSSIA_EXPORT char ossia::get_unit_accessor	(	const ossia::unit_t &	,
		uint8_t	n
	)

get_unit_accessor Return the character corresponding to the accessor

e.g. for unit == rgb, n == 1, the function returns 'g'.

Note: Will return 0 (as in "(char)0") if anything is invalid.

◆ make_value()

OSSIA_EXPORT value_with_unit ossia::make_value	(	const ossia::value &	v,
		const ossia::unit_t &	u
	)

Convert ///.

make_value Create a value_with_unit

Parameters

v	A value
u	A unit

Returns: The same value with the unit attached if the types were correct.

◆ make_unit()

OSSIA_EXPORT ossia::unit_t ossia::make_unit	(	uint64_t	dataspace,
		uint64_t	unit
	)

get_unit Create an unit from indexes in the variant

Parameters

dataspace	Identifier in the first variant
unit	std::optional identifier in the second variant

Ex. : position.opengl_u == (1, 4). This is useful for concise serialization / deserialization.

Returns: A corresponding unit

◆ matching_type()

OSSIA_EXPORT ossia::val_type ossia::matching_type ( const ossia::unit_t & u )

underlying_type Get the implementation type of an unit

Parameters

u An unit

Will return Impulse if the unit is invalid.

Returns: The matching type. For instance vec3f for position.cart3D.

◆ convert() [1/4]

OSSIA_EXPORT ossia::value_with_unit ossia::convert	(	const ossia::value_with_unit &	v,
		const ossia::unit_t &	t
	)

convert Convert a value to another unit in the same dataspace

Parameters

v	A value
t	An unit of the same dataspace than the value.

E.g. you can convert 1cm in millimeters, but not 1cm in RGB colors.

Returns: The converted value if both value and unit are valid and convertible, else the input value

◆ to_value()

OSSIA_EXPORT ossia::value ossia::to_value ( const ossia::value_with_unit & v )

convert Convert a value + unit to a simple value

Parameters

v	Value to convert

Returns: Corresponding ossia::value

◆ to_pretty_string()

OSSIA_EXPORT std::string ossia::to_pretty_string ( const ossia::value_with_unit & v )

to_pretty_string Pretty string of unit & value

Returns: For example "[0.2, 1.6, 3.4] rgb"

◆ merge()

OSSIA_EXPORT ossia::value_with_unit ossia::merge	(	const ossia::value_with_unit &	,
		const ossia::value &	,
		ossia::destination_index
	)

merge Merge a computed value in a unit-aware value

The computed value is assumed to be of the same dataspace. For instance if v is a HSV color, then t can also be an HSV color, or just "h", "s", or "v" component, but not a "r" color.

Parameters

The	value with an unit
The	value to merge
std::optional	destination index or bitset to merge with

Returns

◆ convert() [2/4]

OSSIA_EXPORT ossia::value ossia::convert	(	const ossia::value &	v,
		const ossia::unit_t &	source_unit,
		const ossia::unit_t &	destination_unit
	)

convert Convert a value to another unit.

Parameters

v	A value.
source_unit	The unit of v.
destination_unit	The unit in which v shall be converted.

Dataspaces ought to be similar.

Returns: Converted value, else the input value.

◆ parse_unit() [3/3]

template<typename T >

OSSIA_EXPORT ossia::unit_t ossia::parse_unit	(	std::string_view	text,
		T	dataspace
	)

parse_unit Alternative if we already have a dataspace type at hand.

Note: T should be a dataspace, such as ossia::color_u.

Todo:: In 2020 enforce this with concepts...

◆ convert_compatible_domain()

void ossia::convert_compatible_domain	(	domain &	dom,
		ossia::val_type	newtype
	)

inline

Note: check this if the order in domain_base_variant changes.

◆ convert() [3/4]

template<typename T >

T ossia::convert ( const ossia::value & val )

convert Convert a value to the given type.

Parameters

val A value

Returns: The closest possible conversion of the value to T, else a default-constructed T.

◆ get_value_at_index()

OSSIA_EXPORT ossia::value ossia::get_value_at_index	(	const ossia::value &	val,
		const ossia::destination_index &	idx
	)

get_value_at_index

for ossia::list{{1, 2}, 3} and index {}, return {{1, 2}, 3}. for ossia::list{{1, 2}, 3} and index {0}, return {1, 2}. for ossia::list{{1, 2}, 3} and index {0, 0}, return 1. for ossia::list{{1, 2}, 3} and index {0, 1}, return 2. for ossia::list{{1, 2}, 3} and index {0, 2}, return {}. for ossia::list{{1, 2}, 3} and index {1}, return 3. for ossia::list{{1, 2}, 3} and index {1, 0}, return {}. for ossia::list{{1, 2}, 3} and index {2}, return {}.

See also: destination_index

Returns: The value if it is found, else nothing.

◆ value_to_pretty_string()

OSSIA_EXPORT std::string ossia::value_to_pretty_string ( const ossia::value & val )

getValueAsString Returns a string corresponding to the value

Parameters

val	a valid value

Returns: a string in the format : "type: value".

ex. "int: 3" "string: tutu" "list: [ int: 2, float: 3 ]" etc...

◆ convert() [4/4]

template<typename T >

OSSIA_EXPORT T ossia::convert ( const ossia::value & val )

convert Convert a value to the given type.

Parameters

val A value

Returns: The closest possible conversion of the value to T, else a default-constructed T.

Detailed Description

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ destination_index

◆ expression

◆ state_element

Enumeration Type Documentation

◆ curve_segment_type

◆ track_state

◆ track_motion_gate

◆ track_slot_allocation

◆ track_slot_steal

◆ val_type

◆ access_mode

◆ bounding_mode

Function Documentation

◆ logger()

◆ float_to_sample()

◆ get_attribute()

◆ get_optional_attribute()

◆ assume_aligned()

◆ flatten_and_filter()

◆ lowpass_alpha()

◆ lag_alpha()

◆ unwrap_angle()

◆ greedy_assignment()

◆ underlying_type()

◆ generic_buffer_type()

◆ filesystem_path_type()

◆ url_type()

◆ float_array_type()

◆ u8_blob_type()

◆ check_units_convertible()

◆ get_dataspace_text()

◆ get_unit_text()

◆ get_unit_accessors()

◆ get_pretty_unit_text()

◆ parse_unit() [1/3]

◆ parse_unit() [2/3]

◆ parse_dataspace()

◆ get_unit_accessor()

◆ make_value()

◆ make_unit()

◆ matching_type()

◆ convert() [1/4]

◆ to_value()

◆ to_pretty_string()

◆ merge()

◆ convert() [2/4]

◆ parse_unit() [3/3]

◆ convert_compatible_domain()

◆ convert() [3/4]

◆ get_value_at_index()

◆ value_to_pretty_string()

◆ convert() [4/4]