Wrap rest of API (with a few troublesome exceptions).

git-svn-id: http://svn.drobilla.net/lad/trunk/slv2@2942 a436a847-0d15-0410-975c-d299462d15a1

5 files changed, 229 insertions, 100 deletions

diff --git a/slv2/slv2.h b/slv2/slv2.h
index 45fe597..c761873 100644
--- a/slv2/slv2.h
+++ b/slv2/slv2.h
@@ -79,6 +79,14 @@ typedef void* SLV2Values;         /**< array<Value>. */
  * @{
  */
 
+/** Convert a file URI string to a local path string.
+ * For example, "file://foo/bar/baz.ttl" returns "/foo/bar/baz.ttl".
+ * Return value is shared and must not be deleted by caller.
+ * @return @a uri converted to a path, or NULL on failure (URI is not local).
+ */
+SLV2_API
+const char* slv2_uri_to_path(const char* uri);
+
 /** Create a new URI value.
  * Returned value must be freed by caller with slv2_value_free.
  */
@@ -235,14 +243,6 @@ SLV2_API
 bool
 slv2_value_as_bool(SLV2Value value);
 
-/** Convert a file URI to a local path.
- * For example, "file://foo/bar/baz.ttl" returns "/foo/bar/baz.ttl".
- * Return value is shared and must not be deleted by caller.
- * @return @a uri converted to a path, or NULL on failure (URI is not local).
- */
-SLV2_API
-const char* slv2_uri_to_path(const char* uri);
-
 /** @} */
 /** @name Collections
  * SLV2 has several collection types for holding various types of value:
@@ -471,6 +471,13 @@ SLV2Plugins
 slv2_world_get_plugins_by_filter(SLV2World world,
                                  bool (*include)(SLV2Plugin));
 
+/** Return the plugin with the given @a uri, or NULL if not found.
+ */
+SLV2_API
+SLV2Plugin
+slv2_world_get_plugin_by_uri_string(SLV2World   world,
+                                    const char* uri);
+
 /** @} */
 /** @name Plugin
  * @{
@@ -764,7 +771,7 @@ SLV2_API
 SLV2Values
 slv2_port_get_value_by_qname(SLV2Plugin  plugin,
                              SLV2Port    port,
-                             const char* property_uri);
+                             const char* predicate);
 
 /** Return the LV2 port properties of a port.
  */
diff --git a/slv2/slv2mm.hpp b/slv2/slv2mm.hpp
index f41c2f8..f82925f 100644
--- a/slv2/slv2mm.hpp
+++ b/slv2/slv2mm.hpp
@@ -25,12 +25,29 @@ namespace SLV2 {
 
 const char* uri_to_path(const char* uri) { return slv2_uri_to_path(uri); }
 
-class Value {
-public:
+#define SLV2_WRAP0(RT, prefix, name) \
+	inline RT name () { return slv2_ ## prefix ## _ ## name (me); }
+
+#define SLV2_WRAP0_VOID(prefix, name) \
+	inline void name () { slv2_ ## prefix ## _ ## name (me); }
+
+#define SLV2_WRAP1(RT, prefix, name, T1, a1) \
+	inline RT name (T1 a1) { return slv2_ ## prefix ## _ ## name (me, a1); }
+
+#define SLV2_WRAP1_VOID(prefix, name, T1, a1) \
+	inline void name (T1 a1) { slv2_ ## prefix ## _ ## name (me, a1); }
+
+#define SLV2_WRAP2(RT, prefix, name, T1, a1, T2, a2) \
+	inline RT name (T1 a1, T2 a2) { return slv2_ ## prefix ## _ ## name (me, a1, a2); }
+
+#define SLV2_WRAP2_VOID(prefix, name, T1, a1, T2, a2) \
+	inline void name (T1 a1, T2 a2) { slv2_ ## prefix ## _ ## name (me, a1, a2); }
+
+struct Value {
 	inline Value(SLV2Value value)   : me(value) {}
 	inline Value(const Value& copy) : me(slv2_value_duplicate(copy.me)) {}
 
-	inline ~Value() { slv2_value_free(me); }
+	inline ~Value() { /*slv2_value_free(me);*/ }
 
 	inline bool equals(const Value& other) const {
 		return slv2_value_equals(me, other.me);
@@ -40,118 +57,200 @@ public:
 
 	inline operator SLV2Value() const { return me; }
 
-#define VAL_WRAP0(RetType, name) \
-	inline RetType name () { return slv2_value_ ## name (me); }
-
-	VAL_WRAP0(char*,       get_turtle_token);
-	VAL_WRAP0(bool,        is_uri);
-	VAL_WRAP0(const char*, as_uri);
-	VAL_WRAP0(bool,        is_blank);
-	VAL_WRAP0(const char*, as_blank);
-	VAL_WRAP0(bool,        is_literal);
-	VAL_WRAP0(bool,        is_string);
-	VAL_WRAP0(const char*, as_string);
-	VAL_WRAP0(bool,        is_float);
-	VAL_WRAP0(float,       as_float);
-	VAL_WRAP0(bool,        is_int);
-	VAL_WRAP0(int,         as_int);
-	VAL_WRAP0(bool,        is_bool);
-	VAL_WRAP0(bool,        as_bool);
+	SLV2_WRAP0(char*,       value, get_turtle_token);
+	SLV2_WRAP0(bool,        value, is_uri);
+	SLV2_WRAP0(const char*, value, as_uri);
+	SLV2_WRAP0(bool,        value, is_blank);
+	SLV2_WRAP0(const char*, value, as_blank);
+	SLV2_WRAP0(bool,        value, is_literal);
+	SLV2_WRAP0(bool,        value, is_string);
+	SLV2_WRAP0(const char*, value, as_string);
+	SLV2_WRAP0(bool,        value, is_float);
+	SLV2_WRAP0(float,       value, as_float);
+	SLV2_WRAP0(bool,        value, is_int);
+	SLV2_WRAP0(int,         value, as_int);
+	SLV2_WRAP0(bool,        value, is_bool);
+	SLV2_WRAP0(bool,        value, as_bool);
 
 	SLV2Value me;
 };
 
-class Plugins {
-public:
-	inline Plugins(SLV2Plugins c_obj) : me(c_obj) {}
+struct ScalePoint {
+	inline ScalePoint(SLV2ScalePoint c_obj) : me(c_obj) {}
+	inline operator SLV2ScalePoint() const { return me; }
 
+	SLV2_WRAP0(SLV2Value, scale_point, get_label);
+	SLV2_WRAP0(SLV2Value, scale_point, get_value);
+
+	SLV2ScalePoint me;
+};
+
+struct PluginClass {
+	inline PluginClass(SLV2PluginClass c_obj) : me(c_obj) {}
+	inline operator SLV2PluginClass() const { return me; }
+
+	SLV2_WRAP0(Value, plugin_class, get_parent_uri);
+	SLV2_WRAP0(Value, plugin_class, get_uri);
+	SLV2_WRAP0(Value, plugin_class, get_label);
+
+	inline SLV2PluginClasses get_children() {
+		return slv2_plugin_class_get_children(me);
+	}
+
+	SLV2PluginClass me;
+};
+
+#define SLV2_WRAP_COLL(CT, ET, prefix) \
+	struct CT { \
+		inline CT(SLV2 ## CT c_obj) : me(c_obj) {} \
+		inline operator SLV2 ## CT () const { return me; } \
+		SLV2_WRAP0(unsigned, prefix, size); \
+		SLV2_WRAP1(ET, prefix, get_at, unsigned, index); \
+		SLV2 ## CT me; \
+	}; \
+
+SLV2_WRAP_COLL(PluginClasses, PluginClass, plugin_classes);
+SLV2_WRAP_COLL(ScalePoints, ScalePoint, scale_points);
+SLV2_WRAP_COLL(Values, Value, values);
+
+struct Plugins {
+	inline Plugins(SLV2Plugins c_obj) : me(c_obj) {}
 	inline operator SLV2Plugins() const { return me; }
 
 	SLV2Plugins me;
 };
 
-class World {
-public:
+struct World {
 	inline World() : me(slv2_world_new()) {}
-
 	inline ~World() { /*slv2_world_free(me);*/ }
 
-#define WORLD_WRAP_VOID0(name) \
-	inline void name () { slv2_world_ ## name (me); }
-
-#define WORLD_WRAP0(RetType, name) \
-	inline RetType name () { return slv2_world_ ## name (me); }
-
-#define WORLD_WRAP1(RetType, name, T1, a1) \
-	inline RetType name (T1 a1) { return slv2_world_ ## name (me, a1); }
-
-#define WORLD_WRAP2(RetType, name, T1, a1, T2, a2) \
-	inline RetType name (T1 a1, T2 a2) { return slv2_world_ ## name (me, a1, a2); }
-	
-	WORLD_WRAP2(void, set_option, const char*, uri, SLV2Value, value);
-	WORLD_WRAP_VOID0(free);
-	WORLD_WRAP_VOID0(load_all);
-	WORLD_WRAP1(void, load_bundle, SLV2Value, bundle_uri);
-	WORLD_WRAP0(SLV2PluginClass, get_plugin_class);
-	WORLD_WRAP0(SLV2PluginClasses, get_plugin_classes);
-	WORLD_WRAP0(Plugins, get_all_plugins);
+	inline SLV2Value new_uri(const char* uri) {
+		return slv2_value_new_uri(me, uri);
+	}
+	inline SLV2Value new_string(const char* str) {
+		return slv2_value_new_string(me, str);
+	}
+	inline SLV2Value new_int(int val) {
+		return slv2_value_new_int(me, val);
+	}
+	inline SLV2Value new_float(float val) {
+		return slv2_value_new_float(me, val);
+	}
+	inline SLV2Value new_bool(bool val) {
+		return slv2_value_new_bool(me, val);
+	}
+
+	SLV2_WRAP2_VOID(world, set_option, const char*, uri, SLV2Value, value);
+	SLV2_WRAP0_VOID(world, free);
+	SLV2_WRAP0_VOID(world, load_all);
+	SLV2_WRAP1_VOID(world, load_bundle, SLV2Value, bundle_uri);
+	SLV2_WRAP0(SLV2PluginClass, world, get_plugin_class);
+	SLV2_WRAP0(SLV2PluginClasses, world, get_plugin_classes);
+	SLV2_WRAP0(Plugins, world, get_all_plugins);
+	//SLV2_WRAP1(Plugin, world, get_plugin_by_uri_string, const char*, uri);
 	// TODO: get_plugins_by_filter (takes a function parameter)
 
 	SLV2World me;
 };
 
-class Port {
-public:
-	inline Port(SLV2Port c_obj) : me(c_obj) {}
-
+struct Port {
+	inline Port(SLV2Plugin p, SLV2Port c_obj) : parent(p), me(c_obj) {}
 	inline operator SLV2Port() const { return me; }
 
-	SLV2Port me;
+#define SLV2_PORT_WRAP0(RT, name) \
+	inline RT name () { return slv2_port_ ## name (parent, me); }
+
+#define SLV2_PORT_WRAP1(RT, name, T1, a1) \
+	inline RT name (T1 a1) { return slv2_port_ ## name (parent, me, a1); }
+
+	SLV2_PORT_WRAP1(SLV2Values, get_value, SLV2Value, predicate);
+	SLV2_PORT_WRAP1(SLV2Values, get_value_by_qname, const char*, predicate);
+	SLV2_PORT_WRAP0(SLV2Values, get_properties)
+	SLV2_PORT_WRAP1(bool, has_property, SLV2Value, property_uri);
+	SLV2_PORT_WRAP1(bool, supports_event, SLV2Value, event_uri);
+	SLV2_PORT_WRAP0(SLV2Value,  get_symbol);
+	SLV2_PORT_WRAP0(SLV2Value,  get_name);
+	SLV2_PORT_WRAP0(SLV2Values, get_classes);
+	SLV2_PORT_WRAP1(bool, is_a, SLV2Value, port_class);
+	SLV2_PORT_WRAP0(SLV2ScalePoints, get_scale_points);
+
+	// TODO: get_range (output parameters)
+
+	SLV2Plugin parent;
+	SLV2Port   me;
 };
 
-class Plugin {
-public:
+struct Plugin {
 	inline Plugin(SLV2Plugin c_obj) : me(c_obj) {}
-
 	inline operator SLV2Plugin() const { return me; }
 
-#define PLUGIN_WRAP0(RetType, name) \
-	inline RetType name () { return slv2_plugin_ ## name (me); }
-
-#define PLUGIN_WRAP1(RetType, name, T1, a1)	  \
-	inline RetType name (T1 a1) { return slv2_plugin_ ## name (me, a1); }
-
-#define PLUGIN_WRAP2(RetType, name, T1, a1, T2, a2)	  \
-	inline RetType name (T1 a1, T2 a2) { return slv2_plugin_ ## name (me, a1, a2); }
-
-	PLUGIN_WRAP0(bool,  verify);
-	PLUGIN_WRAP0(Value, get_uri);
-	PLUGIN_WRAP0(Value, get_bundle_uri);
-	//PLUGIN_WRAP0(Values, get_data_uris);
-	PLUGIN_WRAP0(Value, get_library_uri);
-	PLUGIN_WRAP0(Value, get_name);
-	//PLUGIN_WRAP0(PluginClass, get_class);
-	//PLUGIN_WRAP1(Values, get_value, Value, predicate);
-	//PLUGIN_WRAP1(Values, get_value_by_qname, const char*, predicate);
-	//PLUGIN_WRAP2(Values, get_value_for_subject, Value, subject, Value, predicate);
-	PLUGIN_WRAP1(bool, has_feature, Value, feature_uri);
-	//PLUGIN_WRAP0(Values, get_supported_features);
-	//PLUGIN_WRAP0(Values, get_required_features);
-	//PLUGIN_WRAP0(Values, get_optional_features);
-	PLUGIN_WRAP0(uint32_t, get_num_ports);
-	// slv2_plugin_get_port_ranges_float
-	// slv2_plugin_get_num_ports_of_class
-	PLUGIN_WRAP0(bool, has_latency);
-	PLUGIN_WRAP0(uint32_t, get_latency_port_index);
-	PLUGIN_WRAP1(Port, get_port_by_index, uint32_t, index);
-	PLUGIN_WRAP1(Port, get_port_by_symbol, SLV2Value, symbol);
-	PLUGIN_WRAP0(Value, get_author_name);
-	PLUGIN_WRAP0(Value, get_author_email);
-	PLUGIN_WRAP0(Value, get_author_homepage);
+	SLV2_WRAP0(bool,        plugin, verify);
+	SLV2_WRAP0(Value,       plugin, get_uri);
+	SLV2_WRAP0(Value,       plugin, get_bundle_uri);
+	SLV2_WRAP0(Values,      plugin, get_data_uris);
+	SLV2_WRAP0(Value,       plugin, get_library_uri);
+	SLV2_WRAP0(Value,       plugin, get_name);
+	SLV2_WRAP0(PluginClass, plugin, get_class);
+	SLV2_WRAP1(Values,      plugin, get_value, Value, pred);
+	SLV2_WRAP1(Values,      plugin, get_value_by_qname, const char*, predicate);
+	SLV2_WRAP2(Values,      plugin, get_value_for_subject, Value, subject,
+	                                                       Value, predicate);
+	SLV2_WRAP1(bool,        plugin, has_feature, Value, feature_uri);
+	SLV2_WRAP0(Values,      plugin, get_supported_features);
+	SLV2_WRAP0(Values,      plugin, get_required_features);
+	SLV2_WRAP0(Values,      plugin, get_optional_features);
+	SLV2_WRAP0(uint32_t,    plugin, get_num_ports);
+	SLV2_WRAP0(bool,        plugin, has_latency);
+	SLV2_WRAP0(uint32_t,    plugin, get_latency_port_index);
+	SLV2_WRAP0(Value,       plugin, get_author_name);
+	SLV2_WRAP0(Value,       plugin, get_author_email);
+	SLV2_WRAP0(Value,       plugin, get_author_homepage);
+
+	inline Port get_port_by_index(uint32_t index) {
+		return Port(me, slv2_plugin_get_port_by_index(me, index));
+	}
+
+	inline Port get_port_by_symbol(SLV2Value symbol) {
+		return Port(me, slv2_plugin_get_port_by_symbol(me, symbol));
+	}
+
+	inline void get_port_ranges_float(float* min_values,
+	                                  float* max_values,
+	                                  float* def_values) {
+		return slv2_plugin_get_port_ranges_float(
+			me, min_values, max_values, def_values);
+	}
+
+	// TODO: slv2_plugin_get_num_ports_of_class (varargs)
 
 	SLV2Plugin me;
 };
-	
+
+struct Instance {
+	inline Instance(Plugin plugin, double sample_rate) {
+		// TODO: features
+		me = slv2_plugin_instantiate(plugin, sample_rate, NULL);
+	}
+
+	inline operator SLV2Instance() const { return me; }
+
+	SLV2_WRAP2_VOID(instance, connect_port,
+	                uint32_t, port_index,
+	                void*,    data_location);
+
+	SLV2_WRAP0_VOID(instance, activate);
+	SLV2_WRAP1_VOID(instance, run, uint32_t, sample_count);
+	SLV2_WRAP0_VOID(instance, deactivate);
+
+	// TODO: get_extension_data
+
+	inline const LV2_Descriptor* get_descriptor() {
+		return slv2_instance_get_descriptor(me);
+	}
+
+	SLV2Instance me;
+};
+
 } /* namespace SLV2 */
 
 #endif /* SLV2_SLV2MM_HPP__ */
diff --git a/src/world.c b/src/world.c
index f1c02bb..d24bad6 100644
--- a/src/world.c
+++ b/src/world.c
@@ -689,3 +689,14 @@ slv2_world_get_plugins_by_filter(SLV2World world, bool (*include)(SLV2Plugin))
 
 	return result;
 }
+
+SLV2_API
+SLV2Plugin
+slv2_world_get_plugin_by_uri_string(SLV2World   world,
+                                    const char* uri)
+{
+	SLV2Value  uri_val = slv2_value_new_uri(world, uri);
+	SLV2Plugin plugin  = slv2_plugins_get_by_uri(world->plugins, uri_val);
+	slv2_value_free(uri_val);
+	return plugin;
+}
diff --git a/swig/python/lv2_list.py b/swig/python/lv2_list.py
index 0cd6a1b..4b09e86 100755
--- a/swig/python/lv2_list.py
+++ b/swig/python/lv2_list.py
@@ -5,8 +5,8 @@ import slv2
 world = slv2.World()
 world.load_all()
 
-plugins = world.get_all_plugins()
-
-for i in plugins:
+for i in world.get_all_plugins():
 	print(i.get_uri())
 
+
+
diff --git a/swig/slv2.i b/swig/slv2.i
index cb5279a..bff9f70 100644
--- a/swig/slv2.i
+++ b/swig/slv2.i
@@ -3,9 +3,12 @@
 #include "slv2/slv2.h"
 #include "slv2/slv2mm.hpp"
 %}
+
 %include "slv2/slv2.h"
 %include "slv2/slv2mm.hpp"
+
 namespace SLV2 {
+
 %extend Plugins {
 %pythoncode %{
 	def __iter__(self):
@@ -27,10 +30,19 @@ namespace SLV2 {
 		return Iterator(self)
 %}
 };
+
 %extend Value {
 %pythoncode %{
 	def __str__(self):
 		return slv2_value_get_turtle_token(self.me)
 %}
 };
-}
+
+%extend World {
+%pythoncode %{
+	def get_plugin(self, uri_str):
+		return Plugin(slv2_world_get_plugin_by_uri_string(self.me, uri_str))
+%}
+};
+
+} /* namespace SLV2 */