diff options
Diffstat (limited to 'lilv')
| -rw-r--r-- | lilv/lilv.h | 216 | ||||
| -rw-r--r-- | lilv/lilvmm.hpp | 130 |
2 files changed, 173 insertions, 173 deletions
diff --git a/lilv/lilv.h b/lilv/lilv.h index 9631efe..0f3e998 100644 --- a/lilv/lilv.h +++ b/lilv/lilv.h @@ -62,7 +62,7 @@ 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 LilvNodeImpl LilvNode; /**< Typed Value. */ typedef struct LilvWorldImpl LilvWorld; /**< Lilv World. */ typedef struct LilvInstanceImpl LilvInstance; /**< Plugin instance. */ @@ -71,7 +71,7 @@ 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 void LilvNodes; /**< set<Value>. */ /** @defgroup lilv Lilv @@ -99,64 +99,64 @@ lilv_uri_to_path(const char* uri); /** Create a new URI value. - Returned value must be freed by caller with lilv_value_free. + Returned value must be freed by caller with lilv_node_free. */ LILV_API -LilvValue* +LilvNode* lilv_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. + Returned value must be freed by caller with lilv_node_free. */ LILV_API -LilvValue* +LilvNode* lilv_new_string(LilvWorld* world, const char* str); /** Create a new integer value. - Returned value must be freed by caller with lilv_value_free. + Returned value must be freed by caller with lilv_node_free. */ LILV_API -LilvValue* +LilvNode* lilv_new_int(LilvWorld* world, int val); /** Create a new floating point value. - Returned value must be freed by caller with lilv_value_free. + Returned value must be freed by caller with lilv_node_free. */ LILV_API -LilvValue* +LilvNode* lilv_new_float(LilvWorld* world, float val); /** Create a new boolean value. - Returned value must be freed by caller with lilv_value_free. + Returned value must be freed by caller with lilv_node_free. */ LILV_API -LilvValue* +LilvNode* lilv_new_bool(LilvWorld* world, bool val); /** - Free an LilvValue. + Free an LilvNode. */ LILV_API void -lilv_value_free(LilvValue* val); +lilv_node_free(LilvNode* val); /** - Duplicate an LilvValue. + Duplicate an LilvNode. */ LILV_API -LilvValue* -lilv_value_duplicate(const LilvValue* val); +LilvNode* +lilv_node_duplicate(const LilvNode* val); /** Return whether two values are equivalent. */ LILV_API bool -lilv_value_equals(const LilvValue* value, const LilvValue* other); +lilv_node_equals(const LilvNode* value, const LilvNode* other); /** Return this value as a Turtle/SPARQL token. @@ -173,39 +173,39 @@ lilv_value_equals(const LilvValue* value, const LilvValue* other); */ LILV_API char* -lilv_value_get_turtle_token(const LilvValue* value); +lilv_node_get_turtle_token(const LilvNode* value); /** Return whether the value is a URI (resource). */ LILV_API bool -lilv_value_is_uri(const LilvValue* value); +lilv_node_is_uri(const LilvNode* value); /** Return this value as a URI string, e.g. "http://example.org/foo". - Valid to call only if lilv_value_is_uri(@a value) returns true. + Valid to call only if lilv_node_is_uri(@a value) returns true. Returned value is owned by @a value and must not be freed by caller. */ LILV_API const char* -lilv_value_as_uri(const LilvValue* value); +lilv_node_as_uri(const LilvNode* value); /** Return whether the value is a blank node (resource with no URI). */ LILV_API bool -lilv_value_is_blank(const LilvValue* value); +lilv_node_is_blank(const LilvNode* value); /** Return this value as a blank node identifier, e.g. "genid03". - Valid to call only if lilv_value_is_blank(@a value) returns true. + Valid to call only if lilv_node_is_blank(@a value) returns true. Returned value is owned by @a value and must not be freed by caller. */ LILV_API const char* -lilv_value_as_blank(const LilvValue* value); +lilv_node_as_blank(const LilvNode* value); /** Return whether this value is a literal (i.e. not a URI). @@ -213,7 +213,7 @@ lilv_value_as_blank(const LilvValue* value); */ LILV_API bool -lilv_value_is_literal(const LilvValue* value); +lilv_node_is_literal(const LilvNode* value); /** Return whether this value is a string literal. @@ -221,60 +221,60 @@ lilv_value_is_literal(const LilvValue* value); */ LILV_API bool -lilv_value_is_string(const LilvValue* value); +lilv_node_is_string(const LilvNode* value); /** Return @a value as a string. */ LILV_API const char* -lilv_value_as_string(const LilvValue* value); +lilv_node_as_string(const LilvNode* value); /** Return whether this value is a decimal literal. */ LILV_API bool -lilv_value_is_float(const LilvValue* value); +lilv_node_is_float(const LilvNode* value); /** Return @a value as a float. - Valid to call only if lilv_value_is_float(@a value) or - lilv_value_is_int(@a value) returns true. + Valid to call only if lilv_node_is_float(@a value) or + lilv_node_is_int(@a value) returns true. */ LILV_API float -lilv_value_as_float(const LilvValue* value); +lilv_node_as_float(const LilvNode* value); /** Return whether this value is an integer literal. */ LILV_API bool -lilv_value_is_int(const LilvValue* value); +lilv_node_is_int(const LilvNode* value); /** Return @a value as an integer. - Valid to call only if lilv_value_is_int(@a value) returns true. + Valid to call only if lilv_node_is_int(@a value) returns true. */ LILV_API int -lilv_value_as_int(const LilvValue* value); +lilv_node_as_int(const LilvNode* value); /** Return whether this value is a boolean. */ LILV_API bool -lilv_value_is_bool(const LilvValue* value); +lilv_node_is_bool(const LilvNode* value); /** Return @a value as a bool. - Valid to call only if lilv_value_is_bool(@a value) returns true. + Valid to call only if lilv_node_is_bool(@a value) returns true. */ LILV_API bool -lilv_value_as_bool(const LilvValue* value); +lilv_node_as_bool(const LilvNode* value); /** @} @@ -284,7 +284,7 @@ lilv_value_as_bool(const LilvValue* value); <li>LilvPlugins (function prefix "lilv_plugins_")</li> <li>LilvPluginClasses (function prefix "lilv_plugin_classes_")</li> <li>LilvScalePoints (function prefix "lilv_scale_points_")</li> - <li>LilvValues (function prefix "lilv_values_")</li> + <li>LilvNodes (function prefix "lilv_nodes_")</li> <li>LilvUIs (function prefix "lilv_uis_")</li> </ul> @@ -348,7 +348,7 @@ lilv_plugin_classes_is_end(const LilvPluginClasses* collection, LilvIter* i); LILV_API const LilvPluginClass* lilv_plugin_classes_get_by_uri(const LilvPluginClasses* classes, - const LilvValue* uri); + const LilvNode* uri); /* ScalePoints */ @@ -411,44 +411,44 @@ lilv_uis_is_end(const LilvUIs* collection, LilvIter* i); LILV_API const LilvUI* lilv_uis_get_by_uri(const LilvUIs* uis, - const LilvValue* uri); + const LilvNode* uri); /* Values */ LILV_API void -lilv_values_free(LilvValues* collection); +lilv_nodes_free(LilvNodes* collection); LILV_API unsigned -lilv_values_size(const LilvValues* collection); +lilv_nodes_size(const LilvNodes* collection); LILV_API LilvIter* -lilv_values_begin(const LilvValues* collection); +lilv_nodes_begin(const LilvNodes* collection); LILV_API -const LilvValue* -lilv_values_get(const LilvValues* collection, LilvIter* i); +const LilvNode* +lilv_nodes_get(const LilvNodes* collection, LilvIter* i); LILV_API LilvIter* -lilv_values_next(const LilvValues* collection, LilvIter* i); +lilv_nodes_next(const LilvNodes* collection, LilvIter* i); LILV_API bool -lilv_values_is_end(const LilvValues* collection, LilvIter* i); +lilv_nodes_is_end(const LilvNodes* collection, LilvIter* i); LILV_API -LilvValue* -lilv_values_get_first(const LilvValues* collection); +LilvNode* +lilv_nodes_get_first(const LilvNodes* collection); /** Return whether @a values contains @a value. */ LILV_API bool -lilv_values_contains(const LilvValues* values, const LilvValue* value); +lilv_nodes_contains(const LilvNodes* values, const LilvNode* value); /* Plugins */ @@ -481,7 +481,7 @@ lilv_plugins_is_end(const LilvPlugins* collection, LilvIter* i); LILV_API const LilvPlugin* lilv_plugins_get_by_uri(const LilvPlugins* plugins, - const LilvValue* uri); + const LilvNode* uri); /** @} @@ -527,7 +527,7 @@ LILV_API void lilv_world_set_option(LilvWorld* world, const char* uri, - const LilvValue* value); + const LilvNode* value); /** Destroy the world, mwahaha. @@ -569,7 +569,7 @@ lilv_world_load_all(LilvWorld* world); LILV_API void lilv_world_load_bundle(LilvWorld* world, - LilvValue* bundle_uri); + LilvNode* bundle_uri); /** Get the parent of all other plugin classes, lv2:Plugin. @@ -636,7 +636,7 @@ lilv_plugin_verify(const LilvPlugin* plugin); @return A shared URI value which must not be modified or freed. */ LILV_API -const LilvValue* +const LilvNode* lilv_plugin_get_uri(const LilvPlugin* plugin); /** @@ -651,7 +651,7 @@ lilv_plugin_get_uri(const LilvPlugin* plugin); @return a shared string which must not be modified or freed. */ LILV_API -const LilvValue* +const LilvNode* lilv_plugin_get_bundle_uri(const LilvPlugin* plugin); /** @@ -663,7 +663,7 @@ lilv_plugin_get_bundle_uri(const LilvPlugin* plugin); which is shared and must not be modified or freed. */ LILV_API -const LilvValues* +const LilvNodes* lilv_plugin_get_data_uris(const LilvPlugin* plugin); /** @@ -673,7 +673,7 @@ lilv_plugin_get_data_uris(const LilvPlugin* plugin); @return a shared string which must not be modified or freed. */ LILV_API -const LilvValue* +const LilvNode* lilv_plugin_get_library_uri(const LilvPlugin* plugin); /** @@ -684,7 +684,7 @@ lilv_plugin_get_library_uri(const LilvPlugin* plugin); Returned value must be freed by the caller. */ LILV_API -LilvValue* +LilvNode* lilv_plugin_get_name(const LilvPlugin* plugin); /** @@ -703,13 +703,13 @@ lilv_plugin_get_class(const LilvPlugin* plugin); <code><plugin-uri> predicate ?object</code> May return NULL if the property was not found, or if object(s) is not - sensibly represented as an LilvValues (e.g. blank nodes). - Return value must be freed by caller with lilv_values_free. + sensibly represented as an LilvNodes (e.g. blank nodes). + Return value must be freed by caller with lilv_nodes_free. */ LILV_API -LilvValues* +LilvNodes* lilv_plugin_get_value(const LilvPlugin* p, - const LilvValue* predicate); + const LilvNode* predicate); /** Get a value associated with some subject in a plugin's data files. @@ -723,14 +723,14 @@ lilv_plugin_get_value(const LilvPlugin* p, (if information about it is contained in the plugin's data files). May return NULL if the property was not found, or if object is not - sensibly represented as an LilvValues (e.g. blank nodes). - Return value must be freed by caller with lilv_values_free. + sensibly represented as an LilvNodes (e.g. blank nodes). + Return value must be freed by caller with lilv_nodes_free. */ LILV_API -LilvValues* +LilvNodes* lilv_plugin_get_value_for_subject(const LilvPlugin* p, - const LilvValue* subject_uri, - const LilvValue* predicate_uri); + const LilvNode* subject_uri, + const LilvNode* predicate_uri); /** Return whether a feature is supported by a plugin. @@ -740,7 +740,7 @@ lilv_plugin_get_value_for_subject(const LilvPlugin* p, LILV_API bool lilv_plugin_has_feature(const LilvPlugin* p, - const LilvValue* feature_uri); + const LilvNode* feature_uri); /** Get the LV2 Features supported (required or optionally) by a plugin. @@ -750,10 +750,10 @@ lilv_plugin_has_feature(const LilvPlugin* p, probably shouldn't be used by normal hosts. Using lilv_plugin_get_optional_features and lilv_plugin_get_required_features separately is best in most cases. - Returned value must be freed by caller with lilv_values_free. + Returned value must be freed by caller with lilv_nodes_free. */ LILV_API -LilvValues* +LilvNodes* lilv_plugin_get_supported_features(const LilvPlugin* p); /** @@ -765,10 +765,10 @@ lilv_plugin_get_supported_features(const LilvPlugin* p); (along with data, if necessary, as defined by the feature specification) or plugin instantiation will fail. - Return value must be freed by caller with lilv_values_free. + Return value must be freed by caller with lilv_nodes_free. */ LILV_API -LilvValues* +LilvNodes* lilv_plugin_get_required_features(const LilvPlugin* p); /** @@ -777,10 +777,10 @@ lilv_plugin_get_required_features(const LilvPlugin* p); MUST operate (at least somewhat) if they are instantiated without being passed optional features. - Return value must be freed by caller with lilv_values_free. + Return value must be freed by caller with lilv_nodes_free. */ LILV_API -LilvValues* +LilvNodes* lilv_plugin_get_optional_features(const LilvPlugin* p); /** @@ -820,7 +820,7 @@ lilv_plugin_get_port_ranges_float(const LilvPlugin* p, LILV_API uint32_t lilv_plugin_get_num_ports_of_class(const LilvPlugin* p, - const LilvValue* class_1, ...); + const LilvNode* class_1, ...); /** Return whether or not the plugin introduces (and reports) latency. @@ -860,7 +860,7 @@ lilv_plugin_get_port_by_index(const LilvPlugin* plugin, LILV_API const LilvPort* lilv_plugin_get_port_by_symbol(const LilvPlugin* plugin, - const LilvValue* symbol); + const LilvNode* symbol); /** Get the full name of the plugin's author. @@ -868,7 +868,7 @@ lilv_plugin_get_port_by_symbol(const LilvPlugin* plugin, Returned value must be freed by caller. */ LILV_API -LilvValue* +LilvNode* lilv_plugin_get_author_name(const LilvPlugin* plugin); /** @@ -877,7 +877,7 @@ lilv_plugin_get_author_name(const LilvPlugin* plugin); Returned value must be freed by caller. */ LILV_API -LilvValue* +LilvNode* lilv_plugin_get_author_email(const LilvPlugin* plugin); /** @@ -886,7 +886,7 @@ lilv_plugin_get_author_email(const LilvPlugin* plugin); Returned value must be freed by caller. */ LILV_API -LilvValue* +LilvNode* lilv_plugin_get_author_homepage(const LilvPlugin* plugin); /** @@ -909,16 +909,16 @@ lilv_plugin_is_replaced(const LilvPlugin* plugin); Port analog of lilv_plugin_get_value. */ LILV_API -LilvValues* +LilvNodes* lilv_port_get_value(const LilvPlugin* plugin, const LilvPort* port, - const LilvValue* predicate); + const LilvNode* predicate); /** Return the LV2 port properties of a port. */ LILV_API -LilvValues* +LilvNodes* lilv_port_get_properties(const LilvPlugin* plugin, const LilvPort* port); @@ -929,7 +929,7 @@ LILV_API bool lilv_port_has_property(const LilvPlugin* p, const LilvPort* port, - const LilvValue* property_uri); + const LilvNode* property_uri); /** Return whether a port is an event port and supports a certain event type. @@ -938,7 +938,7 @@ LILV_API bool lilv_port_supports_event(const LilvPlugin* p, const LilvPort* port, - const LilvValue* event_uri); + const LilvNode* event_uri); /** Get the symbol of a port. @@ -946,7 +946,7 @@ lilv_port_supports_event(const LilvPlugin* p, Returned value is owned by @a port and must not be freed. */ LILV_API -const LilvValue* +const LilvNode* lilv_port_get_symbol(const LilvPlugin* plugin, const LilvPort* port); @@ -957,7 +957,7 @@ lilv_port_get_symbol(const LilvPlugin* plugin, the caller. */ LILV_API -LilvValue* +LilvNode* lilv_port_get_name(const LilvPlugin* plugin, const LilvPort* port); @@ -969,14 +969,14 @@ lilv_port_get_name(const LilvPlugin* plugin, Returned value is shared and must not be destroyed by caller. */ LILV_API -const LilvValues* +const LilvNodes* lilv_port_get_classes(const LilvPlugin* plugin, const LilvPort* port); /** Determine if a port is of a given class (input, output, audio, etc). For convenience/performance/extensibility reasons, hosts are expected to - create an LilvValue for each port class they "care about". Well-known type + create an LilvNode for each port class they "care about". Well-known type URI strings are defined (e.g. LILV_PORT_CLASS_INPUT) for convenience, but this function is designed so that Lilv is usable with any port types without requiring explicit support in Lilv. @@ -985,23 +985,23 @@ LILV_API bool lilv_port_is_a(const LilvPlugin* plugin, const LilvPort* port, - const LilvValue* port_class); + const LilvNode* port_class); /** Get the default, minimum, and maximum values of a port. @a def, @a min, and @a max are outputs, pass pointers to uninitialized - LilvValue* variables. These will be set to point at new values (which must - be freed by the caller using lilv_value_free), or NULL if the value does not + LilvNode* variables. These will be set to point at new values (which must + be freed by the caller using lilv_node_free), or NULL if the value does not exist. */ LILV_API void lilv_port_get_range(const LilvPlugin* plugin, const LilvPort* port, - LilvValue** deflt, - LilvValue** min, - LilvValue** max); + LilvNode** deflt, + LilvNode** min, + LilvNode** max); /** Get the scale points (enumeration values) of a port. @@ -1026,7 +1026,7 @@ lilv_port_get_scale_points(const LilvPlugin* plugin, Returned value is owned by @a point and must not be freed. */ LILV_API -const LilvValue* +const LilvNode* lilv_scale_point_get_label(const LilvScalePoint* point); /** @@ -1034,7 +1034,7 @@ lilv_scale_point_get_label(const LilvScalePoint* point); Returned value is owned by @a point and must not be freed. */ LILV_API -const LilvValue* +const LilvNode* lilv_scale_point_get_value(const LilvScalePoint* point); /** @@ -1049,7 +1049,7 @@ lilv_scale_point_get_value(const LilvScalePoint* point); Returned value may be NULL, if class has no parent. */ LILV_API -const LilvValue* +const LilvNode* lilv_plugin_class_get_parent_uri(const LilvPluginClass* plugin_class); /** @@ -1057,7 +1057,7 @@ lilv_plugin_class_get_parent_uri(const LilvPluginClass* plugin_class); Returned value is owned by @a plugin_class and must not be freed by caller. */ LILV_API -const LilvValue* +const LilvNode* lilv_plugin_class_get_uri(const LilvPluginClass* plugin_class); /** @@ -1065,7 +1065,7 @@ lilv_plugin_class_get_uri(const LilvPluginClass* plugin_class); Returned value is owned by @a plugin_class and must not be freed by caller. */ LILV_API -const LilvValue* +const LilvNode* lilv_plugin_class_get_label(const LilvPluginClass* plugin_class); /** @@ -1252,7 +1252,7 @@ lilv_plugin_get_uis(const LilvPlugin* plugin); @return a shared value which must not be modified or freed. */ LILV_API -const LilvValue* +const LilvNode* lilv_ui_get_uri(const LilvUI* ui); /** @@ -1264,7 +1264,7 @@ lilv_ui_get_uri(const LilvUI* ui); UI type, avoding the need to use this function (and type specific logic). */ LILV_API -const LilvValues* +const LilvNodes* lilv_ui_get_classes(const LilvUI* ui); /** @@ -1274,7 +1274,7 @@ lilv_ui_get_classes(const LilvUI* ui); */ LILV_API bool -lilv_ui_is_a(const LilvUI* ui, const LilvValue* class_uri); +lilv_ui_is_a(const LilvUI* ui, const LilvNode* class_uri); /** Function to determine whether a UI type is supported. @@ -1291,15 +1291,15 @@ typedef unsigned (*LilvUISupportedFunc)(const char* container_type_uri, @param supported_func User provided supported predicate. @param container_type The widget type to host the UI within. @param ui_type (Output) If non-NULL, set to the native type of the UI - which the caller must free with lilv_value_free. + which the caller must free with lilv_node_free. @return The embedding quality level returned by @c supported_func. */ LILV_API unsigned lilv_ui_is_supported(const LilvUI* ui, LilvUISupportedFunc supported_func, - const LilvValue* container_type, - const LilvValue** ui_type); + const LilvNode* container_type, + const LilvNode** ui_type); /** Get the URI for a Plugin UI's bundle. @@ -1307,7 +1307,7 @@ lilv_ui_is_supported(const LilvUI* ui, @return a shared value which must not be modified or freed. */ LILV_API -const LilvValue* +const LilvNode* lilv_ui_get_bundle_uri(const LilvUI* ui); /** @@ -1316,7 +1316,7 @@ lilv_ui_get_bundle_uri(const LilvUI* ui); @return a shared value which must not be modified or freed. */ LILV_API -const LilvValue* +const LilvNode* lilv_ui_get_binary_uri(const LilvUI* ui); /** diff --git a/lilv/lilvmm.hpp b/lilv/lilvmm.hpp index b2fe293..9a256b0 100644 --- a/lilv/lilvmm.hpp +++ b/lilv/lilvmm.hpp @@ -48,44 +48,44 @@ const char* uri_to_path(const char* uri) { return lilv_uri_to_path(uri); } #define LILV_WRAP_CONVERSION(CT) #endif -struct Value { - inline Value(const LilvValue* value) : me(lilv_value_duplicate(value)) {} - inline Value(const Value& copy) : me(lilv_value_duplicate(copy.me)) {} +struct Node { + inline Node(const LilvNode* node) : me(lilv_node_duplicate(node)) {} + inline Node(const Node& copy) : me(lilv_node_duplicate(copy.me)) {} - inline ~Value() { lilv_value_free(me); } + inline ~Node() { lilv_node_free(me); } - inline bool equals(const Value& other) const { - return lilv_value_equals(me, other.me); + inline bool equals(const Node& other) const { + return lilv_node_equals(me, other.me); } - inline bool operator==(const Value& other) const { return equals(other); } - - LILV_WRAP_CONVERSION(LilvValue); - - LILV_WRAP0(char*, value, get_turtle_token); - LILV_WRAP0(bool, value, is_uri); - LILV_WRAP0(const char*, value, as_uri); - LILV_WRAP0(bool, value, is_blank); - LILV_WRAP0(const char*, value, as_blank); - LILV_WRAP0(bool, value, is_literal); - LILV_WRAP0(bool, value, is_string); - LILV_WRAP0(const char*, value, as_string); - LILV_WRAP0(bool, value, is_float); - LILV_WRAP0(float, value, as_float); - LILV_WRAP0(bool, value, is_int); - LILV_WRAP0(int, value, as_int); - LILV_WRAP0(bool, value, is_bool); - LILV_WRAP0(bool, value, as_bool); - - LilvValue* me; + inline bool operator==(const Node& other) const { return equals(other); } + + LILV_WRAP_CONVERSION(LilvNode); + + LILV_WRAP0(char*, node, get_turtle_token); + LILV_WRAP0(bool, node, is_uri); + LILV_WRAP0(const char*, node, as_uri); + LILV_WRAP0(bool, node, is_blank); + LILV_WRAP0(const char*, node, as_blank); + LILV_WRAP0(bool, node, is_literal); + LILV_WRAP0(bool, node, is_string); + LILV_WRAP0(const char*, node, as_string); + LILV_WRAP0(bool, node, is_float); + LILV_WRAP0(float, node, as_float); + LILV_WRAP0(bool, node, is_int); + LILV_WRAP0(int, node, as_int); + LILV_WRAP0(bool, node, is_bool); + LILV_WRAP0(bool, node, as_bool); + + LilvNode* me; }; struct ScalePoint { inline ScalePoint(const LilvScalePoint* c_obj) : me(c_obj) {} LILV_WRAP_CONVERSION(const LilvScalePoint); - LILV_WRAP0(const LilvValue*, scale_point, get_label); - LILV_WRAP0(const LilvValue*, scale_point, get_value); + LILV_WRAP0(const LilvNode*, scale_point, get_label); + LILV_WRAP0(const LilvNode*, scale_point, get_value); const LilvScalePoint* me; }; @@ -94,9 +94,9 @@ struct PluginClass { 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); + LILV_WRAP0(Node, plugin_class, get_parent_uri); + LILV_WRAP0(Node, plugin_class, get_uri); + LILV_WRAP0(Node, plugin_class, get_label); inline LilvPluginClasses* get_children() { return lilv_plugin_class_get_children(me); @@ -116,7 +116,7 @@ struct PluginClass { LILV_WRAP_COLL(PluginClasses, PluginClass, plugin_classes); LILV_WRAP_COLL(ScalePoints, ScalePoint, scale_points); -LILV_WRAP_COLL(Values, Value, values); +LILV_WRAP_COLL(Nodes, Node, nodes); struct Plugins { inline Plugins(const LilvPlugins* c_obj) : me(c_obj) {} @@ -129,26 +129,26 @@ struct World { inline World() : me(lilv_world_new()) {} inline ~World() { /*lilv_world_free(me);*/ } - inline LilvValue* new_uri(const char* uri) { + inline LilvNode* new_uri(const char* uri) { return lilv_new_uri(me, uri); } - inline LilvValue* new_string(const char* str) { + inline LilvNode* new_string(const char* str) { return lilv_new_string(me, str); } - inline LilvValue* new_int(int val) { + inline LilvNode* new_int(int val) { return lilv_new_int(me, val); } - inline LilvValue* new_float(float val) { + inline LilvNode* new_float(float val) { return lilv_new_float(me, val); } - inline LilvValue* new_bool(bool val) { + inline LilvNode* new_bool(bool val) { return lilv_new_bool(me, val); } - LILV_WRAP2_VOID(world, set_option, const char*, uri, LilvValue*, value); + LILV_WRAP2_VOID(world, set_option, const char*, uri, LilvNode*, value); LILV_WRAP0_VOID(world, free); LILV_WRAP0_VOID(world, load_all); - LILV_WRAP1_VOID(world, load_bundle, LilvValue*, bundle_uri); + LILV_WRAP1_VOID(world, load_bundle, LilvNode*, 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); @@ -167,14 +167,14 @@ 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_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_WRAP1(LilvNodes*, get_value, LilvNode*, predicate); + LILV_PORT_WRAP0(LilvNodes*, get_properties) + LILV_PORT_WRAP1(bool, has_property, LilvNode*, property_uri); + LILV_PORT_WRAP1(bool, supports_event, LilvNode*, event_uri); + LILV_PORT_WRAP0(const LilvNode*, get_symbol); + LILV_PORT_WRAP0(LilvNode*, get_name); + LILV_PORT_WRAP0(const LilvNodes*, get_classes); + LILV_PORT_WRAP1(bool, is_a, LilvNode*, port_class); LILV_PORT_WRAP0(LilvScalePoints*, get_scale_points); // TODO: get_range (output parameters) @@ -188,31 +188,31 @@ struct Plugin { LILV_WRAP_CONVERSION(const LilvPlugin); LILV_WRAP0(bool, plugin, verify); - LILV_WRAP0(Value, plugin, get_uri); - LILV_WRAP0(Value, plugin, get_bundle_uri); - LILV_WRAP0(Values, plugin, get_data_uris); - LILV_WRAP0(Value, plugin, get_library_uri); - LILV_WRAP0(Value, plugin, get_name); + LILV_WRAP0(Node, plugin, get_uri); + LILV_WRAP0(Node, plugin, get_bundle_uri); + LILV_WRAP0(Nodes, plugin, get_data_uris); + LILV_WRAP0(Node, plugin, get_library_uri); + LILV_WRAP0(Node, plugin, get_name); LILV_WRAP0(PluginClass, plugin, get_class); - LILV_WRAP1(Values, plugin, get_value, Value, pred); - LILV_WRAP2(Values, plugin, get_value_for_subject, Value, subject, - Value, predicate); - LILV_WRAP1(bool, plugin, has_feature, Value, feature_uri); - LILV_WRAP0(Values, plugin, get_supported_features); - LILV_WRAP0(Values, plugin, get_required_features); - LILV_WRAP0(Values, plugin, get_optional_features); + LILV_WRAP1(Nodes, plugin, get_value, Node, pred); + LILV_WRAP2(Nodes, plugin, get_value_for_subject, Node, subject, + Node, predicate); + LILV_WRAP1(bool, plugin, has_feature, Node, feature_uri); + LILV_WRAP0(Nodes, plugin, get_supported_features); + LILV_WRAP0(Nodes, plugin, get_required_features); + LILV_WRAP0(Nodes, plugin, get_optional_features); LILV_WRAP0(unsigned, plugin, get_num_ports); LILV_WRAP0(bool, plugin, has_latency); LILV_WRAP0(unsigned, plugin, get_latency_port_index); - LILV_WRAP0(Value, plugin, get_author_name); - LILV_WRAP0(Value, plugin, get_author_email); - LILV_WRAP0(Value, plugin, get_author_homepage); + LILV_WRAP0(Node, plugin, get_author_name); + LILV_WRAP0(Node, plugin, get_author_email); + LILV_WRAP0(Node, plugin, get_author_homepage); inline Port get_port_by_index(unsigned index) { 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(LilvNode* symbol) { return Port(me, lilv_plugin_get_port_by_symbol(me, symbol)); } @@ -223,8 +223,8 @@ 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(LilvNode* class_1, + LilvNode* class_2) { // TODO: varargs return lilv_plugin_get_num_ports_of_class(me, class_1, class_2, NULL); } |