Format all code with clang-format

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 */