python-lilv 0.16.0~dfsg0-1 / usr / share / pyshared / lilv.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.0.10
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.



from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_lilv', [dirname(__file__)])
        except ImportError:
            import _lilv
            return _lilv
        if fp is not None:
            try:
                _mod = imp.load_module('_lilv', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _lilv = swig_import_helper()
    del swig_import_helper
else:
    import _lilv
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self,class_type,name,value):
    return _swig_setattr_nondynamic(self,class_type,name,value,0)

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

def _swig_repr(self):
    try: strthis = "proxy of " + self.this.__repr__()
    except: strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


LILV_NS_DOAP = _lilv.LILV_NS_DOAP
LILV_NS_FOAF = _lilv.LILV_NS_FOAF
LILV_NS_LILV = _lilv.LILV_NS_LILV
LILV_NS_LV2 = _lilv.LILV_NS_LV2
LILV_NS_OWL = _lilv.LILV_NS_OWL
LILV_NS_RDF = _lilv.LILV_NS_RDF
LILV_NS_RDFS = _lilv.LILV_NS_RDFS
LILV_NS_XSD = _lilv.LILV_NS_XSD
LILV_URI_AUDIO_PORT = _lilv.LILV_URI_AUDIO_PORT
LILV_URI_CONTROL_PORT = _lilv.LILV_URI_CONTROL_PORT
LILV_URI_EVENT_PORT = _lilv.LILV_URI_EVENT_PORT
LILV_URI_INPUT_PORT = _lilv.LILV_URI_INPUT_PORT
LILV_URI_MIDI_EVENT = _lilv.LILV_URI_MIDI_EVENT
LILV_URI_OUTPUT_PORT = _lilv.LILV_URI_OUTPUT_PORT
LILV_URI_PORT = _lilv.LILV_URI_PORT

def lilv_uri_to_path(*args):
  """lilv_uri_to_path(char const * uri) -> char const *"""
  return _lilv.lilv_uri_to_path(*args)

def lilv_new_uri(*args):
  """lilv_new_uri(LilvWorld * world, char const * uri) -> LilvNode *"""
  return _lilv.lilv_new_uri(*args)

def lilv_new_string(*args):
  """lilv_new_string(LilvWorld * world, char const * str) -> LilvNode *"""
  return _lilv.lilv_new_string(*args)

def lilv_new_int(*args):
  """lilv_new_int(LilvWorld * world, int val) -> LilvNode *"""
  return _lilv.lilv_new_int(*args)

def lilv_new_float(*args):
  """lilv_new_float(LilvWorld * world, float val) -> LilvNode *"""
  return _lilv.lilv_new_float(*args)

def lilv_new_bool(*args):
  """lilv_new_bool(LilvWorld * world, bool val) -> LilvNode *"""
  return _lilv.lilv_new_bool(*args)

def lilv_node_free(*args):
  """lilv_node_free(LilvNode * val)"""
  return _lilv.lilv_node_free(*args)

def lilv_node_duplicate(*args):
  """lilv_node_duplicate(LilvNode const * val) -> LilvNode *"""
  return _lilv.lilv_node_duplicate(*args)

def lilv_node_equals(*args):
  """lilv_node_equals(LilvNode const * value, LilvNode const * other) -> bool"""
  return _lilv.lilv_node_equals(*args)

def lilv_node_get_turtle_token(*args):
  """lilv_node_get_turtle_token(LilvNode const * value) -> char *"""
  return _lilv.lilv_node_get_turtle_token(*args)

def lilv_node_is_uri(*args):
  """lilv_node_is_uri(LilvNode const * value) -> bool"""
  return _lilv.lilv_node_is_uri(*args)

def lilv_node_as_uri(*args):
  """lilv_node_as_uri(LilvNode const * value) -> char const *"""
  return _lilv.lilv_node_as_uri(*args)

def lilv_node_is_blank(*args):
  """lilv_node_is_blank(LilvNode const * value) -> bool"""
  return _lilv.lilv_node_is_blank(*args)

def lilv_node_as_blank(*args):
  """lilv_node_as_blank(LilvNode const * value) -> char const *"""
  return _lilv.lilv_node_as_blank(*args)

def lilv_node_is_literal(*args):
  """lilv_node_is_literal(LilvNode const * value) -> bool"""
  return _lilv.lilv_node_is_literal(*args)

def lilv_node_is_string(*args):
  """lilv_node_is_string(LilvNode const * value) -> bool"""
  return _lilv.lilv_node_is_string(*args)

def lilv_node_as_string(*args):
  """lilv_node_as_string(LilvNode const * value) -> char const *"""
  return _lilv.lilv_node_as_string(*args)

def lilv_node_is_float(*args):
  """lilv_node_is_float(LilvNode const * value) -> bool"""
  return _lilv.lilv_node_is_float(*args)

def lilv_node_as_float(*args):
  """lilv_node_as_float(LilvNode const * value) -> float"""
  return _lilv.lilv_node_as_float(*args)

def lilv_node_is_int(*args):
  """lilv_node_is_int(LilvNode const * value) -> bool"""
  return _lilv.lilv_node_is_int(*args)

def lilv_node_as_int(*args):
  """lilv_node_as_int(LilvNode const * value) -> int"""
  return _lilv.lilv_node_as_int(*args)

def lilv_node_is_bool(*args):
  """lilv_node_is_bool(LilvNode const * value) -> bool"""
  return _lilv.lilv_node_is_bool(*args)

def lilv_node_as_bool(*args):
  """lilv_node_as_bool(LilvNode const * value) -> bool"""
  return _lilv.lilv_node_as_bool(*args)

def lilv_plugin_classes_free(*args):
  """lilv_plugin_classes_free(LilvPluginClasses * collection)"""
  return _lilv.lilv_plugin_classes_free(*args)

def lilv_plugin_classes_size(*args):
  """lilv_plugin_classes_size(LilvPluginClasses const * collection) -> unsigned int"""
  return _lilv.lilv_plugin_classes_size(*args)

def lilv_plugin_classes_begin(*args):
  """lilv_plugin_classes_begin(LilvPluginClasses const * collection) -> LilvIter *"""
  return _lilv.lilv_plugin_classes_begin(*args)

def lilv_plugin_classes_get(*args):
  """lilv_plugin_classes_get(LilvPluginClasses const * collection, LilvIter * i) -> LilvPluginClass const *"""
  return _lilv.lilv_plugin_classes_get(*args)

def lilv_plugin_classes_next(*args):
  """lilv_plugin_classes_next(LilvPluginClasses const * collection, LilvIter * i) -> LilvIter *"""
  return _lilv.lilv_plugin_classes_next(*args)

def lilv_plugin_classes_is_end(*args):
  """lilv_plugin_classes_is_end(LilvPluginClasses const * collection, LilvIter * i) -> bool"""
  return _lilv.lilv_plugin_classes_is_end(*args)

def lilv_plugin_classes_get_by_uri(*args):
  """lilv_plugin_classes_get_by_uri(LilvPluginClasses const * classes, LilvNode const * uri) -> LilvPluginClass const *"""
  return _lilv.lilv_plugin_classes_get_by_uri(*args)

def lilv_scale_points_free(*args):
  """lilv_scale_points_free(LilvScalePoints * collection)"""
  return _lilv.lilv_scale_points_free(*args)

def lilv_scale_points_size(*args):
  """lilv_scale_points_size(LilvScalePoints const * collection) -> unsigned int"""
  return _lilv.lilv_scale_points_size(*args)

def lilv_scale_points_begin(*args):
  """lilv_scale_points_begin(LilvScalePoints const * collection) -> LilvIter *"""
  return _lilv.lilv_scale_points_begin(*args)

def lilv_scale_points_get(*args):
  """lilv_scale_points_get(LilvScalePoints const * collection, LilvIter * i) -> LilvScalePoint const *"""
  return _lilv.lilv_scale_points_get(*args)

def lilv_scale_points_next(*args):
  """lilv_scale_points_next(LilvScalePoints const * collection, LilvIter * i) -> LilvIter *"""
  return _lilv.lilv_scale_points_next(*args)

def lilv_scale_points_is_end(*args):
  """lilv_scale_points_is_end(LilvScalePoints const * collection, LilvIter * i) -> bool"""
  return _lilv.lilv_scale_points_is_end(*args)

def lilv_uis_free(*args):
  """lilv_uis_free(LilvUIs * collection)"""
  return _lilv.lilv_uis_free(*args)

def lilv_uis_size(*args):
  """lilv_uis_size(LilvUIs const * collection) -> unsigned int"""
  return _lilv.lilv_uis_size(*args)

def lilv_uis_begin(*args):
  """lilv_uis_begin(LilvUIs const * collection) -> LilvIter *"""
  return _lilv.lilv_uis_begin(*args)

def lilv_uis_get(*args):
  """lilv_uis_get(LilvUIs const * collection, LilvIter * i) -> LilvUI const *"""
  return _lilv.lilv_uis_get(*args)

def lilv_uis_next(*args):
  """lilv_uis_next(LilvUIs const * collection, LilvIter * i) -> LilvIter *"""
  return _lilv.lilv_uis_next(*args)

def lilv_uis_is_end(*args):
  """lilv_uis_is_end(LilvUIs const * collection, LilvIter * i) -> bool"""
  return _lilv.lilv_uis_is_end(*args)

def lilv_uis_get_by_uri(*args):
  """lilv_uis_get_by_uri(LilvUIs const * uis, LilvNode const * uri) -> LilvUI const *"""
  return _lilv.lilv_uis_get_by_uri(*args)

def lilv_nodes_free(*args):
  """lilv_nodes_free(LilvNodes * collection)"""
  return _lilv.lilv_nodes_free(*args)

def lilv_nodes_size(*args):
  """lilv_nodes_size(LilvNodes const * collection) -> unsigned int"""
  return _lilv.lilv_nodes_size(*args)

def lilv_nodes_begin(*args):
  """lilv_nodes_begin(LilvNodes const * collection) -> LilvIter *"""
  return _lilv.lilv_nodes_begin(*args)

def lilv_nodes_get(*args):
  """lilv_nodes_get(LilvNodes const * collection, LilvIter * i) -> LilvNode const *"""
  return _lilv.lilv_nodes_get(*args)

def lilv_nodes_next(*args):
  """lilv_nodes_next(LilvNodes const * collection, LilvIter * i) -> LilvIter *"""
  return _lilv.lilv_nodes_next(*args)

def lilv_nodes_is_end(*args):
  """lilv_nodes_is_end(LilvNodes const * collection, LilvIter * i) -> bool"""
  return _lilv.lilv_nodes_is_end(*args)

def lilv_nodes_get_first(*args):
  """lilv_nodes_get_first(LilvNodes const * collection) -> LilvNode *"""
  return _lilv.lilv_nodes_get_first(*args)

def lilv_nodes_contains(*args):
  """lilv_nodes_contains(LilvNodes const * values, LilvNode const * value) -> bool"""
  return _lilv.lilv_nodes_contains(*args)

def lilv_nodes_merge(*args):
  """lilv_nodes_merge(LilvNodes const * a, LilvNodes const * b) -> LilvNodes *"""
  return _lilv.lilv_nodes_merge(*args)

def lilv_plugins_size(*args):
  """lilv_plugins_size(LilvPlugins const * collection) -> unsigned int"""
  return _lilv.lilv_plugins_size(*args)

def lilv_plugins_begin(*args):
  """lilv_plugins_begin(LilvPlugins const * collection) -> LilvIter *"""
  return _lilv.lilv_plugins_begin(*args)

def lilv_plugins_get(*args):
  """lilv_plugins_get(LilvPlugins const * collection, LilvIter * i) -> LilvPlugin const *"""
  return _lilv.lilv_plugins_get(*args)

def lilv_plugins_next(*args):
  """lilv_plugins_next(LilvPlugins const * collection, LilvIter * i) -> LilvIter *"""
  return _lilv.lilv_plugins_next(*args)

def lilv_plugins_is_end(*args):
  """lilv_plugins_is_end(LilvPlugins const * collection, LilvIter * i) -> bool"""
  return _lilv.lilv_plugins_is_end(*args)

def lilv_plugins_get_by_uri(*args):
  """lilv_plugins_get_by_uri(LilvPlugins const * plugins, LilvNode const * uri) -> LilvPlugin const *"""
  return _lilv.lilv_plugins_get_by_uri(*args)

def lilv_world_new():
  """lilv_world_new() -> LilvWorld *"""
  return _lilv.lilv_world_new()
LILV_OPTION_FILTER_LANG = _lilv.LILV_OPTION_FILTER_LANG
LILV_OPTION_DYN_MANIFEST = _lilv.LILV_OPTION_DYN_MANIFEST

def lilv_world_set_option(*args):
  """lilv_world_set_option(LilvWorld * world, char const * uri, LilvNode const * value)"""
  return _lilv.lilv_world_set_option(*args)

def lilv_world_free(*args):
  """lilv_world_free(LilvWorld * world)"""
  return _lilv.lilv_world_free(*args)

def lilv_world_load_all(*args):
  """lilv_world_load_all(LilvWorld * world)"""
  return _lilv.lilv_world_load_all(*args)

def lilv_world_load_bundle(*args):
  """lilv_world_load_bundle(LilvWorld * world, LilvNode * bundle_uri)"""
  return _lilv.lilv_world_load_bundle(*args)

def lilv_world_load_resource(*args):
  """lilv_world_load_resource(LilvWorld * world, LilvNode const * resource) -> int"""
  return _lilv.lilv_world_load_resource(*args)

def lilv_world_get_plugin_class(*args):
  """lilv_world_get_plugin_class(LilvWorld const * world) -> LilvPluginClass const *"""
  return _lilv.lilv_world_get_plugin_class(*args)

def lilv_world_get_plugin_classes(*args):
  """lilv_world_get_plugin_classes(LilvWorld const * world) -> LilvPluginClasses const *"""
  return _lilv.lilv_world_get_plugin_classes(*args)

def lilv_world_get_all_plugins(*args):
  """lilv_world_get_all_plugins(LilvWorld const * world) -> LilvPlugins const *"""
  return _lilv.lilv_world_get_all_plugins(*args)

def lilv_world_find_nodes(*args):
  """lilv_world_find_nodes(LilvWorld * world, LilvNode const * subject, LilvNode const * predicate, LilvNode const * object) -> LilvNodes *"""
  return _lilv.lilv_world_find_nodes(*args)

def lilv_world_get(*args):
  """lilv_world_get(LilvWorld * world, LilvNode const * subject, LilvNode const * predicate, LilvNode const * object) -> LilvNode *"""
  return _lilv.lilv_world_get(*args)

def lilv_world_ask(*args):
  """lilv_world_ask(LilvWorld * world, LilvNode const * subject, LilvNode const * predicate, LilvNode const * object) -> bool"""
  return _lilv.lilv_world_ask(*args)

def lilv_plugin_verify(*args):
  """lilv_plugin_verify(LilvPlugin const * plugin) -> bool"""
  return _lilv.lilv_plugin_verify(*args)

def lilv_plugin_get_uri(*args):
  """lilv_plugin_get_uri(LilvPlugin const * plugin) -> LilvNode const *"""
  return _lilv.lilv_plugin_get_uri(*args)

def lilv_plugin_get_bundle_uri(*args):
  """lilv_plugin_get_bundle_uri(LilvPlugin const * plugin) -> LilvNode const *"""
  return _lilv.lilv_plugin_get_bundle_uri(*args)

def lilv_plugin_get_data_uris(*args):
  """lilv_plugin_get_data_uris(LilvPlugin const * plugin) -> LilvNodes const *"""
  return _lilv.lilv_plugin_get_data_uris(*args)

def lilv_plugin_get_library_uri(*args):
  """lilv_plugin_get_library_uri(LilvPlugin const * plugin) -> LilvNode const *"""
  return _lilv.lilv_plugin_get_library_uri(*args)

def lilv_plugin_get_name(*args):
  """lilv_plugin_get_name(LilvPlugin const * plugin) -> LilvNode *"""
  return _lilv.lilv_plugin_get_name(*args)

def lilv_plugin_get_class(*args):
  """lilv_plugin_get_class(LilvPlugin const * plugin) -> LilvPluginClass const *"""
  return _lilv.lilv_plugin_get_class(*args)

def lilv_plugin_get_value(*args):
  """lilv_plugin_get_value(LilvPlugin const * p, LilvNode const * predicate) -> LilvNodes *"""
  return _lilv.lilv_plugin_get_value(*args)

def lilv_plugin_has_feature(*args):
  """lilv_plugin_has_feature(LilvPlugin const * p, LilvNode const * feature_uri) -> bool"""
  return _lilv.lilv_plugin_has_feature(*args)

def lilv_plugin_get_supported_features(*args):
  """lilv_plugin_get_supported_features(LilvPlugin const * p) -> LilvNodes *"""
  return _lilv.lilv_plugin_get_supported_features(*args)

def lilv_plugin_get_required_features(*args):
  """lilv_plugin_get_required_features(LilvPlugin const * p) -> LilvNodes *"""
  return _lilv.lilv_plugin_get_required_features(*args)

def lilv_plugin_get_optional_features(*args):
  """lilv_plugin_get_optional_features(LilvPlugin const * p) -> LilvNodes *"""
  return _lilv.lilv_plugin_get_optional_features(*args)

def lilv_plugin_has_extension_data(*args):
  """lilv_plugin_has_extension_data(LilvPlugin const * p, LilvNode const * uri) -> bool"""
  return _lilv.lilv_plugin_has_extension_data(*args)

def lilv_plugin_get_extension_data(*args):
  """lilv_plugin_get_extension_data(LilvPlugin const * p) -> LilvNodes *"""
  return _lilv.lilv_plugin_get_extension_data(*args)

def lilv_plugin_get_num_ports(*args):
  """lilv_plugin_get_num_ports(LilvPlugin const * p) -> uint32_t"""
  return _lilv.lilv_plugin_get_num_ports(*args)

def lilv_plugin_get_port_ranges_float(*args):
  """lilv_plugin_get_port_ranges_float(LilvPlugin const * p, float * min_values, float * max_values, float * def_values)"""
  return _lilv.lilv_plugin_get_port_ranges_float(*args)

def lilv_plugin_get_num_ports_of_class(*args):
  """lilv_plugin_get_num_ports_of_class(LilvPlugin const * p, LilvNode const * class_1) -> uint32_t"""
  return _lilv.lilv_plugin_get_num_ports_of_class(*args)

def lilv_plugin_has_latency(*args):
  """lilv_plugin_has_latency(LilvPlugin const * p) -> bool"""
  return _lilv.lilv_plugin_has_latency(*args)

def lilv_plugin_get_latency_port_index(*args):
  """lilv_plugin_get_latency_port_index(LilvPlugin const * p) -> uint32_t"""
  return _lilv.lilv_plugin_get_latency_port_index(*args)

def lilv_plugin_get_port_by_index(*args):
  """lilv_plugin_get_port_by_index(LilvPlugin const * plugin, uint32_t index) -> LilvPort const *"""
  return _lilv.lilv_plugin_get_port_by_index(*args)

def lilv_plugin_get_port_by_symbol(*args):
  """lilv_plugin_get_port_by_symbol(LilvPlugin const * plugin, LilvNode const * symbol) -> LilvPort const *"""
  return _lilv.lilv_plugin_get_port_by_symbol(*args)

def lilv_plugin_get_port_by_designation(*args):
  """lilv_plugin_get_port_by_designation(LilvPlugin const * plugin, LilvNode const * port_class, LilvNode const * designation) -> LilvPort const *"""
  return _lilv.lilv_plugin_get_port_by_designation(*args)

def lilv_plugin_get_project(*args):
  """lilv_plugin_get_project(LilvPlugin const * plugin) -> LilvNode *"""
  return _lilv.lilv_plugin_get_project(*args)

def lilv_plugin_get_author_name(*args):
  """lilv_plugin_get_author_name(LilvPlugin const * plugin) -> LilvNode *"""
  return _lilv.lilv_plugin_get_author_name(*args)

def lilv_plugin_get_author_email(*args):
  """lilv_plugin_get_author_email(LilvPlugin const * plugin) -> LilvNode *"""
  return _lilv.lilv_plugin_get_author_email(*args)

def lilv_plugin_get_author_homepage(*args):
  """lilv_plugin_get_author_homepage(LilvPlugin const * plugin) -> LilvNode *"""
  return _lilv.lilv_plugin_get_author_homepage(*args)

def lilv_plugin_is_replaced(*args):
  """lilv_plugin_is_replaced(LilvPlugin const * plugin) -> bool"""
  return _lilv.lilv_plugin_is_replaced(*args)

def lilv_plugin_write_description(*args):
  """lilv_plugin_write_description(LilvWorld * world, LilvPlugin const * plugin, LilvNode const * base_uri, FILE * plugin_file)"""
  return _lilv.lilv_plugin_write_description(*args)

def lilv_plugin_write_manifest_entry(*args):
  """
    lilv_plugin_write_manifest_entry(LilvWorld * world, LilvPlugin const * plugin, LilvNode const * base_uri, FILE * manifest_file, 
        char const * plugin_file_path)
    """
  return _lilv.lilv_plugin_write_manifest_entry(*args)

def lilv_plugin_get_related(*args):
  """lilv_plugin_get_related(LilvPlugin const * plugin, LilvNode const * type) -> LilvNodes *"""
  return _lilv.lilv_plugin_get_related(*args)

def lilv_port_get_value(*args):
  """lilv_port_get_value(LilvPlugin const * plugin, LilvPort const * port, LilvNode const * predicate) -> LilvNodes *"""
  return _lilv.lilv_port_get_value(*args)

def lilv_port_get(*args):
  """lilv_port_get(LilvPlugin const * plugin, LilvPort const * port, LilvNode const * predicate) -> LilvNode *"""
  return _lilv.lilv_port_get(*args)

def lilv_port_get_properties(*args):
  """lilv_port_get_properties(LilvPlugin const * plugin, LilvPort const * port) -> LilvNodes *"""
  return _lilv.lilv_port_get_properties(*args)

def lilv_port_has_property(*args):
  """lilv_port_has_property(LilvPlugin const * p, LilvPort const * port, LilvNode const * property_uri) -> bool"""
  return _lilv.lilv_port_has_property(*args)

def lilv_port_supports_event(*args):
  """lilv_port_supports_event(LilvPlugin const * p, LilvPort const * port, LilvNode const * event_type) -> bool"""
  return _lilv.lilv_port_supports_event(*args)

def lilv_port_get_index(*args):
  """lilv_port_get_index(LilvPlugin const * plugin, LilvPort const * port) -> uint32_t"""
  return _lilv.lilv_port_get_index(*args)

def lilv_port_get_symbol(*args):
  """lilv_port_get_symbol(LilvPlugin const * plugin, LilvPort const * port) -> LilvNode const *"""
  return _lilv.lilv_port_get_symbol(*args)

def lilv_port_get_name(*args):
  """lilv_port_get_name(LilvPlugin const * plugin, LilvPort const * port) -> LilvNode *"""
  return _lilv.lilv_port_get_name(*args)

def lilv_port_get_classes(*args):
  """lilv_port_get_classes(LilvPlugin const * plugin, LilvPort const * port) -> LilvNodes const *"""
  return _lilv.lilv_port_get_classes(*args)

def lilv_port_is_a(*args):
  """lilv_port_is_a(LilvPlugin const * plugin, LilvPort const * port, LilvNode const * port_class) -> bool"""
  return _lilv.lilv_port_is_a(*args)

def lilv_port_get_range(*args):
  """
    lilv_port_get_range(LilvPlugin const * plugin, LilvPort const * port, LilvNode ** deflt, LilvNode ** min, 
        LilvNode ** max)
    """
  return _lilv.lilv_port_get_range(*args)

def lilv_port_get_scale_points(*args):
  """lilv_port_get_scale_points(LilvPlugin const * plugin, LilvPort const * port) -> LilvScalePoints *"""
  return _lilv.lilv_port_get_scale_points(*args)

def lilv_state_new_from_world(*args):
  """lilv_state_new_from_world(LilvWorld * world, LV2_URID_Map * map, LilvNode const * subject) -> LilvState *"""
  return _lilv.lilv_state_new_from_world(*args)

def lilv_state_new_from_file(*args):
  """lilv_state_new_from_file(LilvWorld * world, LV2_URID_Map * map, LilvNode const * subject, char const * path) -> LilvState *"""
  return _lilv.lilv_state_new_from_file(*args)

def lilv_state_new_from_string(*args):
  """lilv_state_new_from_string(LilvWorld * world, LV2_URID_Map * map, char const * str) -> LilvState *"""
  return _lilv.lilv_state_new_from_string(*args)

def lilv_state_new_from_instance(*args):
  """
    lilv_state_new_from_instance(LilvPlugin const * plugin, LilvInstanceImpl instance, LV2_URID_Map * map, char const * file_dir, 
        char const * copy_dir, char const * link_dir, char const * save_dir, 
        LilvGetPortValueFunc get_value, void * user_data, uint32_t flags, 
        LV2_Feature const *const * features) -> LilvState *
    """
  return _lilv.lilv_state_new_from_instance(*args)

def lilv_state_free(*args):
  """lilv_state_free(LilvState * state)"""
  return _lilv.lilv_state_free(*args)

def lilv_state_equals(*args):
  """lilv_state_equals(LilvState const * a, LilvState const * b) -> bool"""
  return _lilv.lilv_state_equals(*args)

def lilv_state_get_num_properties(*args):
  """lilv_state_get_num_properties(LilvState const * state) -> unsigned int"""
  return _lilv.lilv_state_get_num_properties(*args)

def lilv_state_get_plugin_uri(*args):
  """lilv_state_get_plugin_uri(LilvState const * state) -> LilvNode const *"""
  return _lilv.lilv_state_get_plugin_uri(*args)

def lilv_state_get_label(*args):
  """lilv_state_get_label(LilvState const * state) -> char const *"""
  return _lilv.lilv_state_get_label(*args)

def lilv_state_set_label(*args):
  """lilv_state_set_label(LilvState * state, char const * label)"""
  return _lilv.lilv_state_set_label(*args)

def lilv_state_restore(*args):
  """
    lilv_state_restore(LilvState const * state, LilvInstanceImpl instance, LilvSetPortValueFunc set_value, 
        void * user_data, uint32_t flags, LV2_Feature const *const * features)
    """
  return _lilv.lilv_state_restore(*args)

def lilv_state_save(*args):
  """
    lilv_state_save(LilvWorld * world, LV2_URID_Map * map, LV2_URID_Unmap * unmap, LilvState const * state, 
        char const * uri, char const * dir, char const * filename) -> int
    """
  return _lilv.lilv_state_save(*args)

def lilv_state_to_string(*args):
  """
    lilv_state_to_string(LilvWorld * world, LV2_URID_Map * map, LV2_URID_Unmap * unmap, LilvState const * state, 
        char const * uri, char const * base_uri) -> char *
    """
  return _lilv.lilv_state_to_string(*args)

def lilv_scale_point_get_label(*args):
  """lilv_scale_point_get_label(LilvScalePoint const * point) -> LilvNode const *"""
  return _lilv.lilv_scale_point_get_label(*args)

def lilv_scale_point_get_value(*args):
  """lilv_scale_point_get_value(LilvScalePoint const * point) -> LilvNode const *"""
  return _lilv.lilv_scale_point_get_value(*args)

def lilv_plugin_class_get_parent_uri(*args):
  """lilv_plugin_class_get_parent_uri(LilvPluginClass const * plugin_class) -> LilvNode const *"""
  return _lilv.lilv_plugin_class_get_parent_uri(*args)

def lilv_plugin_class_get_uri(*args):
  """lilv_plugin_class_get_uri(LilvPluginClass const * plugin_class) -> LilvNode const *"""
  return _lilv.lilv_plugin_class_get_uri(*args)

def lilv_plugin_class_get_label(*args):
  """lilv_plugin_class_get_label(LilvPluginClass const * plugin_class) -> LilvNode const *"""
  return _lilv.lilv_plugin_class_get_label(*args)

def lilv_plugin_class_get_children(*args):
  """lilv_plugin_class_get_children(LilvPluginClass const * plugin_class) -> LilvPluginClasses *"""
  return _lilv.lilv_plugin_class_get_children(*args)
class LilvInstanceImpl(_object):
    """Proxy of C++ LilvInstanceImpl class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LilvInstanceImpl, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LilvInstanceImpl, name)
    __repr__ = _swig_repr
    __swig_setmethods__["lv2_descriptor"] = _lilv.LilvInstanceImpl_lv2_descriptor_set
    __swig_getmethods__["lv2_descriptor"] = _lilv.LilvInstanceImpl_lv2_descriptor_get
    if _newclass:lv2_descriptor = _swig_property(_lilv.LilvInstanceImpl_lv2_descriptor_get, _lilv.LilvInstanceImpl_lv2_descriptor_set)
    __swig_setmethods__["lv2_handle"] = _lilv.LilvInstanceImpl_lv2_handle_set
    __swig_getmethods__["lv2_handle"] = _lilv.LilvInstanceImpl_lv2_handle_get
    if _newclass:lv2_handle = _swig_property(_lilv.LilvInstanceImpl_lv2_handle_get, _lilv.LilvInstanceImpl_lv2_handle_set)
    __swig_setmethods__["pimpl"] = _lilv.LilvInstanceImpl_pimpl_set
    __swig_getmethods__["pimpl"] = _lilv.LilvInstanceImpl_pimpl_get
    if _newclass:pimpl = _swig_property(_lilv.LilvInstanceImpl_pimpl_get, _lilv.LilvInstanceImpl_pimpl_set)
    def __init__(self): 
        """__init__(LilvInstanceImpl self) -> LilvInstanceImpl"""
        this = _lilv.new_LilvInstanceImpl()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lilv.delete_LilvInstanceImpl
    __del__ = lambda self : None;
LilvInstanceImpl_swigregister = _lilv.LilvInstanceImpl_swigregister
LilvInstanceImpl_swigregister(LilvInstanceImpl)


def lilv_plugin_instantiate(*args):
  """lilv_plugin_instantiate(LilvPlugin const * plugin, double sample_rate, LV2_Feature const *const * features) -> LilvInstanceImpl"""
  return _lilv.lilv_plugin_instantiate(*args)

def lilv_instance_free(*args):
  """lilv_instance_free(LilvInstanceImpl instance)"""
  return _lilv.lilv_instance_free(*args)

def lilv_instance_get_uri(*args):
  """lilv_instance_get_uri(LilvInstanceImpl instance) -> char const *"""
  return _lilv.lilv_instance_get_uri(*args)

def lilv_instance_connect_port(*args):
  """lilv_instance_connect_port(LilvInstanceImpl instance, uint32_t port_index, void * data_location)"""
  return _lilv.lilv_instance_connect_port(*args)

def lilv_instance_activate(*args):
  """lilv_instance_activate(LilvInstanceImpl instance)"""
  return _lilv.lilv_instance_activate(*args)

def lilv_instance_run(*args):
  """lilv_instance_run(LilvInstanceImpl instance, uint32_t sample_count)"""
  return _lilv.lilv_instance_run(*args)

def lilv_instance_deactivate(*args):
  """lilv_instance_deactivate(LilvInstanceImpl instance)"""
  return _lilv.lilv_instance_deactivate(*args)

def lilv_instance_get_extension_data(*args):
  """lilv_instance_get_extension_data(LilvInstanceImpl instance, char const * uri) -> void const *"""
  return _lilv.lilv_instance_get_extension_data(*args)

def lilv_instance_get_descriptor(*args):
  """lilv_instance_get_descriptor(LilvInstanceImpl instance) -> LV2_Descriptor const *"""
  return _lilv.lilv_instance_get_descriptor(*args)

def lilv_instance_get_handle(*args):
  """lilv_instance_get_handle(LilvInstanceImpl instance) -> LV2_Handle"""
  return _lilv.lilv_instance_get_handle(*args)

def lilv_plugin_get_uis(*args):
  """lilv_plugin_get_uis(LilvPlugin const * plugin) -> LilvUIs *"""
  return _lilv.lilv_plugin_get_uis(*args)

def lilv_ui_get_uri(*args):
  """lilv_ui_get_uri(LilvUI const * ui) -> LilvNode const *"""
  return _lilv.lilv_ui_get_uri(*args)

def lilv_ui_get_classes(*args):
  """lilv_ui_get_classes(LilvUI const * ui) -> LilvNodes const *"""
  return _lilv.lilv_ui_get_classes(*args)

def lilv_ui_is_a(*args):
  """lilv_ui_is_a(LilvUI const * ui, LilvNode const * class_uri) -> bool"""
  return _lilv.lilv_ui_is_a(*args)

def lilv_ui_is_supported(*args):
  """
    lilv_ui_is_supported(LilvUI const * ui, LilvUISupportedFunc supported_func, LilvNode const * container_type, 
        LilvNode const ** ui_type) -> unsigned int
    """
  return _lilv.lilv_ui_is_supported(*args)

def lilv_ui_get_bundle_uri(*args):
  """lilv_ui_get_bundle_uri(LilvUI const * ui) -> LilvNode const *"""
  return _lilv.lilv_ui_get_bundle_uri(*args)

def lilv_ui_get_binary_uri(*args):
  """lilv_ui_get_binary_uri(LilvUI const * ui) -> LilvNode const *"""
  return _lilv.lilv_ui_get_binary_uri(*args)

def uri_to_path(*args):
  """uri_to_path(char const * uri) -> char const *"""
  return _lilv.uri_to_path(*args)
class Node(_object):
    """Proxy of C++ Lilv::Node class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Node, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Node, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(Lilv::Node self, LilvNode const * node) -> Node
        __init__(Lilv::Node self, Node copy) -> Node
        """
        this = _lilv.new_Node(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lilv.delete_Node
    __del__ = lambda self : None;
    def equals(self, *args):
        """equals(Node self, Node other) -> bool"""
        return _lilv.Node_equals(self, *args)

    def __eq__(self, *args):
        """__eq__(Node self, Node other) -> bool"""
        return _lilv.Node___eq__(self, *args)

    def get_turtle_token(self):
        """get_turtle_token(Node self) -> char *"""
        return _lilv.Node_get_turtle_token(self)

    def is_uri(self):
        """is_uri(Node self) -> bool"""
        return _lilv.Node_is_uri(self)

    def as_uri(self):
        """as_uri(Node self) -> char const *"""
        return _lilv.Node_as_uri(self)

    def is_blank(self):
        """is_blank(Node self) -> bool"""
        return _lilv.Node_is_blank(self)

    def as_blank(self):
        """as_blank(Node self) -> char const *"""
        return _lilv.Node_as_blank(self)

    def is_literal(self):
        """is_literal(Node self) -> bool"""
        return _lilv.Node_is_literal(self)

    def is_string(self):
        """is_string(Node self) -> bool"""
        return _lilv.Node_is_string(self)

    def as_string(self):
        """as_string(Node self) -> char const *"""
        return _lilv.Node_as_string(self)

    def is_float(self):
        """is_float(Node self) -> bool"""
        return _lilv.Node_is_float(self)

    def as_float(self):
        """as_float(Node self) -> float"""
        return _lilv.Node_as_float(self)

    def is_int(self):
        """is_int(Node self) -> bool"""
        return _lilv.Node_is_int(self)

    def as_int(self):
        """as_int(Node self) -> int"""
        return _lilv.Node_as_int(self)

    def is_bool(self):
        """is_bool(Node self) -> bool"""
        return _lilv.Node_is_bool(self)

    def as_bool(self):
        """as_bool(Node self) -> bool"""
        return _lilv.Node_as_bool(self)

    __swig_setmethods__["me"] = _lilv.Node_me_set
    __swig_getmethods__["me"] = _lilv.Node_me_get
    if _newclass:me = _swig_property(_lilv.Node_me_get, _lilv.Node_me_set)
    def __str__(self):
    	return self.get_turtle_token()

Node_swigregister = _lilv.Node_swigregister
Node_swigregister(Node)

class ScalePoint(_object):
    """Proxy of C++ Lilv::ScalePoint class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScalePoint, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ScalePoint, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(Lilv::ScalePoint self, LilvScalePoint const * c_obj) -> ScalePoint"""
        this = _lilv.new_ScalePoint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_label(self):
        """get_label(ScalePoint self) -> LilvNode const *"""
        return _lilv.ScalePoint_get_label(self)

    def get_value(self):
        """get_value(ScalePoint self) -> LilvNode const *"""
        return _lilv.ScalePoint_get_value(self)

    __swig_setmethods__["me"] = _lilv.ScalePoint_me_set
    __swig_getmethods__["me"] = _lilv.ScalePoint_me_get
    if _newclass:me = _swig_property(_lilv.ScalePoint_me_get, _lilv.ScalePoint_me_set)
    __swig_destroy__ = _lilv.delete_ScalePoint
    __del__ = lambda self : None;
ScalePoint_swigregister = _lilv.ScalePoint_swigregister
ScalePoint_swigregister(ScalePoint)

class PluginClass(_object):
    """Proxy of C++ Lilv::PluginClass class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PluginClass, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PluginClass, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(Lilv::PluginClass self, LilvPluginClass const * c_obj) -> PluginClass"""
        this = _lilv.new_PluginClass(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_parent_uri(self):
        """get_parent_uri(PluginClass self) -> Node"""
        return _lilv.PluginClass_get_parent_uri(self)

    def get_uri(self):
        """get_uri(PluginClass self) -> Node"""
        return _lilv.PluginClass_get_uri(self)

    def get_label(self):
        """get_label(PluginClass self) -> Node"""
        return _lilv.PluginClass_get_label(self)

    def get_children(self):
        """get_children(PluginClass self) -> LilvPluginClasses *"""
        return _lilv.PluginClass_get_children(self)

    __swig_setmethods__["me"] = _lilv.PluginClass_me_set
    __swig_getmethods__["me"] = _lilv.PluginClass_me_get
    if _newclass:me = _swig_property(_lilv.PluginClass_me_get, _lilv.PluginClass_me_set)
    __swig_destroy__ = _lilv.delete_PluginClass
    __del__ = lambda self : None;
PluginClass_swigregister = _lilv.PluginClass_swigregister
PluginClass_swigregister(PluginClass)

class PluginClasses(_object):
    """Proxy of C++ Lilv::PluginClasses class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PluginClasses, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PluginClasses, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(Lilv::PluginClasses self, LilvPluginClasses const * c_obj) -> PluginClasses"""
        this = _lilv.new_PluginClasses(*args)
        try: self.this.append(this)
        except: self.this = this
    def size(self):
        """size(PluginClasses self) -> unsigned int"""
        return _lilv.PluginClasses_size(self)

    def get(self, *args):
        """get(PluginClasses self, LilvIter * i) -> PluginClass"""
        return _lilv.PluginClasses_get(self, *args)

    def begin(self):
        """begin(PluginClasses self) -> LilvIter *"""
        return _lilv.PluginClasses_begin(self)

    def next(self, *args):
        """next(PluginClasses self, LilvIter * i) -> LilvIter *"""
        return _lilv.PluginClasses_next(self, *args)

    def is_end(self, *args):
        """is_end(PluginClasses self, LilvIter * i) -> bool"""
        return _lilv.PluginClasses_is_end(self, *args)

    __swig_setmethods__["me"] = _lilv.PluginClasses_me_set
    __swig_getmethods__["me"] = _lilv.PluginClasses_me_get
    if _newclass:me = _swig_property(_lilv.PluginClasses_me_get, _lilv.PluginClasses_me_set)
    def get_by_uri(self, *args):
        """get_by_uri(PluginClasses self, LilvNode const * uri) -> PluginClass"""
        return _lilv.PluginClasses_get_by_uri(self, *args)

    __swig_destroy__ = _lilv.delete_PluginClasses
    __del__ = lambda self : None;
PluginClasses_swigregister = _lilv.PluginClasses_swigregister
PluginClasses_swigregister(PluginClasses)

class ScalePoints(_object):
    """Proxy of C++ Lilv::ScalePoints class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScalePoints, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ScalePoints, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(Lilv::ScalePoints self, LilvScalePoints const * c_obj) -> ScalePoints"""
        this = _lilv.new_ScalePoints(*args)
        try: self.this.append(this)
        except: self.this = this
    def size(self):
        """size(ScalePoints self) -> unsigned int"""
        return _lilv.ScalePoints_size(self)

    def get(self, *args):
        """get(ScalePoints self, LilvIter * i) -> ScalePoint"""
        return _lilv.ScalePoints_get(self, *args)

    def begin(self):
        """begin(ScalePoints self) -> LilvIter *"""
        return _lilv.ScalePoints_begin(self)

    def next(self, *args):
        """next(ScalePoints self, LilvIter * i) -> LilvIter *"""
        return _lilv.ScalePoints_next(self, *args)

    def is_end(self, *args):
        """is_end(ScalePoints self, LilvIter * i) -> bool"""
        return _lilv.ScalePoints_is_end(self, *args)

    __swig_setmethods__["me"] = _lilv.ScalePoints_me_set
    __swig_getmethods__["me"] = _lilv.ScalePoints_me_get
    if _newclass:me = _swig_property(_lilv.ScalePoints_me_get, _lilv.ScalePoints_me_set)
    __swig_destroy__ = _lilv.delete_ScalePoints
    __del__ = lambda self : None;
ScalePoints_swigregister = _lilv.ScalePoints_swigregister
ScalePoints_swigregister(ScalePoints)

class Nodes(_object):
    """Proxy of C++ Lilv::Nodes class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Nodes, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Nodes, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(Lilv::Nodes self, LilvNodes const * c_obj) -> Nodes"""
        this = _lilv.new_Nodes(*args)
        try: self.this.append(this)
        except: self.this = this
    def size(self):
        """size(Nodes self) -> unsigned int"""
        return _lilv.Nodes_size(self)

    def get(self, *args):
        """get(Nodes self, LilvIter * i) -> Node"""
        return _lilv.Nodes_get(self, *args)

    def begin(self):
        """begin(Nodes self) -> LilvIter *"""
        return _lilv.Nodes_begin(self)

    def next(self, *args):
        """next(Nodes self, LilvIter * i) -> LilvIter *"""
        return _lilv.Nodes_next(self, *args)

    def is_end(self, *args):
        """is_end(Nodes self, LilvIter * i) -> bool"""
        return _lilv.Nodes_is_end(self, *args)

    __swig_setmethods__["me"] = _lilv.Nodes_me_set
    __swig_getmethods__["me"] = _lilv.Nodes_me_get
    if _newclass:me = _swig_property(_lilv.Nodes_me_get, _lilv.Nodes_me_set)
    def contains(self, *args):
        """contains(Nodes self, Node node) -> bool"""
        return _lilv.Nodes_contains(self, *args)

    def get_first(self):
        """get_first(Nodes self) -> Node"""
        return _lilv.Nodes_get_first(self)

    __swig_destroy__ = _lilv.delete_Nodes
    __del__ = lambda self : None;
Nodes_swigregister = _lilv.Nodes_swigregister
Nodes_swigregister(Nodes)

class UI(_object):
    """Proxy of C++ Lilv::UI class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, UI, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, UI, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(Lilv::UI self, LilvUI const * c_obj) -> UI"""
        this = _lilv.new_UI(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_uri(self):
        """get_uri(UI self) -> LilvNode const *"""
        return _lilv.UI_get_uri(self)

    def get_bundle_uri(self):
        """get_bundle_uri(UI self) -> LilvNode const *"""
        return _lilv.UI_get_bundle_uri(self)

    def get_binary_uri(self):
        """get_binary_uri(UI self) -> LilvNode const *"""
        return _lilv.UI_get_binary_uri(self)

    def get_classes(self):
        """get_classes(UI self) -> LilvNodes const *"""
        return _lilv.UI_get_classes(self)

    def is_a(self, *args):
        """is_a(UI self, LilvNode const * class_uri) -> bool"""
        return _lilv.UI_is_a(self, *args)

    __swig_setmethods__["me"] = _lilv.UI_me_set
    __swig_getmethods__["me"] = _lilv.UI_me_get
    if _newclass:me = _swig_property(_lilv.UI_me_get, _lilv.UI_me_set)
    __swig_destroy__ = _lilv.delete_UI
    __del__ = lambda self : None;
UI_swigregister = _lilv.UI_swigregister
UI_swigregister(UI)

class UIs(_object):
    """Proxy of C++ Lilv::UIs class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, UIs, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, UIs, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(Lilv::UIs self, LilvUIs const * c_obj) -> UIs"""
        this = _lilv.new_UIs(*args)
        try: self.this.append(this)
        except: self.this = this
    def size(self):
        """size(UIs self) -> unsigned int"""
        return _lilv.UIs_size(self)

    def get(self, *args):
        """get(UIs self, LilvIter * i) -> UI"""
        return _lilv.UIs_get(self, *args)

    def begin(self):
        """begin(UIs self) -> LilvIter *"""
        return _lilv.UIs_begin(self)

    def next(self, *args):
        """next(UIs self, LilvIter * i) -> LilvIter *"""
        return _lilv.UIs_next(self, *args)

    def is_end(self, *args):
        """is_end(UIs self, LilvIter * i) -> bool"""
        return _lilv.UIs_is_end(self, *args)

    __swig_setmethods__["me"] = _lilv.UIs_me_set
    __swig_getmethods__["me"] = _lilv.UIs_me_get
    if _newclass:me = _swig_property(_lilv.UIs_me_get, _lilv.UIs_me_set)
    __swig_destroy__ = _lilv.delete_UIs
    __del__ = lambda self : None;
UIs_swigregister = _lilv.UIs_swigregister
UIs_swigregister(UIs)

class Port(_object):
    """Proxy of C++ Lilv::Port class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Port, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Port, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(Lilv::Port self, LilvPlugin const * p, LilvPort const * c_obj) -> Port"""
        this = _lilv.new_Port(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_value(self, *args):
        """get_value(Port self, LilvNode * predicate) -> LilvNodes *"""
        return _lilv.Port_get_value(self, *args)

    def get_properties(self):
        """get_properties(Port self) -> LilvNodes *"""
        return _lilv.Port_get_properties(self)

    def has_property(self, *args):
        """has_property(Port self, LilvNode * property_uri) -> bool"""
        return _lilv.Port_has_property(self, *args)

    def supports_event(self, *args):
        """supports_event(Port self, LilvNode * event_uri) -> bool"""
        return _lilv.Port_supports_event(self, *args)

    def get_symbol(self):
        """get_symbol(Port self) -> LilvNode const *"""
        return _lilv.Port_get_symbol(self)

    def get_name(self):
        """get_name(Port self) -> LilvNode *"""
        return _lilv.Port_get_name(self)

    def get_classes(self):
        """get_classes(Port self) -> LilvNodes const *"""
        return _lilv.Port_get_classes(self)

    def is_a(self, *args):
        """is_a(Port self, LilvNode * port_class) -> bool"""
        return _lilv.Port_is_a(self, *args)

    def get_scale_points(self):
        """get_scale_points(Port self) -> LilvScalePoints *"""
        return _lilv.Port_get_scale_points(self)

    __swig_setmethods__["parent"] = _lilv.Port_parent_set
    __swig_getmethods__["parent"] = _lilv.Port_parent_get
    if _newclass:parent = _swig_property(_lilv.Port_parent_get, _lilv.Port_parent_set)
    __swig_setmethods__["me"] = _lilv.Port_me_set
    __swig_getmethods__["me"] = _lilv.Port_me_get
    if _newclass:me = _swig_property(_lilv.Port_me_get, _lilv.Port_me_set)
    __swig_destroy__ = _lilv.delete_Port
    __del__ = lambda self : None;
Port_swigregister = _lilv.Port_swigregister
Port_swigregister(Port)

class Plugin(_object):
    """Proxy of C++ Lilv::Plugin class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Plugin, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Plugin, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(Lilv::Plugin self, LilvPlugin const * c_obj) -> Plugin"""
        this = _lilv.new_Plugin(*args)
        try: self.this.append(this)
        except: self.this = this
    def verify(self):
        """verify(Plugin self) -> bool"""
        return _lilv.Plugin_verify(self)

    def get_uri(self):
        """get_uri(Plugin self) -> Node"""
        return _lilv.Plugin_get_uri(self)

    def get_bundle_uri(self):
        """get_bundle_uri(Plugin self) -> Node"""
        return _lilv.Plugin_get_bundle_uri(self)

    def get_data_uris(self):
        """get_data_uris(Plugin self) -> Nodes"""
        return _lilv.Plugin_get_data_uris(self)

    def get_library_uri(self):
        """get_library_uri(Plugin self) -> Node"""
        return _lilv.Plugin_get_library_uri(self)

    def get_name(self):
        """get_name(Plugin self) -> Node"""
        return _lilv.Plugin_get_name(self)

    def get_class(self):
        """get_class(Plugin self) -> PluginClass"""
        return _lilv.Plugin_get_class(self)

    def get_value(self, *args):
        """get_value(Plugin self, Node pred) -> Nodes"""
        return _lilv.Plugin_get_value(self, *args)

    def has_feature(self, *args):
        """has_feature(Plugin self, Node feature_uri) -> bool"""
        return _lilv.Plugin_has_feature(self, *args)

    def get_supported_features(self):
        """get_supported_features(Plugin self) -> Nodes"""
        return _lilv.Plugin_get_supported_features(self)

    def get_required_features(self):
        """get_required_features(Plugin self) -> Nodes"""
        return _lilv.Plugin_get_required_features(self)

    def get_optional_features(self):
        """get_optional_features(Plugin self) -> Nodes"""
        return _lilv.Plugin_get_optional_features(self)

    def get_num_ports(self):
        """get_num_ports(Plugin self) -> unsigned int"""
        return _lilv.Plugin_get_num_ports(self)

    def has_latency(self):
        """has_latency(Plugin self) -> bool"""
        return _lilv.Plugin_has_latency(self)

    def get_latency_port_index(self):
        """get_latency_port_index(Plugin self) -> unsigned int"""
        return _lilv.Plugin_get_latency_port_index(self)

    def get_author_name(self):
        """get_author_name(Plugin self) -> Node"""
        return _lilv.Plugin_get_author_name(self)

    def get_author_email(self):
        """get_author_email(Plugin self) -> Node"""
        return _lilv.Plugin_get_author_email(self)

    def get_author_homepage(self):
        """get_author_homepage(Plugin self) -> Node"""
        return _lilv.Plugin_get_author_homepage(self)

    def is_replaced(self):
        """is_replaced(Plugin self) -> bool"""
        return _lilv.Plugin_is_replaced(self)

    def get_extension_data(self):
        """get_extension_data(Plugin self) -> Nodes"""
        return _lilv.Plugin_get_extension_data(self)

    def get_uis(self):
        """get_uis(Plugin self) -> UIs"""
        return _lilv.Plugin_get_uis(self)

    def get_related(self, *args):
        """get_related(Plugin self, Node type) -> Nodes"""
        return _lilv.Plugin_get_related(self, *args)

    def get_port_by_index(self, *args):
        """get_port_by_index(Plugin self, unsigned int index) -> Port"""
        return _lilv.Plugin_get_port_by_index(self, *args)

    def get_port_by_symbol(self, *args):
        """get_port_by_symbol(Plugin self, LilvNode * symbol) -> Port"""
        return _lilv.Plugin_get_port_by_symbol(self, *args)

    def get_port_ranges_float(self, *args):
        """get_port_ranges_float(Plugin self, float * min_values, float * max_values, float * def_values)"""
        return _lilv.Plugin_get_port_ranges_float(self, *args)

    def get_num_ports_of_class(self, *args):
        """get_num_ports_of_class(Plugin self, LilvNode * class_1) -> unsigned int"""
        return _lilv.Plugin_get_num_ports_of_class(self, *args)

    __swig_setmethods__["me"] = _lilv.Plugin_me_set
    __swig_getmethods__["me"] = _lilv.Plugin_me_get
    if _newclass:me = _swig_property(_lilv.Plugin_me_get, _lilv.Plugin_me_set)
    __swig_destroy__ = _lilv.delete_Plugin
    __del__ = lambda self : None;
Plugin_swigregister = _lilv.Plugin_swigregister
Plugin_swigregister(Plugin)

class Plugins(_object):
    """Proxy of C++ Lilv::Plugins class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Plugins, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Plugins, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(Lilv::Plugins self, LilvPlugins const * c_obj) -> Plugins"""
        this = _lilv.new_Plugins(*args)
        try: self.this.append(this)
        except: self.this = this
    def size(self):
        """size(Plugins self) -> unsigned int"""
        return _lilv.Plugins_size(self)

    def get(self, *args):
        """get(Plugins self, LilvIter * i) -> Plugin"""
        return _lilv.Plugins_get(self, *args)

    def begin(self):
        """begin(Plugins self) -> LilvIter *"""
        return _lilv.Plugins_begin(self)

    def next(self, *args):
        """next(Plugins self, LilvIter * i) -> LilvIter *"""
        return _lilv.Plugins_next(self, *args)

    def is_end(self, *args):
        """is_end(Plugins self, LilvIter * i) -> bool"""
        return _lilv.Plugins_is_end(self, *args)

    __swig_setmethods__["me"] = _lilv.Plugins_me_set
    __swig_getmethods__["me"] = _lilv.Plugins_me_get
    if _newclass:me = _swig_property(_lilv.Plugins_me_get, _lilv.Plugins_me_set)
    def get_by_uri(self, *args):
        """get_by_uri(Plugins self, LilvNode const * uri) -> Plugin"""
        return _lilv.Plugins_get_by_uri(self, *args)

    def __iter__(self):
    	class Iterator(object):
    		def __init__(self, plugins):
    			self.plugins = plugins
    			self.iter    = plugins.begin()
                    
    		def next(self):
    			self.iter = self.plugins.next(self.iter)
    			if not self.plugins.is_end(self.iter):
    				return self.plugins.get(self.iter)
    			else:
    				raise StopIteration

    	return Iterator(self)

    __swig_destroy__ = _lilv.delete_Plugins
    __del__ = lambda self : None;
Plugins_swigregister = _lilv.Plugins_swigregister
Plugins_swigregister(Plugins)

class Instance(_object):
    """Proxy of C++ Lilv::Instance class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Instance, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Instance, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(Lilv::Instance self, LilvInstanceImpl instance) -> Instance
        __init__(Lilv::Instance self, Plugin plugin, double sample_rate) -> Instance
        __init__(Lilv::Instance self, Plugin plugin, double sample_rate, LV2_Feature *const * features) -> Instance
        """
        this = _lilv.new_Instance(*args)
        try: self.this.append(this)
        except: self.this = this
    def create(*args):
        """create(Plugin plugin, double sample_rate, LV2_Feature *const * features) -> Instance"""
        return _lilv.Instance_create(*args)

    if _newclass:create = staticmethod(create)
    __swig_getmethods__["create"] = lambda x: create
    def connect_port(self, *args):
        """connect_port(Instance self, unsigned int port_index, void * data_location)"""
        return _lilv.Instance_connect_port(self, *args)

    def activate(self):
        """activate(Instance self)"""
        return _lilv.Instance_activate(self)

    def run(self, *args):
        """run(Instance self, unsigned int sample_count)"""
        return _lilv.Instance_run(self, *args)

    def deactivate(self):
        """deactivate(Instance self)"""
        return _lilv.Instance_deactivate(self)

    def get_extension_data(self, *args):
        """get_extension_data(Instance self, char const * uri) -> void const *"""
        return _lilv.Instance_get_extension_data(self, *args)

    def get_descriptor(self):
        """get_descriptor(Instance self) -> LV2_Descriptor const *"""
        return _lilv.Instance_get_descriptor(self)

    def get_handle(self):
        """get_handle(Instance self) -> LV2_Handle"""
        return _lilv.Instance_get_handle(self)

    __swig_setmethods__["me"] = _lilv.Instance_me_set
    __swig_getmethods__["me"] = _lilv.Instance_me_get
    if _newclass:me = _swig_property(_lilv.Instance_me_get, _lilv.Instance_me_set)
    __swig_destroy__ = _lilv.delete_Instance
    __del__ = lambda self : None;
Instance_swigregister = _lilv.Instance_swigregister
Instance_swigregister(Instance)

def Instance_create(*args):
  """Instance_create(Plugin plugin, double sample_rate, LV2_Feature *const * features) -> Instance"""
  return _lilv.Instance_create(*args)

class World(_object):
    """Proxy of C++ Lilv::World class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, World, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, World, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(Lilv::World self) -> World"""
        this = _lilv.new_World()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lilv.delete_World
    __del__ = lambda self : None;
    def new_uri(self, *args):
        """new_uri(World self, char const * uri) -> LilvNode *"""
        return _lilv.World_new_uri(self, *args)

    def new_string(self, *args):
        """new_string(World self, char const * str) -> LilvNode *"""
        return _lilv.World_new_string(self, *args)

    def new_int(self, *args):
        """new_int(World self, int val) -> LilvNode *"""
        return _lilv.World_new_int(self, *args)

    def new_float(self, *args):
        """new_float(World self, float val) -> LilvNode *"""
        return _lilv.World_new_float(self, *args)

    def new_bool(self, *args):
        """new_bool(World self, bool val) -> LilvNode *"""
        return _lilv.World_new_bool(self, *args)

    def find_nodes(self, *args):
        """find_nodes(World self, LilvNode const * subject, LilvNode const * predicate, LilvNode const * object) -> Nodes"""
        return _lilv.World_find_nodes(self, *args)

    def set_option(self, *args):
        """set_option(World self, char const * uri, LilvNode * value)"""
        return _lilv.World_set_option(self, *args)

    def load_all(self):
        """load_all(World self)"""
        return _lilv.World_load_all(self)

    def load_bundle(self, *args):
        """load_bundle(World self, LilvNode * bundle_uri)"""
        return _lilv.World_load_bundle(self, *args)

    def get_plugin_class(self):
        """get_plugin_class(World self) -> LilvPluginClass const *"""
        return _lilv.World_get_plugin_class(self)

    def get_plugin_classes(self):
        """get_plugin_classes(World self) -> LilvPluginClasses const *"""
        return _lilv.World_get_plugin_classes(self)

    def get_all_plugins(self):
        """get_all_plugins(World self) -> Plugins"""
        return _lilv.World_get_all_plugins(self)

    def load_resource(self, *args):
        """load_resource(World self, LilvNode const * resource) -> int"""
        return _lilv.World_load_resource(self, *args)

    __swig_setmethods__["me"] = _lilv.World_me_set
    __swig_getmethods__["me"] = _lilv.World_me_get
    if _newclass:me = _swig_property(_lilv.World_me_get, _lilv.World_me_set)
World_swigregister = _lilv.World_swigregister
World_swigregister(World)

# This file is compatible with both classic and new-style classes.