summaryrefslogtreecommitdiffstats
path: root/include/lilv/lilvmm.hpp
diff options
context:
space:
mode:
Diffstat (limited to 'include/lilv/lilvmm.hpp')
-rw-r--r--include/lilv/lilvmm.hpp574
1 files changed, 308 insertions, 266 deletions
diff --git a/include/lilv/lilvmm.hpp b/include/lilv/lilvmm.hpp
index 011c9c8..33a0dcd 100644
--- a/include/lilv/lilvmm.hpp
+++ b/include/lilv/lilvmm.hpp
@@ -26,11 +26,11 @@
namespace Lilv {
#if defined(__clang__)
-# pragma clang diagnostic push
-# pragma clang diagnostic ignored "-Wdeprecated-declarations"
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wdeprecated-declarations"
#elif defined(__GNUC__) && __GNUC__ > 4
-# pragma GCC diagnostic push
-# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
struct Instance;
@@ -49,348 +49,390 @@ struct World;
LILV_DEPRECATED
static inline const char*
-uri_to_path(const char* uri) {
- return lilv_uri_to_path(uri);
+uri_to_path(const char* uri)
+{
+ return lilv_uri_to_path(uri);
}
#if defined(__clang__)
-# pragma clang diagnostic pop
+# pragma clang diagnostic pop
#elif defined(__GNUC__) && __GNUC__ > 4
-# pragma GCC diagnostic pop
+# pragma GCC diagnostic pop
#endif
#define LILV_WRAP0(RT, prefix, name) \
- inline RT name() { return lilv_ ## prefix ## _ ## name (me); }
+ inline RT name() { return lilv_##prefix##_##name(me); }
#define LILV_WRAP0_VOID(prefix, name) \
- inline void name() { lilv_ ## prefix ## _ ## name(me); }
+ inline void name() { lilv_##prefix##_##name(me); }
#define LILV_WRAP1(RT, prefix, name, T1, a1) \
- inline RT name(T1 a1) { return lilv_ ## prefix ## _ ## name (me, a1); }
+ inline RT name(T1 a1) { return lilv_##prefix##_##name(me, a1); }
#define LILV_WRAP1_VOID(prefix, name, T1, a1) \
- inline void name(T1 a1) { lilv_ ## prefix ## _ ## name(me, a1); }
+ inline void name(T1 a1) { lilv_##prefix##_##name(me, a1); }
#define LILV_WRAP2(RT, prefix, name, T1, a1, T2, a2) \
- inline RT name(T1 a1, T2 a2) { \
- return lilv_ ## prefix ## _ ## name(me, a1, a2); \
- }
+ inline RT name(T1 a1, T2 a2) { return lilv_##prefix##_##name(me, a1, a2); }
#define LILV_WRAP3(RT, prefix, name, T1, a1, T2, a2, T3, a3) \
- inline RT name(T1 a1, T2 a2, T3 a3) { \
- return lilv_ ## prefix ## _ ## name(me, a1, a2, a3); \
- }
+ inline RT name(T1 a1, T2 a2, T3 a3) \
+ { \
+ return lilv_##prefix##_##name(me, a1, a2, a3); \
+ }
#define LILV_WRAP2_VOID(prefix, name, T1, a1, T2, a2) \
- inline void name(T1 a1, T2 a2) { lilv_ ## prefix ## _ ## name(me, a1, a2); }
+ inline void name(T1 a1, T2 a2) { lilv_##prefix##_##name(me, a1, a2); }
#ifndef SWIG
-#define LILV_WRAP_CONVERSION(CT) \
- inline operator CT*() const { return me; }
+# define LILV_WRAP_CONVERSION(CT) \
+ inline operator CT*() const { return me; }
#else
-#define LILV_WRAP_CONVERSION(CT)
+# define LILV_WRAP_CONVERSION(CT)
#endif
struct Node {
- inline Node(const LilvNode* node) : me(lilv_node_duplicate(node)) {}
-
- inline Node(const Node& copy) : me(lilv_node_duplicate(copy.me)) {}
-
- inline Node& operator=(const Node& rhs)
- {
- if (&rhs != this) {
- lilv_node_free(me);
- me = lilv_node_duplicate(rhs.me);
- }
- return *this;
- }
-
- inline Node(Node&& other) noexcept : me(other.me) { other.me = nullptr; }
-
- inline Node& operator=(Node&& rhs) noexcept
- {
- if (&rhs != this) {
- me = rhs.me;
- rhs.me = nullptr;
- }
- return *this;
- }
-
- inline ~Node() { lilv_node_free(me); }
-
- inline bool equals(const Node& other) const {
- return lilv_node_equals(me, other.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;
+ inline Node(const LilvNode* node)
+ : me(lilv_node_duplicate(node))
+ {}
+
+ inline Node(const Node& copy)
+ : me(lilv_node_duplicate(copy.me))
+ {}
+
+ inline Node& operator=(const Node& rhs)
+ {
+ if (&rhs != this) {
+ lilv_node_free(me);
+ me = lilv_node_duplicate(rhs.me);
+ }
+ return *this;
+ }
+
+ inline Node(Node&& other) noexcept
+ : me(other.me)
+ {
+ other.me = nullptr;
+ }
+
+ inline Node& operator=(Node&& rhs) noexcept
+ {
+ if (&rhs != this) {
+ me = rhs.me;
+ rhs.me = nullptr;
+ }
+ return *this;
+ }
+
+ inline ~Node() { lilv_node_free(me); }
+
+ inline bool equals(const Node& other) const
+ {
+ return lilv_node_equals(me, other.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);
+ inline ScalePoint(const LilvScalePoint* c_obj)
+ : me(c_obj)
+ {}
- LILV_WRAP0(const LilvNode*, scale_point, get_label);
- LILV_WRAP0(const LilvNode*, scale_point, get_value);
+ LILV_WRAP_CONVERSION(const LilvScalePoint);
- const LilvScalePoint* me;
+ LILV_WRAP0(const LilvNode*, scale_point, get_label);
+ LILV_WRAP0(const LilvNode*, scale_point, get_value);
+
+ const LilvScalePoint* me;
};
struct PluginClass {
- inline PluginClass(const LilvPluginClass* c_obj) : me(c_obj) {}
- LILV_WRAP_CONVERSION(const LilvPluginClass);
+ inline PluginClass(const LilvPluginClass* c_obj)
+ : me(c_obj)
+ {}
+
+ LILV_WRAP_CONVERSION(const LilvPluginClass);
- LILV_WRAP0(Node, plugin_class, get_parent_uri);
- LILV_WRAP0(Node, plugin_class, get_uri);
- LILV_WRAP0(Node, plugin_class, get_label);
- LILV_WRAP0(LilvPluginClasses*, plugin_class, get_children);
+ LILV_WRAP0(Node, plugin_class, get_parent_uri);
+ LILV_WRAP0(Node, plugin_class, get_uri);
+ LILV_WRAP0(Node, plugin_class, get_label);
+ LILV_WRAP0(LilvPluginClasses*, plugin_class, get_children);
- const LilvPluginClass* me;
+ const LilvPluginClass* me;
};
-#define LILV_WRAP_COLL(CT, ET, prefix) \
- 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_WRAP0(LilvIter*, prefix, begin); \
- LILV_WRAP1(LilvIter*, prefix, next, LilvIter*, i); \
- LILV_WRAP1(bool, prefix, is_end, LilvIter*, i); \
- const Lilv ## CT* me; \
+#define LILV_WRAP_COLL(CT, ET, prefix) \
+ 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_WRAP0(LilvIter*, prefix, begin); \
+ LILV_WRAP1(LilvIter*, prefix, next, LilvIter*, i); \
+ LILV_WRAP1(bool, prefix, is_end, LilvIter*, i); \
+ const Lilv##CT* me;
struct PluginClasses {
- LILV_WRAP_COLL(PluginClasses, PluginClass, plugin_classes);
- LILV_WRAP1(PluginClass, plugin_classes,
- get_by_uri, const LilvNode*, uri);
+ LILV_WRAP_COLL(PluginClasses, PluginClass, plugin_classes);
+ LILV_WRAP1(PluginClass, plugin_classes, get_by_uri, const LilvNode*, uri);
};
struct ScalePoints {
- LILV_WRAP_COLL(ScalePoints, ScalePoint, scale_points);
+ LILV_WRAP_COLL(ScalePoints, ScalePoint, scale_points);
};
struct Nodes {
- LILV_WRAP_COLL(Nodes, Node, nodes);
- LILV_WRAP1(bool, nodes, contains, const Node&, node);
- LILV_WRAP0(Node, nodes, get_first);
+ LILV_WRAP_COLL(Nodes, Node, nodes);
+ LILV_WRAP1(bool, nodes, contains, const Node&, node);
+ LILV_WRAP0(Node, nodes, get_first);
};
struct UI {
- inline UI(const LilvUI* c_obj) : me(c_obj) {}
- LILV_WRAP_CONVERSION(const LilvUI);
-
- LILV_WRAP0(const LilvNode*, ui, get_uri);
- LILV_WRAP0(const LilvNode*, ui, get_bundle_uri);
- LILV_WRAP0(const LilvNode*, ui, get_binary_uri);
- LILV_WRAP0(const LilvNodes*, ui, get_classes);
- /*LILV_WRAP3(bool, ui, is_supported,
- LilvUISupportedFunc, supported_func,
- const LilvNode*, container_type,
- const LilvNode**, ui_type);*/
- LILV_WRAP1(bool, ui, is_a, const LilvNode*, class_uri);
-
- const LilvUI* me;
+ inline UI(const LilvUI* c_obj)
+ : me(c_obj)
+ {}
+
+ LILV_WRAP_CONVERSION(const LilvUI);
+
+ LILV_WRAP0(const LilvNode*, ui, get_uri);
+ LILV_WRAP0(const LilvNode*, ui, get_bundle_uri);
+ LILV_WRAP0(const LilvNode*, ui, get_binary_uri);
+ LILV_WRAP0(const LilvNodes*, ui, get_classes);
+ /*LILV_WRAP3(bool, ui, is_supported,
+ LilvUISupportedFunc, supported_func,
+ const LilvNode*, container_type,
+ const LilvNode**, ui_type);*/
+ LILV_WRAP1(bool, ui, is_a, const LilvNode*, class_uri);
+
+ const LilvUI* me;
};
struct UIs {
- LILV_WRAP_COLL(UIs, UI, uis);
+ LILV_WRAP_COLL(UIs, UI, uis);
};
struct Port {
- inline Port(const LilvPlugin* p, const LilvPort* c_obj)
- : parent(p), me(c_obj)
- {}
+ inline Port(const LilvPlugin* p, const LilvPort* c_obj)
+ : parent(p)
+ , me(c_obj)
+ {}
- LILV_WRAP_CONVERSION(const LilvPort);
+ LILV_WRAP_CONVERSION(const LilvPort);
#define LILV_PORT_WRAP0(RT, name) \
- inline RT name () { return lilv_port_ ## name (parent, me); }
+ inline RT name() { return lilv_port_##name(parent, me); }
#define LILV_PORT_WRAP1(RT, name, T1, a1) \
- inline RT name (T1 a1) { return lilv_port_ ## name (parent, me, a1); }
-
- 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)
-
- const LilvPlugin* parent;
- const LilvPort* me;
+ inline RT name(T1 a1) { return lilv_port_##name(parent, me, a1); }
+
+ 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)
+
+ const LilvPlugin* parent;
+ const LilvPort* me;
};
struct Plugin {
- inline Plugin(const LilvPlugin* c_obj) : me(c_obj) {}
- LILV_WRAP_CONVERSION(const LilvPlugin);
-
- LILV_WRAP0(bool, plugin, verify);
- 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(Nodes, plugin, get_value, const Node&, pred);
- LILV_WRAP1(bool, plugin, has_feature, const 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(Node, plugin, get_author_name);
- LILV_WRAP0(Node, plugin, get_author_email);
- LILV_WRAP0(Node, plugin, get_author_homepage);
- LILV_WRAP0(bool, plugin, is_replaced);
- LILV_WRAP0(Nodes, plugin, get_extension_data);
- LILV_WRAP0(UIs, plugin, get_uis);
- LILV_WRAP1(Nodes, plugin, get_related, const Node&, type);
-
- inline Port get_port_by_index(unsigned index) const {
- return Port(me, lilv_plugin_get_port_by_index(me, index));
- }
-
- inline Port get_port_by_symbol(LilvNode* symbol) const {
- return Port(me, lilv_plugin_get_port_by_symbol(me, symbol));
- }
-
- inline void get_port_ranges_float(float* min_values,
- float* max_values,
- float* def_values) const {
- return lilv_plugin_get_port_ranges_float(
- me, min_values, max_values, def_values);
- }
-
- inline unsigned get_num_ports_of_class(LilvNode* class_1, ...) const {
- va_list args;
- va_start(args, class_1);
-
- const uint32_t count = lilv_plugin_get_num_ports_of_class_va(
- me, class_1, args);
-
- va_end(args);
- return count;
- }
-
- const LilvPlugin* me;
+ inline Plugin(const LilvPlugin* c_obj)
+ : me(c_obj)
+ {}
+
+ LILV_WRAP_CONVERSION(const LilvPlugin);
+
+ LILV_WRAP0(bool, plugin, verify);
+ 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(Nodes, plugin, get_value, const Node&, pred);
+ LILV_WRAP1(bool, plugin, has_feature, const 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(Node, plugin, get_author_name);
+ LILV_WRAP0(Node, plugin, get_author_email);
+ LILV_WRAP0(Node, plugin, get_author_homepage);
+ LILV_WRAP0(bool, plugin, is_replaced);
+ LILV_WRAP0(Nodes, plugin, get_extension_data);
+ LILV_WRAP0(UIs, plugin, get_uis);
+ LILV_WRAP1(Nodes, plugin, get_related, const Node&, type);
+
+ inline Port get_port_by_index(unsigned index) const
+ {
+ return Port(me, lilv_plugin_get_port_by_index(me, index));
+ }
+
+ inline Port get_port_by_symbol(LilvNode* symbol) const
+ {
+ return Port(me, lilv_plugin_get_port_by_symbol(me, symbol));
+ }
+
+ inline void get_port_ranges_float(float* min_values,
+ float* max_values,
+ float* def_values) const
+ {
+ return lilv_plugin_get_port_ranges_float(
+ me, min_values, max_values, def_values);
+ }
+
+ inline unsigned get_num_ports_of_class(LilvNode* class_1, ...) const
+ {
+ va_list args;
+ va_start(args, class_1);
+
+ const uint32_t count =
+ lilv_plugin_get_num_ports_of_class_va(me, class_1, args);
+
+ va_end(args);
+ return count;
+ }
+
+ const LilvPlugin* me;
};
struct Plugins {
- LILV_WRAP_COLL(Plugins, Plugin, plugins);
- LILV_WRAP1(Plugin, plugins, get_by_uri, const LilvNode*, uri);
+ LILV_WRAP_COLL(Plugins, Plugin, plugins);
+ LILV_WRAP1(Plugin, plugins, get_by_uri, const LilvNode*, uri);
};
struct Instance {
- inline Instance(LilvInstance* instance) : me(instance) {}
+ inline Instance(LilvInstance* instance)
+ : me(instance)
+ {}
+
+ LILV_DEPRECATED
+ inline Instance(Plugin plugin, double sample_rate)
+ {
+ me = lilv_plugin_instantiate(plugin, sample_rate, nullptr);
+ }
+
+ LILV_DEPRECATED inline Instance(Plugin plugin,
+ double sample_rate,
+ LV2_Feature* const* features)
+ {
+ me = lilv_plugin_instantiate(plugin, sample_rate, features);
+ }
+
+ static inline Instance* create(Plugin plugin,
+ double sample_rate,
+ LV2_Feature* const* features)
+ {
+ LilvInstance* me = lilv_plugin_instantiate(plugin, sample_rate, features);
+
+ return me ? new Instance(me) : nullptr;
+ }
+
+ LILV_WRAP_CONVERSION(LilvInstance);
+
+ LILV_WRAP2_VOID(instance,
+ connect_port,
+ unsigned,
+ port_index,
+ void*,
+ data_location);
+
+ LILV_WRAP0_VOID(instance, activate);
+ LILV_WRAP1_VOID(instance, run, unsigned, sample_count);
+ LILV_WRAP0_VOID(instance, deactivate);
+
+ inline const void* get_extension_data(const char* uri) const
+ {
+ return lilv_instance_get_extension_data(me, uri);
+ }
+
+ inline const LV2_Descriptor* get_descriptor() const
+ {
+ return lilv_instance_get_descriptor(me);
+ }
+
+ inline LV2_Handle get_handle() const { return lilv_instance_get_handle(me); }
+
+ LilvInstance* me;
+};
- LILV_DEPRECATED
- inline Instance(Plugin plugin, double sample_rate) {
- me = lilv_plugin_instantiate(plugin, sample_rate, nullptr);
- }
+struct World {
+ inline World()
+ : me(lilv_world_new())
+ {}
- LILV_DEPRECATED inline Instance(Plugin plugin,
- double sample_rate,
- LV2_Feature* const* features) {
- me = lilv_plugin_instantiate(plugin, sample_rate, features);
- }
+ inline ~World() { lilv_world_free(me); }
- static inline Instance* create(Plugin plugin,
- double sample_rate,
- LV2_Feature* const* features) {
- LilvInstance* me = lilv_plugin_instantiate(
- plugin, sample_rate, features);
+ World(const World&) = delete;
+ World& operator=(const World&) = delete;
- return me ? new Instance(me) : nullptr;
- }
+ World(World&&) = delete;
+ World& operator=(World&&) = delete;
- LILV_WRAP_CONVERSION(LilvInstance);
+ inline LilvNode* new_uri(const char* uri) const
+ {
+ return lilv_new_uri(me, uri);
+ }
- LILV_WRAP2_VOID(instance, connect_port,
- unsigned, port_index,
- void*, data_location);
+ inline LilvNode* new_string(const char* str) const
+ {
+ return lilv_new_string(me, str);
+ }
- LILV_WRAP0_VOID(instance, activate);
- LILV_WRAP1_VOID(instance, run, unsigned, sample_count);
- LILV_WRAP0_VOID(instance, deactivate);
+ inline LilvNode* new_int(int val) const { return lilv_new_int(me, val); }
- inline const void* get_extension_data(const char* uri) const {
- return lilv_instance_get_extension_data(me, uri);
- }
+ inline LilvNode* new_float(float val) const
+ {
+ return lilv_new_float(me, val);
+ }
- inline const LV2_Descriptor* get_descriptor() const {
- return lilv_instance_get_descriptor(me);
- }
+ inline LilvNode* new_bool(bool val) const { return lilv_new_bool(me, val); }
- inline LV2_Handle get_handle() const {
- return lilv_instance_get_handle(me);
- }
+ inline Nodes find_nodes(const LilvNode* subject,
+ const LilvNode* predicate,
+ const LilvNode* object) const
+ {
+ return lilv_world_find_nodes(me, subject, predicate, object);
+ }
- LilvInstance* me;
-};
+ LILV_WRAP2_VOID(world, set_option, const char*, uri, LilvNode*, value);
+ LILV_WRAP0_VOID(world, load_all);
+ 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);
+ LILV_WRAP1(int, world, load_resource, const LilvNode*, resource);
-struct World {
- inline World() : me(lilv_world_new()) {}
- inline ~World() { lilv_world_free(me); }
-
- World(const World&) = delete;
- World& operator=(const World&) = delete;
-
- World(World&&) = delete;
- World& operator=(World&&) = delete;
-
- inline LilvNode* new_uri(const char* uri) const {
- return lilv_new_uri(me, uri);
- }
- inline LilvNode* new_string(const char* str) const {
- return lilv_new_string(me, str);
- }
- inline LilvNode* new_int(int val) const {
- return lilv_new_int(me, val);
- }
- inline LilvNode* new_float(float val) const {
- return lilv_new_float(me, val);
- }
- inline LilvNode* new_bool(bool val) const {
- return lilv_new_bool(me, val);
- }
- inline Nodes find_nodes(const LilvNode* subject,
- const LilvNode* predicate,
- const LilvNode* object) const {
- return lilv_world_find_nodes(me, subject, predicate, object);
- }
-
- LILV_WRAP2_VOID(world, set_option, const char*, uri, LilvNode*, value);
- LILV_WRAP0_VOID(world, load_all);
- 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);
- LILV_WRAP1(int, world, load_resource, const LilvNode*, resource);
-
- LilvWorld* me;
+ LilvWorld* me;
};
} /* namespace Lilv */