diff options
Diffstat (limited to 'lilv')
| -rw-r--r-- | lilv/lilv.h | 509 | ||||
| -rw-r--r-- | lilv/lilvmm.hpp | 104 |
2 files changed, 300 insertions, 313 deletions
diff --git a/lilv/lilv.h b/lilv/lilv.h index 41c16d8..ce0729d 100644 --- a/lilv/lilv.h +++ b/lilv/lilv.h @@ -57,19 +57,21 @@ extern "C" { #define LILV_PORT_CLASS_EVENT "http://lv2plug.in/ns/ext/event#EventPort" #define LILV_EVENT_CLASS_MIDI "http://lv2plug.in/ns/ext/midi#MidiEvent" -typedef struct _LilvPlugin* LilvPlugin; /**< LV2 Plugin. */ -typedef struct _LilvPluginClass* LilvPluginClass; /**< Plugin Class. */ -typedef struct _LilvPort* LilvPort; /**< Port. */ -typedef struct _LilvScalePoint* LilvScalePoint; /**< Scale Point (Notch). */ -typedef struct _LilvUI* LilvUI; /**< Plugin UI. */ -typedef struct _LilvValue* LilvValue; /**< Typed Value. */ -typedef struct _LilvWorld* LilvWorld; /**< Lilv World. */ - -typedef void* LilvPluginClasses; /**< set<PluginClass>. */ -typedef void* LilvPlugins; /**< set<Plugin>. */ -typedef void* LilvScalePoints; /**< set<ScalePoint>. */ -typedef void* LilvUIs; /**< set<UI>. */ -typedef void* LilvValues; /**< set<Value>. */ +typedef struct LilvPluginImpl LilvPlugin; /**< LV2 Plugin. */ +typedef struct LilvPluginClassImpl LilvPluginClass; /**< Plugin Class. */ +typedef struct LilvPortImpl LilvPort; /**< Port. */ +typedef struct LilvScalePointImpl LilvScalePoint; /**< Scale Point (Notch). */ +typedef struct LilvUIImpl LilvUI; /**< Plugin UI. */ +typedef struct LilvValueImpl LilvValue; /**< Typed Value. */ +typedef struct LilvWorldImpl LilvWorld; /**< Lilv World. */ +typedef struct LilvInstanceImpl LilvInstance; /**< Plugin instance. */ + +typedef void LilvIter; /**< Collection iterator */ +typedef void LilvPluginClasses; /**< set<PluginClass>. */ +typedef void LilvPlugins; /**< set<Plugin>. */ +typedef void LilvScalePoints; /**< set<ScalePoint>. */ +typedef void LilvUIs; /**< set<UI>. */ +typedef void LilvValues; /**< set<Value>. */ /** @defgroup lilv Lilv @@ -100,61 +102,61 @@ lilv_uri_to_path(const char* uri); Returned value must be freed by caller with lilv_value_free. */ LILV_API -LilvValue -lilv_value_new_uri(LilvWorld world, const char* uri); +LilvValue* +lilv_value_new_uri(LilvWorld* world, const char* uri); /** Create a new string value (with no language). Returned value must be freed by caller with lilv_value_free. */ LILV_API -LilvValue -lilv_value_new_string(LilvWorld world, const char* str); +LilvValue* +lilv_value_new_string(LilvWorld* world, const char* str); /** Create a new integer value. Returned value must be freed by caller with lilv_value_free. */ LILV_API -LilvValue -lilv_value_new_int(LilvWorld world, int val); +LilvValue* +lilv_value_new_int(LilvWorld* world, int val); /** Create a new floating point value. Returned value must be freed by caller with lilv_value_free. */ LILV_API -LilvValue -lilv_value_new_float(LilvWorld world, float val); +LilvValue* +lilv_value_new_float(LilvWorld* world, float val); /** Create a new boolean value. Returned value must be freed by caller with lilv_value_free. */ LILV_API -LilvValue -lilv_value_new_bool(LilvWorld world, bool val); +LilvValue* +lilv_value_new_bool(LilvWorld* world, bool val); /** Free an LilvValue. */ LILV_API void -lilv_value_free(LilvValue val); +lilv_value_free(LilvValue* val); /** Duplicate an LilvValue. */ LILV_API -LilvValue -lilv_value_duplicate(LilvValue val); +LilvValue* +lilv_value_duplicate(const LilvValue* val); /** Return whether two values are equivalent. */ LILV_API bool -lilv_value_equals(LilvValue value, LilvValue other); +lilv_value_equals(const LilvValue* value, const LilvValue* other); /** Return this value as a Turtle/SPARQL token. @@ -171,14 +173,14 @@ lilv_value_equals(LilvValue value, LilvValue other); */ LILV_API char* -lilv_value_get_turtle_token(LilvValue value); +lilv_value_get_turtle_token(const LilvValue* value); /** Return whether the value is a URI (resource). */ LILV_API bool -lilv_value_is_uri(LilvValue value); +lilv_value_is_uri(const LilvValue* value); /** Return this value as a URI string, e.g. "http://example.org/foo". @@ -187,14 +189,14 @@ lilv_value_is_uri(LilvValue value); */ LILV_API const char* -lilv_value_as_uri(LilvValue value); +lilv_value_as_uri(const LilvValue* value); /** Return whether the value is a blank node (resource with no URI). */ LILV_API bool -lilv_value_is_blank(LilvValue value); +lilv_value_is_blank(const LilvValue* value); /** Return this value as a blank node identifier, e.g. "genid03". @@ -203,7 +205,7 @@ lilv_value_is_blank(LilvValue value); */ LILV_API const char* -lilv_value_as_blank(LilvValue value); +lilv_value_as_blank(const LilvValue* value); /** Return whether this value is a literal (i.e. not a URI). @@ -211,7 +213,7 @@ lilv_value_as_blank(LilvValue value); */ LILV_API bool -lilv_value_is_literal(LilvValue value); +lilv_value_is_literal(const LilvValue* value); /** Return whether this value is a string literal. @@ -219,21 +221,21 @@ lilv_value_is_literal(LilvValue value); */ LILV_API bool -lilv_value_is_string(LilvValue value); +lilv_value_is_string(const LilvValue* value); /** Return @a value as a string. */ LILV_API const char* -lilv_value_as_string(LilvValue value); +lilv_value_as_string(const LilvValue* value); /** Return whether this value is a decimal literal. */ LILV_API bool -lilv_value_is_float(LilvValue value); +lilv_value_is_float(const LilvValue* value); /** Return @a value as a float. @@ -242,14 +244,14 @@ lilv_value_is_float(LilvValue value); */ LILV_API float -lilv_value_as_float(LilvValue value); +lilv_value_as_float(const LilvValue* value); /** Return whether this value is an integer literal. */ LILV_API bool -lilv_value_is_int(LilvValue value); +lilv_value_is_int(const LilvValue* value); /** Return @a value as an integer. @@ -257,14 +259,14 @@ lilv_value_is_int(LilvValue value); */ LILV_API int -lilv_value_as_int(LilvValue value); +lilv_value_as_int(const LilvValue* value); /** Return whether this value is a boolean. */ LILV_API bool -lilv_value_is_bool(LilvValue value); +lilv_value_is_bool(const LilvValue* value); /** Return @a value as a bool. @@ -272,7 +274,7 @@ lilv_value_is_bool(LilvValue value); */ LILV_API bool -lilv_value_as_bool(LilvValue value); +lilv_value_as_bool(const LilvValue* value); /** @} @@ -290,15 +292,13 @@ lilv_value_as_bool(LilvValue value); <ul> <li>void PREFIX_free (coll)</li> <li>unsigned PREFIX_size (coll)</li> - <li>LilvIter PREFIX_begin (coll)</li> + <li>LilvIter* PREFIX_begin (coll)</li> </ul> @{ */ /* Collections */ -typedef void* LilvIter; - /** Iterate over each element of a collection. @code @@ -309,7 +309,7 @@ typedef void* LilvIter; @endcode */ #define LILV_FOREACH(colltype, iter, collection) \ - for (LilvIter (iter) = lilv_ ## colltype ## _begin(collection); \ + for (LilvIter* (iter) = lilv_ ## colltype ## _begin(collection); \ !lilv_ ## colltype ## _is_end(collection, iter); \ (iter) = lilv_ ## colltype ## _next(collection, iter)) @@ -317,27 +317,27 @@ typedef void* LilvIter; LILV_API void -lilv_plugin_classes_free(LilvPluginClasses collection); +lilv_plugin_classes_free(LilvPluginClasses* collection); LILV_API unsigned -lilv_plugin_classes_size(LilvPluginClasses collection); +lilv_plugin_classes_size(const LilvPluginClasses* collection); LILV_API -LilvIter -lilv_plugin_classes_begin(LilvPluginClasses collection); +LilvIter* +lilv_plugin_classes_begin(const LilvPluginClasses* collection); LILV_API -LilvPluginClass -lilv_plugin_classes_get(LilvPluginClasses collection, LilvIter i); +const LilvPluginClass* +lilv_plugin_classes_get(const LilvPluginClasses* collection, LilvIter* i); LILV_API -LilvIter -lilv_plugin_classes_next(LilvPluginClasses collection, LilvIter i); +LilvIter* +lilv_plugin_classes_next(const LilvPluginClasses* collection, LilvIter* i); LILV_API bool -lilv_plugin_classes_is_end(LilvPluginClasses collection, LilvIter i); +lilv_plugin_classes_is_end(const LilvPluginClasses* collection, LilvIter* i); /** Get a plugin class from @a classes by URI. @@ -346,61 +346,61 @@ lilv_plugin_classes_is_end(LilvPluginClasses collection, LilvIter i); @return NULL if no plugin class with @a uri is found in @a classes. */ LILV_API -LilvPluginClass -lilv_plugin_classes_get_by_uri(LilvPluginClasses classes, - LilvValue uri); +const LilvPluginClass* +lilv_plugin_classes_get_by_uri(const LilvPluginClasses* classes, + const LilvValue* uri); /* ScalePoints */ LILV_API void -lilv_scale_points_free(LilvScalePoints collection); +lilv_scale_points_free(LilvScalePoints* collection); LILV_API unsigned -lilv_scale_points_size(LilvScalePoints collection); +lilv_scale_points_size(const LilvScalePoints* collection); LILV_API -LilvIter -lilv_scale_points_begin(LilvScalePoints collection); +LilvIter* +lilv_scale_points_begin(const LilvScalePoints* collection); LILV_API -LilvScalePoint -lilv_scale_points_get(LilvScalePoints collection, LilvIter i); +const LilvScalePoint* +lilv_scale_points_get(const LilvScalePoints* collection, LilvIter* i); LILV_API -LilvIter -lilv_scale_points_next(LilvScalePoints collection, LilvIter i); +LilvIter* +lilv_scale_points_next(const LilvScalePoints* collection, LilvIter* i); LILV_API bool -lilv_scale_points_is_end(LilvScalePoints collection, LilvIter i); +lilv_scale_points_is_end(const LilvScalePoints* collection, LilvIter* i); /* UIs */ LILV_API void -lilv_uis_free(LilvUIs collection); +lilv_uis_free(LilvUIs* collection); LILV_API unsigned -lilv_uis_size(LilvUIs collection); +lilv_uis_size(const LilvUIs* collection); LILV_API -LilvIter -lilv_uis_begin(LilvUIs collection); +LilvIter* +lilv_uis_begin(const LilvUIs* collection); LILV_API -LilvUI -lilv_uis_get(LilvUIs collection, LilvIter i); +const LilvUI* +lilv_uis_get(const LilvUIs* collection, LilvIter* i); LILV_API -LilvIter -lilv_uis_next(LilvUIs collection, LilvIter i); +LilvIter* +lilv_uis_next(const LilvUIs* collection, LilvIter* i); LILV_API bool -lilv_uis_is_end(LilvUIs collection, LilvIter i); +lilv_uis_is_end(const LilvUIs* collection, LilvIter* i); /** Get a UI from @a uis by URI. @@ -409,72 +409,68 @@ lilv_uis_is_end(LilvUIs collection, LilvIter i); @return NULL if no UI with @a uri is found in @a list. */ LILV_API -LilvUI -lilv_uis_get_by_uri(LilvUIs uis, - LilvValue uri); +const LilvUI* +lilv_uis_get_by_uri(const LilvUIs* uis, + const LilvValue* uri); /* Values */ LILV_API void -lilv_values_free(LilvValues collection); +lilv_values_free(LilvValues* collection); LILV_API unsigned -lilv_values_size(LilvValues collection); +lilv_values_size(const LilvValues* collection); LILV_API -LilvIter -lilv_values_begin(LilvValues collection); +LilvIter* +lilv_values_begin(const LilvValues* collection); LILV_API -LilvValue -lilv_values_get(LilvValues collection, LilvIter i); +const LilvValue* +lilv_values_get(const LilvValues* collection, LilvIter* i); LILV_API -LilvIter -lilv_values_next(LilvValues collection, LilvIter i); +LilvIter* +lilv_values_next(const LilvValues* collection, LilvIter* i); LILV_API bool -lilv_values_is_end(LilvValues collection, LilvIter i); +lilv_values_is_end(const LilvValues* collection, LilvIter* i); LILV_API -LilvValue -lilv_values_get_first(LilvValues collection); +LilvValue* +lilv_values_get_first(const LilvValues* collection); /** Return whether @a values contains @a value. */ LILV_API bool -lilv_values_contains(LilvValues values, LilvValue value); +lilv_values_contains(const LilvValues* values, const LilvValue* value); /* Plugins */ LILV_API unsigned -lilv_plugins_size(LilvPlugins collection); +lilv_plugins_size(const LilvPlugins* collection); LILV_API -LilvIter -lilv_plugins_begin(LilvPlugins collection); +LilvIter* +lilv_plugins_begin(const LilvPlugins* collection); LILV_API -LilvPlugin -lilv_plugins_get(LilvPlugins collection, LilvIter i); +const LilvPlugin* +lilv_plugins_get(const LilvPlugins* collection, LilvIter* i); LILV_API -LilvIter -lilv_plugins_next(LilvPlugins collection, LilvIter i); +LilvIter* +lilv_plugins_next(const LilvPlugins* collection, LilvIter* i); LILV_API bool -lilv_plugins_is_end(LilvPlugins collection, LilvIter i); - -LILV_API -void -lilv_plugins_free(LilvWorld world, LilvPlugins plugins); +lilv_plugins_is_end(const LilvPlugins* collection, LilvIter* i); /** Get a plugin from @a plugins by URI. @@ -483,9 +479,9 @@ lilv_plugins_free(LilvWorld world, LilvPlugins plugins); @return NULL if no plugin with @a uri is found in @a plugins. */ LILV_API -LilvPlugin -lilv_plugins_get_by_uri(LilvPlugins plugins, - LilvValue uri); +const LilvPlugin* +lilv_plugins_get_by_uri(const LilvPlugins* plugins, + const LilvValue* uri); /** @} @@ -502,7 +498,7 @@ lilv_plugins_get_by_uri(LilvPlugins plugins, If initialization fails, NULL is returned. */ LILV_API -LilvWorld +LilvWorld* lilv_world_new(void); /** @@ -529,9 +525,9 @@ lilv_world_new(void); */ LILV_API void -lilv_world_set_option(LilvWorld world, - const char* uri, - const LilvValue value); +lilv_world_set_option(LilvWorld* world, + const char* uri, + const LilvValue* value); /** Destroy the world, mwahaha. @@ -541,7 +537,7 @@ lilv_world_set_option(LilvWorld world, */ LILV_API void -lilv_world_free(LilvWorld world); +lilv_world_free(LilvWorld* world); /** Load all installed LV2 bundles on the system. @@ -556,7 +552,7 @@ lilv_world_free(LilvWorld world); */ LILV_API void -lilv_world_load_all(LilvWorld world); +lilv_world_load_all(LilvWorld* world); /** Load a specific bundle. @@ -572,23 +568,23 @@ lilv_world_load_all(LilvWorld world); */ LILV_API void -lilv_world_load_bundle(LilvWorld world, - LilvValue bundle_uri); +lilv_world_load_bundle(LilvWorld* world, + LilvValue* bundle_uri); /** Get the parent of all other plugin classes, lv2:Plugin. */ LILV_API -LilvPluginClass -lilv_world_get_plugin_class(LilvWorld world); +const LilvPluginClass* +lilv_world_get_plugin_class(const LilvWorld* world); /** Return a list of all found plugin classes. Returned list is owned by world and must not be freed by the caller. */ LILV_API -LilvPluginClasses -lilv_world_get_plugin_classes(LilvWorld world); +const LilvPluginClasses* +lilv_world_get_plugin_classes(const LilvWorld* world); /** Return a list of all found plugins. @@ -602,16 +598,8 @@ lilv_world_get_plugin_classes(LilvWorld world); and must not be freed by caller. */ LILV_API -LilvPlugins -lilv_world_get_all_plugins(LilvWorld world); - -/** - Return the plugin with the given @a uri, or NULL if not found. -*/ -LILV_API -LilvPlugin -lilv_world_get_plugin_by_uri_string(LilvWorld world, - const char* uri); +const LilvPlugins* +lilv_world_get_all_plugins(const LilvWorld* world); /** @} @@ -631,7 +619,7 @@ lilv_world_get_plugin_by_uri_string(LilvWorld world, */ LILV_API bool -lilv_plugin_verify(LilvPlugin plugin); +lilv_plugin_verify(const LilvPlugin* plugin); /** Get the URI of @a plugin. @@ -648,8 +636,8 @@ lilv_plugin_verify(LilvPlugin plugin); @return A shared URI value which must not be modified or freed. */ LILV_API -LilvValue -lilv_plugin_get_uri(LilvPlugin plugin); +const LilvValue* +lilv_plugin_get_uri(const LilvPlugin* plugin); /** Get the (resolvable) URI of the plugin's "main" bundle. @@ -663,8 +651,8 @@ lilv_plugin_get_uri(LilvPlugin plugin); @return a shared string which must not be modified or freed. */ LILV_API -LilvValue -lilv_plugin_get_bundle_uri(LilvPlugin plugin); +const LilvValue* +lilv_plugin_get_bundle_uri(const LilvPlugin* plugin); /** Get the (resolvable) URIs of the RDF data files that define a plugin. @@ -675,8 +663,8 @@ lilv_plugin_get_bundle_uri(LilvPlugin plugin); which is shared and must not be modified or freed. */ LILV_API -LilvValues -lilv_plugin_get_data_uris(LilvPlugin plugin); +const LilvValues* +lilv_plugin_get_data_uris(const LilvPlugin* plugin); /** Get the (resolvable) URI of the shared library for @a plugin. @@ -685,8 +673,8 @@ lilv_plugin_get_data_uris(LilvPlugin plugin); @return a shared string which must not be modified or freed. */ LILV_API -LilvValue -lilv_plugin_get_library_uri(LilvPlugin plugin); +const LilvValue* +lilv_plugin_get_library_uri(const LilvPlugin* plugin); /** Get the name of @a plugin. @@ -696,15 +684,15 @@ lilv_plugin_get_library_uri(LilvPlugin plugin); Returned value must be freed by the caller. */ LILV_API -LilvValue -lilv_plugin_get_name(LilvPlugin plugin); +LilvValue* +lilv_plugin_get_name(const LilvPlugin* plugin); /** - Get the class this plugin belongs to (ie Filters). + Get the class this plugin belongs to (e.g. Filters). */ LILV_API -LilvPluginClass -lilv_plugin_get_class(LilvPlugin plugin); +const LilvPluginClass* +lilv_plugin_get_class(const LilvPlugin* plugin); /** Get a value associated with the plugin in a plugin's data files. @@ -719,9 +707,9 @@ lilv_plugin_get_class(LilvPlugin plugin); Return value must be freed by caller with lilv_values_free. */ LILV_API -LilvValues -lilv_plugin_get_value(LilvPlugin p, - LilvValue predicate); +LilvValues* +lilv_plugin_get_value(const LilvPlugin* p, + const LilvValue* predicate); /** Get a value associated with the plugin in a plugin's data files. @@ -730,9 +718,9 @@ lilv_plugin_get_value(LilvPlugin p, more convenient. */ LILV_API -LilvValues -lilv_plugin_get_value_by_qname(LilvPlugin p, - const char* predicate); +LilvValues* +lilv_plugin_get_value_by_qname(const LilvPlugin* p, + const char* predicate); /** Get a value associated with some subject in a plugin's data files. @@ -750,10 +738,10 @@ lilv_plugin_get_value_by_qname(LilvPlugin p, Return value must be freed by caller with lilv_values_free. */ LILV_API -LilvValues -lilv_plugin_get_value_for_subject(LilvPlugin p, - LilvValue subject_uri, - LilvValue predicate_uri); +LilvValues* +lilv_plugin_get_value_for_subject(const LilvPlugin* p, + const LilvValue* subject_uri, + const LilvValue* predicate_uri); /** Return whether a feature is supported by a plugin. @@ -762,8 +750,8 @@ lilv_plugin_get_value_for_subject(LilvPlugin p, */ LILV_API bool -lilv_plugin_has_feature(LilvPlugin p, - LilvValue feature_uri); +lilv_plugin_has_feature(const LilvPlugin* p, + const LilvValue* feature_uri); /** Get the LV2 Features supported (required or optionally) by a plugin. @@ -776,8 +764,8 @@ lilv_plugin_has_feature(LilvPlugin p, Returned value must be freed by caller with lilv_values_free. */ LILV_API -LilvValues -lilv_plugin_get_supported_features(LilvPlugin p); +LilvValues* +lilv_plugin_get_supported_features(const LilvPlugin* p); /** Get the LV2 Features required by a plugin. @@ -791,8 +779,8 @@ lilv_plugin_get_supported_features(LilvPlugin p); Return value must be freed by caller with lilv_values_free. */ LILV_API -LilvValues -lilv_plugin_get_required_features(LilvPlugin p); +LilvValues* +lilv_plugin_get_required_features(const LilvPlugin* p); /** Get the LV2 Features optionally supported by a plugin. @@ -803,15 +791,15 @@ lilv_plugin_get_required_features(LilvPlugin p); Return value must be freed by caller with lilv_values_free. */ LILV_API -LilvValues -lilv_plugin_get_optional_features(LilvPlugin p); +LilvValues* +lilv_plugin_get_optional_features(const LilvPlugin* p); /** Get the number of ports on this plugin. */ LILV_API uint32_t -lilv_plugin_get_num_ports(LilvPlugin p); +lilv_plugin_get_num_ports(const LilvPlugin* p); /** Get the port ranges (minimum, maximum and default values) for all ports. @@ -829,10 +817,10 @@ lilv_plugin_get_num_ports(LilvPlugin p); */ LILV_API void -lilv_plugin_get_port_ranges_float(LilvPlugin p, - float* min_values, - float* max_values, - float* def_values); +lilv_plugin_get_port_ranges_float(const LilvPlugin* p, + float* min_values, + float* max_values, + float* def_values); /** Get the number of ports on this plugin that are members of some class(es). @@ -842,8 +830,8 @@ lilv_plugin_get_port_ranges_float(LilvPlugin p, */ LILV_API uint32_t -lilv_plugin_get_num_ports_of_class(LilvPlugin p, - LilvValue class_1, ...); +lilv_plugin_get_num_ports_of_class(const LilvPlugin* p, + const LilvValue* class_1, ...); /** Return whether or not the plugin introduces (and reports) latency. @@ -852,7 +840,7 @@ lilv_plugin_get_num_ports_of_class(LilvPlugin p, */ LILV_API bool -lilv_plugin_has_latency(LilvPlugin p); +lilv_plugin_has_latency(const LilvPlugin* p); /** Return the index of the plugin's latency port. @@ -865,15 +853,15 @@ lilv_plugin_has_latency(LilvPlugin p); */ LILV_API uint32_t -lilv_plugin_get_latency_port_index(LilvPlugin p); +lilv_plugin_get_latency_port_index(const LilvPlugin* p); /** Get a port on @a plugin by @a index. */ LILV_API -LilvPort -lilv_plugin_get_port_by_index(LilvPlugin plugin, - uint32_t index); +const LilvPort* +lilv_plugin_get_port_by_index(const LilvPlugin* plugin, + uint32_t index); /** Get a port on @a plugin by @a symbol. @@ -881,9 +869,9 @@ lilv_plugin_get_port_by_index(LilvPlugin plugin, especially on plugins with a very large number of ports. */ LILV_API -LilvPort -lilv_plugin_get_port_by_symbol(LilvPlugin plugin, - LilvValue symbol); +const LilvPort* +lilv_plugin_get_port_by_symbol(const LilvPlugin* plugin, + const LilvValue* symbol); /** Get the full name of the plugin's author. @@ -891,8 +879,8 @@ lilv_plugin_get_port_by_symbol(LilvPlugin plugin, Returned value must be freed by caller. */ LILV_API -LilvValue -lilv_plugin_get_author_name(LilvPlugin plugin); +LilvValue* +lilv_plugin_get_author_name(const LilvPlugin* plugin); /** Get the email address of the plugin's author. @@ -900,8 +888,8 @@ lilv_plugin_get_author_name(LilvPlugin plugin); Returned value must be freed by caller. */ LILV_API -LilvValue -lilv_plugin_get_author_email(LilvPlugin plugin); +LilvValue* +lilv_plugin_get_author_email(const LilvPlugin* plugin); /** Get the email address of the plugin's author. @@ -909,8 +897,8 @@ lilv_plugin_get_author_email(LilvPlugin plugin); Returned value must be freed by caller. */ LILV_API -LilvValue -lilv_plugin_get_author_homepage(LilvPlugin plugin); +LilvValue* +lilv_plugin_get_author_homepage(const LilvPlugin* plugin); /** Return true iff @a plugin has been replaced by another plugin. @@ -920,7 +908,7 @@ lilv_plugin_get_author_homepage(LilvPlugin plugin); */ LILV_API bool -lilv_plugin_is_replaced(LilvPlugin plugin); +lilv_plugin_is_replaced(const LilvPlugin* plugin); /** @} @@ -932,45 +920,45 @@ lilv_plugin_is_replaced(LilvPlugin plugin); Port analog of lilv_plugin_get_value. */ LILV_API -LilvValues -lilv_port_get_value(LilvPlugin plugin, - LilvPort port, - LilvValue predicate); +LilvValues* +lilv_port_get_value(const LilvPlugin* plugin, + const LilvPort* port, + const LilvValue* predicate); /** Port analog of lilv_plugin_get_value_by_qname. */ LILV_API -LilvValues -lilv_port_get_value_by_qname(LilvPlugin plugin, - LilvPort port, +LilvValues* +lilv_port_get_value_by_qname(const LilvPlugin* plugin, + const LilvPort* port, const char* predicate); /** Return the LV2 port properties of a port. */ LILV_API -LilvValues -lilv_port_get_properties(LilvPlugin plugin, - LilvPort port); +LilvValues* +lilv_port_get_properties(const LilvPlugin* plugin, + const LilvPort* port); /** Return whether a port has a certain property. */ LILV_API bool -lilv_port_has_property(LilvPlugin p, - LilvPort port, - LilvValue property_uri); +lilv_port_has_property(const LilvPlugin* p, + const LilvPort* port, + const LilvValue* property_uri); /** Return whether a port is an event port and supports a certain event type. */ LILV_API bool -lilv_port_supports_event(LilvPlugin p, - LilvPort port, - LilvValue event_uri); +lilv_port_supports_event(const LilvPlugin* p, + const LilvPort* port, + const LilvValue* event_uri); /** Get the symbol of a port. @@ -978,9 +966,9 @@ lilv_port_supports_event(LilvPlugin p, Returned value is owned by @a port and must not be freed. */ LILV_API -LilvValue -lilv_port_get_symbol(LilvPlugin plugin, - LilvPort port); +const LilvValue* +lilv_port_get_symbol(const LilvPlugin* plugin, + const LilvPort* port); /** Get the name of a port. @@ -989,9 +977,9 @@ lilv_port_get_symbol(LilvPlugin plugin, the caller. */ LILV_API -LilvValue -lilv_port_get_name(LilvPlugin plugin, - LilvPort port); +LilvValue* +lilv_port_get_name(const LilvPlugin* plugin, + const LilvPort* port); /** Get all the classes of a port. @@ -1001,9 +989,9 @@ lilv_port_get_name(LilvPlugin plugin, Returned value is shared and must not be destroyed by caller. */ LILV_API -LilvValues -lilv_port_get_classes(LilvPlugin plugin, - LilvPort port); +const LilvValues* +lilv_port_get_classes(const LilvPlugin* plugin, + const LilvPort* port); /** Determine if a port is of a given class (input, output, audio, etc). @@ -1015,9 +1003,9 @@ lilv_port_get_classes(LilvPlugin plugin, */ LILV_API bool -lilv_port_is_a(LilvPlugin plugin, - LilvPort port, - LilvValue port_class); +lilv_port_is_a(const LilvPlugin* plugin, + const LilvPort* port, + const LilvValue* port_class); /** Get the default, minimum, and maximum values of a port. @@ -1028,11 +1016,11 @@ lilv_port_is_a(LilvPlugin plugin, */ LILV_API void -lilv_port_get_range(LilvPlugin plugin, - LilvPort port, - LilvValue* deflt, - LilvValue* min, - LilvValue* max); +lilv_port_get_range(const LilvPlugin* plugin, + const LilvPort* port, + LilvValue** deflt, + LilvValue** min, + LilvValue** max); /** Get the scale points (enumeration values) of a port. @@ -1042,9 +1030,9 @@ lilv_port_get_range(LilvPlugin plugin, must be freed by caller with lilv_scale_points_free. */ LILV_API -LilvScalePoints -lilv_port_get_scale_points(LilvPlugin plugin, - LilvPort port); +LilvScalePoints* +lilv_port_get_scale_points(const LilvPlugin* plugin, + const LilvPort* port); /** @} @@ -1057,16 +1045,16 @@ lilv_port_get_scale_points(LilvPlugin plugin, Returned value is owned by @a point and must not be freed. */ LILV_API -LilvValue -lilv_scale_point_get_label(LilvScalePoint point); +const LilvValue* +lilv_scale_point_get_label(const LilvScalePoint* point); /** Get the value of this scale point (enumeration value) Returned value is owned by @a point and must not be freed. */ LILV_API -LilvValue -lilv_scale_point_get_value(LilvScalePoint point); +const LilvValue* +lilv_scale_point_get_value(const LilvScalePoint* point); /** @} @@ -1080,31 +1068,32 @@ lilv_scale_point_get_value(LilvScalePoint point); Returned value may be NULL, if class has no parent. */ LILV_API -LilvValue -lilv_plugin_class_get_parent_uri(LilvPluginClass plugin_class); +const LilvValue* +lilv_plugin_class_get_parent_uri(const LilvPluginClass* plugin_class); /** Get the URI of this plugin class. Returned value is owned by @a plugin_class and must not be freed by caller. */ LILV_API -LilvValue -lilv_plugin_class_get_uri(LilvPluginClass plugin_class); +const LilvValue* +lilv_plugin_class_get_uri(const LilvPluginClass* plugin_class); /** Get the label of this plugin class, ie "Oscillators". Returned value is owned by @a plugin_class and must not be freed by caller. */ LILV_API -LilvValue lilv_plugin_class_get_label(LilvPluginClass plugin_class); +const LilvValue* +lilv_plugin_class_get_label(const LilvPluginClass* plugin_class); /** Get the subclasses of this plugin class. Returned value must be freed by caller with lilv_plugin_classes_free. */ LILV_API -LilvPluginClasses -lilv_plugin_class_get_children(LilvPluginClass plugin_class); +LilvPluginClasses* +lilv_plugin_class_get_children(const LilvPluginClass* plugin_class); /** @} @@ -1112,8 +1101,6 @@ lilv_plugin_class_get_children(LilvPluginClass plugin_class); @{ */ -typedef struct _LilvInstanceImpl* LilvInstanceImpl; - /** @cond 0 */ @@ -1125,11 +1112,11 @@ typedef struct _LilvInstanceImpl* LilvInstanceImpl; in any way (which is why it is not machine documented). Truly private implementation details are hidden via @a ref pimpl. */ -typedef struct _Instance { +struct LilvInstanceImpl { const LV2_Descriptor* lv2_descriptor; LV2_Handle lv2_handle; - LilvInstanceImpl pimpl; -}* LilvInstance; + void* pimpl; +}; /** @endcond @@ -1145,8 +1132,8 @@ typedef struct _Instance { @return NULL if instantiation failed. */ LILV_API -LilvInstance -lilv_plugin_instantiate(LilvPlugin plugin, +LilvInstance* +lilv_plugin_instantiate(const LilvPlugin* plugin, double sample_rate, const LV2_Feature*const* features); @@ -1156,7 +1143,7 @@ lilv_plugin_instantiate(LilvPlugin plugin, */ LILV_API void -lilv_instance_free(LilvInstance instance); +lilv_instance_free(LilvInstance* instance); #ifndef LILV_INTERNAL @@ -1165,7 +1152,7 @@ lilv_instance_free(LilvInstance instance); Returned string is shared and must not be modified or deleted. */ static inline const char* -lilv_instance_get_uri(LilvInstance instance) +lilv_instance_get_uri(const LilvInstance* instance) { return instance->lv2_descriptor->URI; } @@ -1176,9 +1163,9 @@ lilv_instance_get_uri(LilvInstance instance) activation and deactivation does not destroy port connections. */ static inline void -lilv_instance_connect_port(LilvInstance instance, - uint32_t port_index, - void* data_location) +lilv_instance_connect_port(LilvInstance* instance, + uint32_t port_index, + void* data_location) { instance->lv2_descriptor->connect_port (instance->lv2_handle, port_index, data_location); @@ -1191,7 +1178,7 @@ lilv_instance_connect_port(LilvInstance instance, before calling lilv_instance_run. */ static inline void -lilv_instance_activate(LilvInstance instance) +lilv_instance_activate(LilvInstance* instance) { if (instance->lv2_descriptor->activate) instance->lv2_descriptor->activate(instance->lv2_handle); @@ -1203,7 +1190,7 @@ lilv_instance_activate(LilvInstance instance) guaranteed not to block. */ static inline void -lilv_instance_run(LilvInstance instance, +lilv_instance_run(LilvInstance* instance, uint32_t sample_count) { instance->lv2_descriptor->run(instance->lv2_handle, sample_count); @@ -1215,7 +1202,7 @@ lilv_instance_run(LilvInstance instance, reset all state information (except port connections). */ static inline void -lilv_instance_deactivate(LilvInstance instance) +lilv_instance_deactivate(LilvInstance* instance) { if (instance->lv2_descriptor->deactivate) instance->lv2_descriptor->deactivate(instance->lv2_handle); @@ -1227,8 +1214,8 @@ lilv_instance_deactivate(LilvInstance instance) extension, though in all cases it is shared and must not be deleted. */ static inline const void* -lilv_instance_get_extension_data(LilvInstance instance, - const char* uri) +lilv_instance_get_extension_data(const LilvInstance* instance, + const char* uri) { if (instance->lv2_descriptor->extension_data) return instance->lv2_descriptor->extension_data(uri); @@ -1244,7 +1231,7 @@ lilv_instance_get_extension_data(LilvInstance instance, The returned descriptor is shared and must not be deleted. */ static inline const LV2_Descriptor* -lilv_instance_get_descriptor(LilvInstance instance) +lilv_instance_get_descriptor(const LilvInstance* instance) { return instance->lv2_descriptor; } @@ -1257,7 +1244,7 @@ lilv_instance_get_descriptor(LilvInstance instance) The returned handle is shared and must not be deleted. */ static inline LV2_Handle -lilv_instance_get_handle(LilvInstance instance) +lilv_instance_get_handle(const LilvInstance* instance) { return instance->lv2_handle; } @@ -1275,8 +1262,8 @@ lilv_instance_get_handle(LilvInstance instance) Returned value must be freed by caller using lilv_uis_free. */ LILV_API -LilvUIs -lilv_plugin_get_uis(LilvPlugin plugin); +LilvUIs* +lilv_plugin_get_uis(const LilvPlugin* plugin); /** Get the URI of a Plugin UI. @@ -1284,8 +1271,8 @@ lilv_plugin_get_uis(LilvPlugin plugin); @return a shared value which must not be modified or freed. */ LILV_API -LilvValue -lilv_ui_get_uri(LilvUI ui); +const LilvValue* +lilv_ui_get_uri(const LilvUI* ui); /** Get the types (URIs of RDF classes) of a Plugin UI. @@ -1296,8 +1283,8 @@ lilv_ui_get_uri(LilvUI ui); UI type, avoding the need to use this function (and type specific logic). */ LILV_API -LilvValues -lilv_ui_get_classes(LilvUI ui); +const LilvValues* +lilv_ui_get_classes(const LilvUI* ui); /** Check whether a plugin UI has a given type. @@ -1306,7 +1293,7 @@ lilv_ui_get_classes(LilvUI ui); */ LILV_API bool -lilv_ui_is_a(LilvUI ui, LilvValue class_uri); +lilv_ui_is_a(const LilvUI* ui, const LilvValue* class_uri); /** Function to determine whether a UI type is supported. @@ -1328,10 +1315,10 @@ typedef unsigned (*LilvUISupportedFunc)(const char* container_type_uri, */ LILV_API unsigned -lilv_ui_is_supported(LilvUI ui, +lilv_ui_is_supported(const LilvUI* ui, LilvUISupportedFunc supported_func, - LilvValue container_type, - LilvValue* ui_type); + const LilvValue* container_type, + const LilvValue** ui_type); /** Get the URI for a Plugin UI's bundle. @@ -1339,8 +1326,8 @@ lilv_ui_is_supported(LilvUI ui, @return a shared value which must not be modified or freed. */ LILV_API -LilvValue -lilv_ui_get_bundle_uri(LilvUI ui); +const LilvValue* +lilv_ui_get_bundle_uri(const LilvUI* ui); /** Get the URI for a Plugin UI's shared library. @@ -1348,8 +1335,8 @@ lilv_ui_get_bundle_uri(LilvUI ui); @return a shared value which must not be modified or freed. */ LILV_API -LilvValue -lilv_ui_get_binary_uri(LilvUI ui); +const LilvValue* +lilv_ui_get_binary_uri(const LilvUI* ui); /** @} diff --git a/lilv/lilvmm.hpp b/lilv/lilvmm.hpp index 7f25d33..66a0276 100644 --- a/lilv/lilvmm.hpp +++ b/lilv/lilvmm.hpp @@ -43,16 +43,16 @@ const char* uri_to_path(const char* uri) { return lilv_uri_to_path(uri); } #ifndef SWIG #define LILV_WRAP_CONVERSION(CT) \ - inline operator CT() const { return me; } + inline operator CT*() const { return me; } #else #define LILV_WRAP_CONVERSION(CT) #endif struct Value { - inline Value(LilvValue value) : me(value) {} - inline Value(const Value& copy) : me(lilv_value_duplicate(copy.me)) {} + inline Value(const LilvValue* value) : me(lilv_value_duplicate(value)) {} + inline Value(const Value& copy) : me(lilv_value_duplicate(copy.me)) {} - inline ~Value() { /*lilv_value_free(me);*/ } + inline ~Value() { lilv_value_free(me); } inline bool equals(const Value& other) const { return lilv_value_equals(me, other.me); @@ -77,41 +77,41 @@ struct Value { LILV_WRAP0(bool, value, is_bool); LILV_WRAP0(bool, value, as_bool); - LilvValue me; + LilvValue* me; }; struct ScalePoint { - inline ScalePoint(LilvScalePoint c_obj) : me(c_obj) {} - LILV_WRAP_CONVERSION(LilvScalePoint); + inline ScalePoint(const LilvScalePoint* c_obj) : me(c_obj) {} + LILV_WRAP_CONVERSION(const LilvScalePoint); - LILV_WRAP0(LilvValue, scale_point, get_label); - LILV_WRAP0(LilvValue, scale_point, get_value); + LILV_WRAP0(const LilvValue*, scale_point, get_label); + LILV_WRAP0(const LilvValue*, scale_point, get_value); - LilvScalePoint me; + const LilvScalePoint* me; }; struct PluginClass { - inline PluginClass(LilvPluginClass c_obj) : me(c_obj) {} - LILV_WRAP_CONVERSION(LilvPluginClass); + inline PluginClass(const LilvPluginClass* c_obj) : me(c_obj) {} + LILV_WRAP_CONVERSION(const LilvPluginClass); LILV_WRAP0(Value, plugin_class, get_parent_uri); LILV_WRAP0(Value, plugin_class, get_uri); LILV_WRAP0(Value, plugin_class, get_label); - inline LilvPluginClasses get_children() { + inline LilvPluginClasses* get_children() { return lilv_plugin_class_get_children(me); } - LilvPluginClass me; + const LilvPluginClass* me; }; #define LILV_WRAP_COLL(CT, ET, prefix) \ struct CT { \ - inline CT(Lilv ## CT c_obj) : me(c_obj) {} \ - LILV_WRAP_CONVERSION(Lilv ## CT); \ + inline CT(const Lilv ## CT* c_obj) : me(c_obj) {} \ + LILV_WRAP_CONVERSION(const Lilv ## CT); \ LILV_WRAP0(unsigned, prefix, size); \ - LILV_WRAP1(ET, prefix, get, LilvIter, i); \ - Lilv ## CT me; \ + LILV_WRAP1(const ET, prefix, get, LilvIter*, i); \ + const Lilv ## CT* me; \ }; \ LILV_WRAP_COLL(PluginClasses, PluginClass, plugin_classes); @@ -119,47 +119,47 @@ LILV_WRAP_COLL(ScalePoints, ScalePoint, scale_points); LILV_WRAP_COLL(Values, Value, values); struct Plugins { - inline Plugins(LilvPlugins c_obj) : me(c_obj) {} - LILV_WRAP_CONVERSION(LilvPlugins); + inline Plugins(const LilvPlugins* c_obj) : me(c_obj) {} + LILV_WRAP_CONVERSION(const LilvPlugins); - LilvPlugins me; + const LilvPlugins* me; }; struct World { inline World() : me(lilv_world_new()) {} inline ~World() { /*lilv_world_free(me);*/ } - inline LilvValue new_uri(const char* uri) { + inline LilvValue* new_uri(const char* uri) { return lilv_value_new_uri(me, uri); } - inline LilvValue new_string(const char* str) { + inline LilvValue* new_string(const char* str) { return lilv_value_new_string(me, str); } - inline LilvValue new_int(int val) { + inline LilvValue* new_int(int val) { return lilv_value_new_int(me, val); } - inline LilvValue new_float(float val) { + inline LilvValue* new_float(float val) { return lilv_value_new_float(me, val); } - inline LilvValue new_bool(bool val) { + inline LilvValue* new_bool(bool val) { return lilv_value_new_bool(me, val); } - LILV_WRAP2_VOID(world, set_option, const char*, uri, LilvValue, value); + LILV_WRAP2_VOID(world, set_option, const char*, uri, LilvValue*, value); LILV_WRAP0_VOID(world, free); LILV_WRAP0_VOID(world, load_all); - LILV_WRAP1_VOID(world, load_bundle, LilvValue, bundle_uri); - LILV_WRAP0(LilvPluginClass, world, get_plugin_class); - LILV_WRAP0(LilvPluginClasses, world, get_plugin_classes); + LILV_WRAP1_VOID(world, load_bundle, LilvValue*, bundle_uri); + LILV_WRAP0(const LilvPluginClass*, world, get_plugin_class); + LILV_WRAP0(const LilvPluginClasses*, world, get_plugin_classes); LILV_WRAP0(Plugins, world, get_all_plugins); //LILV_WRAP1(Plugin, world, get_plugin_by_uri_string, const char*, uri); - LilvWorld me; + LilvWorld* me; }; struct Port { - inline Port(LilvPlugin p, LilvPort c_obj) : parent(p), me(c_obj) {} - LILV_WRAP_CONVERSION(LilvPort); + inline Port(const LilvPlugin* p, const LilvPort* c_obj) : parent(p), me(c_obj) {} + LILV_WRAP_CONVERSION(const LilvPort); #define LILV_PORT_WRAP0(RT, name) \ inline RT name () { return lilv_port_ ## name (parent, me); } @@ -167,26 +167,26 @@ struct Port { #define LILV_PORT_WRAP1(RT, name, T1, a1) \ inline RT name (T1 a1) { return lilv_port_ ## name (parent, me, a1); } - LILV_PORT_WRAP1(LilvValues, get_value, LilvValue, predicate); - LILV_PORT_WRAP1(LilvValues, get_value_by_qname, const char*, predicate); - LILV_PORT_WRAP0(LilvValues, get_properties) - LILV_PORT_WRAP1(bool, has_property, LilvValue, property_uri); - LILV_PORT_WRAP1(bool, supports_event, LilvValue, event_uri); - LILV_PORT_WRAP0(LilvValue, get_symbol); - LILV_PORT_WRAP0(LilvValue, get_name); - LILV_PORT_WRAP0(LilvValues, get_classes); - LILV_PORT_WRAP1(bool, is_a, LilvValue, port_class); - LILV_PORT_WRAP0(LilvScalePoints, get_scale_points); + LILV_PORT_WRAP1(LilvValues*, get_value, LilvValue*, predicate); + LILV_PORT_WRAP1(LilvValues*, get_value_by_qname, const char*, predicate); + LILV_PORT_WRAP0(LilvValues*, get_properties) + LILV_PORT_WRAP1(bool, has_property, LilvValue*, property_uri); + LILV_PORT_WRAP1(bool, supports_event, LilvValue*, event_uri); + LILV_PORT_WRAP0(const LilvValue*, get_symbol); + LILV_PORT_WRAP0(LilvValue*, get_name); + LILV_PORT_WRAP0(const LilvValues*, get_classes); + LILV_PORT_WRAP1(bool, is_a, LilvValue*, port_class); + LILV_PORT_WRAP0(LilvScalePoints*, get_scale_points); // TODO: get_range (output parameters) - LilvPlugin parent; - LilvPort me; + const LilvPlugin* parent; + const LilvPort* me; }; struct Plugin { - inline Plugin(LilvPlugin c_obj) : me(c_obj) {} - LILV_WRAP_CONVERSION(LilvPlugin); + inline Plugin(const LilvPlugin* c_obj) : me(c_obj) {} + LILV_WRAP_CONVERSION(const LilvPlugin); LILV_WRAP0(bool, plugin, verify); LILV_WRAP0(Value, plugin, get_uri); @@ -214,7 +214,7 @@ struct Plugin { return Port(me, lilv_plugin_get_port_by_index(me, index)); } - inline Port get_port_by_symbol(LilvValue symbol) { + inline Port get_port_by_symbol(LilvValue* symbol) { return Port(me, lilv_plugin_get_port_by_symbol(me, symbol)); } @@ -225,13 +225,13 @@ struct Plugin { me, min_values, max_values, def_values); } - inline unsigned get_num_ports_of_class(LilvValue class_1, - LilvValue class_2) { + inline unsigned get_num_ports_of_class(LilvValue* class_1, + LilvValue* class_2) { // TODO: varargs return lilv_plugin_get_num_ports_of_class(me, class_1, class_2, NULL); } - LilvPlugin me; + const LilvPlugin* me; }; struct Instance { @@ -256,7 +256,7 @@ struct Instance { return lilv_instance_get_descriptor(me); } - LilvInstance me; + LilvInstance* me; }; } /* namespace Lilv */ |