Rename slv2 to lilv.

API breakage was proving too much of a hassle, and would be even further of a
mess after release and packaging.  Best to make a clean break now, and fix
installation to support parallel installs and prevent this kind of problem in
the future.


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

1 files changed, 264 insertions, 0 deletions

diff --git a/lilv/lilvmm.hpp b/lilv/lilvmm.hpp
new file mode 100644
index 0000000..7f25d33
--- /dev/null
+++ b/lilv/lilvmm.hpp
@@ -0,0 +1,264 @@
+/*
+  Copyright 2007-2011 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#ifndef LILV_LILVMM_HPP
+#define LILV_LILVMM_HPP
+
+#include "lilv/lilv.h"
+
+namespace Lilv {
+
+const char* uri_to_path(const char* uri) { return lilv_uri_to_path(uri); }
+
+#define LILV_WRAP0(RT, prefix, name) \
+	inline RT name () { return lilv_ ## prefix ## _ ## name (me); }
+
+#define LILV_WRAP0_VOID(prefix, name) \
+	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); }
+
+#define LILV_WRAP1_VOID(prefix, name, T1, 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); }
+
+#define LILV_WRAP2_VOID(prefix, name, T1, a1, T2, 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; }
+#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() { /*lilv_value_free(me);*/ }
+
+	inline bool equals(const Value& other) const {
+		return lilv_value_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;
+};
+
+struct ScalePoint {
+	inline ScalePoint(LilvScalePoint c_obj) : me(c_obj) {}
+	LILV_WRAP_CONVERSION(LilvScalePoint);
+
+	LILV_WRAP0(LilvValue, scale_point, get_label);
+	LILV_WRAP0(LilvValue, scale_point, get_value);
+
+	LilvScalePoint me;
+};
+
+struct PluginClass {
+	inline PluginClass(LilvPluginClass c_obj) : me(c_obj) {}
+	LILV_WRAP_CONVERSION(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() {
+		return lilv_plugin_class_get_children(me);
+	}
+
+	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); \
+		LILV_WRAP0(unsigned, prefix, size); \
+		LILV_WRAP1(ET, prefix, get, LilvIter, i); \
+		Lilv ## CT me; \
+	}; \
+
+LILV_WRAP_COLL(PluginClasses, PluginClass, plugin_classes);
+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);
+
+	LilvPlugins me;
+};
+
+struct World {
+	inline World() : me(lilv_world_new()) {}
+	inline ~World() { /*lilv_world_free(me);*/ }
+
+	inline LilvValue new_uri(const char* uri) {
+		return lilv_value_new_uri(me, uri);
+	}
+	inline LilvValue new_string(const char* str) {
+		return lilv_value_new_string(me, str);
+	}
+	inline LilvValue new_int(int val) {
+		return lilv_value_new_int(me, val);
+	}
+	inline LilvValue new_float(float val) {
+		return lilv_value_new_float(me, 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_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_WRAP0(Plugins, world, get_all_plugins);
+	//LILV_WRAP1(Plugin, world, get_plugin_by_uri_string, const char*, uri);
+
+	LilvWorld me;
+};
+
+struct Port {
+	inline Port(LilvPlugin p, LilvPort c_obj) : parent(p), me(c_obj) {}
+	LILV_WRAP_CONVERSION(LilvPort);
+
+#define LILV_PORT_WRAP0(RT, name) \
+	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(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);
+
+	// TODO: get_range (output parameters)
+
+	LilvPlugin parent;
+	LilvPort   me;
+};
+
+struct Plugin {
+	inline Plugin(LilvPlugin c_obj) : me(c_obj) {}
+	LILV_WRAP_CONVERSION(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(PluginClass, plugin, get_class);
+	LILV_WRAP1(Values,      plugin, get_value, Value, pred);
+	LILV_WRAP1(Values,      plugin, get_value_by_qname, const char*, predicate);
+	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_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);
+
+	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) {
+		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) {
+		return lilv_plugin_get_port_ranges_float(
+			me, min_values, max_values, def_values);
+	}
+
+	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;
+};
+
+struct Instance {
+	inline Instance(Plugin plugin, double sample_rate) {
+		// TODO: features
+		me = lilv_plugin_instantiate(plugin, sample_rate, NULL);
+	}
+
+	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);
+
+	// TODO: get_extension_data
+
+	inline const LV2_Descriptor* get_descriptor() {
+		return lilv_instance_get_descriptor(me);
+	}
+
+	LilvInstance me;
+};
+
+} /* namespace Lilv */
+
+#endif /* LILV_LILVMM_HPP */