/* rygel-object-creator-test.c generated by valac 0.24.0.112-bbf5, the Vala compiler
 * generated from rygel-object-creator-test.vala, do not modify */

/*
 * Copyright (C) 2012 Nokia Corporation.
 * Copyright (C) 2012 Intel Corporation.
 *
 * Author: Jens Georg <jensg@openismus.com>
 *
 * This file is part of Rygel.
 *
 * Rygel is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Rygel is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */
/* This is not used.
[CCode (cname = "uuid_generate", cheader_filename = "uuid/uuid.h")]
internal extern static void uuid_generate ([CCode (array_length = false)]
                                           uchar[] uuid);
[CCode (cname = "uuid_unparse", cheader_filename = "uuid/uuid.h")]
internal extern static void uuid_unparse ([CCode (array_length = false)]
                                          uchar[] uuid,
                                          [CCode (array_length = false)]
                                          uchar[] output);
*/

#include <glib.h>
#include <glib-object.h>
#include <stdlib.h>
#include <string.h>
#include <gio/gio.h>
#include <gee.h>
#include <libgupnp-av/gupnp-av.h>
#include <libxml/tree.h>
#include <libxml/parser.h>
#include <gobject/gvaluecollector.h>


#define RYGEL_TYPE_SERVICE_ACTION (rygel_service_action_get_type ())
#define RYGEL_SERVICE_ACTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_SERVICE_ACTION, RygelServiceAction))
#define RYGEL_SERVICE_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_SERVICE_ACTION, RygelServiceActionClass))
#define RYGEL_IS_SERVICE_ACTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_SERVICE_ACTION))
#define RYGEL_IS_SERVICE_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_SERVICE_ACTION))
#define RYGEL_SERVICE_ACTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_SERVICE_ACTION, RygelServiceActionClass))

typedef struct _RygelServiceAction RygelServiceAction;
typedef struct _RygelServiceActionClass RygelServiceActionClass;
typedef struct _RygelServiceActionPrivate RygelServiceActionPrivate;
#define _g_free0(var) (var = (g_free (var), NULL))

#define RYGEL_TYPE_HTTP_SERVER (rygel_http_server_get_type ())
#define RYGEL_HTTP_SERVER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_HTTP_SERVER, RygelHTTPServer))
#define RYGEL_HTTP_SERVER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_HTTP_SERVER, RygelHTTPServerClass))
#define RYGEL_IS_HTTP_SERVER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_HTTP_SERVER))
#define RYGEL_IS_HTTP_SERVER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_HTTP_SERVER))
#define RYGEL_HTTP_SERVER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_HTTP_SERVER, RygelHTTPServerClass))

typedef struct _RygelHTTPServer RygelHTTPServer;
typedef struct _RygelHTTPServerClass RygelHTTPServerClass;
typedef struct _RygelHTTPServerPrivate RygelHTTPServerPrivate;

#define RYGEL_TYPE_OBJECT_REMOVAL_QUEUE (rygel_object_removal_queue_get_type ())
#define RYGEL_OBJECT_REMOVAL_QUEUE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_OBJECT_REMOVAL_QUEUE, RygelObjectRemovalQueue))
#define RYGEL_OBJECT_REMOVAL_QUEUE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_OBJECT_REMOVAL_QUEUE, RygelObjectRemovalQueueClass))
#define RYGEL_IS_OBJECT_REMOVAL_QUEUE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_OBJECT_REMOVAL_QUEUE))
#define RYGEL_IS_OBJECT_REMOVAL_QUEUE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_OBJECT_REMOVAL_QUEUE))
#define RYGEL_OBJECT_REMOVAL_QUEUE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_OBJECT_REMOVAL_QUEUE, RygelObjectRemovalQueueClass))

typedef struct _RygelObjectRemovalQueue RygelObjectRemovalQueue;
typedef struct _RygelObjectRemovalQueueClass RygelObjectRemovalQueueClass;
typedef struct _RygelObjectRemovalQueuePrivate RygelObjectRemovalQueuePrivate;

#define RYGEL_TYPE_MEDIA_OBJECT (rygel_media_object_get_type ())
#define RYGEL_MEDIA_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_MEDIA_OBJECT, RygelMediaObject))
#define RYGEL_MEDIA_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_MEDIA_OBJECT, RygelMediaObjectClass))
#define RYGEL_IS_MEDIA_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_MEDIA_OBJECT))
#define RYGEL_IS_MEDIA_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_MEDIA_OBJECT))
#define RYGEL_MEDIA_OBJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_MEDIA_OBJECT, RygelMediaObjectClass))

typedef struct _RygelMediaObject RygelMediaObject;
typedef struct _RygelMediaObjectClass RygelMediaObjectClass;

#define RYGEL_TYPE_MEDIA_SERVER_PLUGIN (rygel_media_server_plugin_get_type ())
#define RYGEL_MEDIA_SERVER_PLUGIN(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_MEDIA_SERVER_PLUGIN, RygelMediaServerPlugin))
#define RYGEL_MEDIA_SERVER_PLUGIN_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_MEDIA_SERVER_PLUGIN, RygelMediaServerPluginClass))
#define RYGEL_IS_MEDIA_SERVER_PLUGIN(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_MEDIA_SERVER_PLUGIN))
#define RYGEL_IS_MEDIA_SERVER_PLUGIN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_MEDIA_SERVER_PLUGIN))
#define RYGEL_MEDIA_SERVER_PLUGIN_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_MEDIA_SERVER_PLUGIN, RygelMediaServerPluginClass))

typedef struct _RygelMediaServerPlugin RygelMediaServerPlugin;
typedef struct _RygelMediaServerPluginClass RygelMediaServerPluginClass;
typedef struct _RygelMediaServerPluginPrivate RygelMediaServerPluginPrivate;

#define RYGEL_TYPE_DLNA_PROFILE (rygel_dlna_profile_get_type ())
#define RYGEL_DLNA_PROFILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_DLNA_PROFILE, RygelDLNAProfile))
#define RYGEL_DLNA_PROFILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_DLNA_PROFILE, RygelDLNAProfileClass))
#define RYGEL_IS_DLNA_PROFILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_DLNA_PROFILE))
#define RYGEL_IS_DLNA_PROFILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_DLNA_PROFILE))
#define RYGEL_DLNA_PROFILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_DLNA_PROFILE, RygelDLNAProfileClass))

typedef struct _RygelDLNAProfile RygelDLNAProfile;
typedef struct _RygelDLNAProfileClass RygelDLNAProfileClass;
#define __g_list_free__rygel_dlna_profile_unref0_0(var) ((var == NULL) ? NULL : (var = (_g_list_free__rygel_dlna_profile_unref0_ (var), NULL)))
typedef struct _RygelMediaObjectPrivate RygelMediaObjectPrivate;

#define RYGEL_TYPE_MEDIA_OBJECTS (rygel_media_objects_get_type ())
#define RYGEL_MEDIA_OBJECTS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_MEDIA_OBJECTS, RygelMediaObjects))
#define RYGEL_MEDIA_OBJECTS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_MEDIA_OBJECTS, RygelMediaObjectsClass))
#define RYGEL_IS_MEDIA_OBJECTS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_MEDIA_OBJECTS))
#define RYGEL_IS_MEDIA_OBJECTS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_MEDIA_OBJECTS))
#define RYGEL_MEDIA_OBJECTS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_MEDIA_OBJECTS, RygelMediaObjectsClass))

typedef struct _RygelMediaObjects RygelMediaObjects;
typedef struct _RygelMediaObjectsClass RygelMediaObjectsClass;

#define RYGEL_TYPE_MEDIA_CONTAINER (rygel_media_container_get_type ())
#define RYGEL_MEDIA_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_MEDIA_CONTAINER, RygelMediaContainer))
#define RYGEL_MEDIA_CONTAINER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_MEDIA_CONTAINER, RygelMediaContainerClass))
#define RYGEL_IS_MEDIA_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_MEDIA_CONTAINER))
#define RYGEL_IS_MEDIA_CONTAINER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_MEDIA_CONTAINER))
#define RYGEL_MEDIA_CONTAINER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_MEDIA_CONTAINER, RygelMediaContainerClass))

typedef struct _RygelMediaContainer RygelMediaContainer;
typedef struct _RygelMediaContainerClass RygelMediaContainerClass;
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))

#define RYGEL_TYPE_SERIALIZER (rygel_serializer_get_type ())
#define RYGEL_SERIALIZER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_SERIALIZER, RygelSerializer))
#define RYGEL_SERIALIZER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_SERIALIZER, RygelSerializerClass))
#define RYGEL_IS_SERIALIZER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_SERIALIZER))
#define RYGEL_IS_SERIALIZER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_SERIALIZER))
#define RYGEL_SERIALIZER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_SERIALIZER, RygelSerializerClass))

typedef struct _RygelSerializer RygelSerializer;
typedef struct _RygelSerializerClass RygelSerializerClass;
typedef struct _RygelMediaObjectGetChildrenData RygelMediaObjectGetChildrenData;
typedef struct _RygelMediaObjectFindObjectData RygelMediaObjectFindObjectData;

#define RYGEL_TYPE_TRACKABLE_CONTAINER (rygel_trackable_container_get_type ())
#define RYGEL_TRACKABLE_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_TRACKABLE_CONTAINER, RygelTrackableContainer))
#define RYGEL_IS_TRACKABLE_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_TRACKABLE_CONTAINER))
#define RYGEL_TRACKABLE_CONTAINER_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), RYGEL_TYPE_TRACKABLE_CONTAINER, RygelTrackableContainerIface))

typedef struct _RygelTrackableContainer RygelTrackableContainer;
typedef struct _RygelTrackableContainerIface RygelTrackableContainerIface;

#define RYGEL_TYPE_MEDIA_ITEM (rygel_media_item_get_type ())
#define RYGEL_MEDIA_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_MEDIA_ITEM, RygelMediaItem))
#define RYGEL_MEDIA_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_MEDIA_ITEM, RygelMediaItemClass))
#define RYGEL_IS_MEDIA_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_MEDIA_ITEM))
#define RYGEL_IS_MEDIA_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_MEDIA_ITEM))
#define RYGEL_MEDIA_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_MEDIA_ITEM, RygelMediaItemClass))

typedef struct _RygelMediaItem RygelMediaItem;
typedef struct _RygelMediaItemClass RygelMediaItemClass;

#define RYGEL_TYPE_TRACKABLE_ITEM (rygel_trackable_item_get_type ())
#define RYGEL_TRACKABLE_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_TRACKABLE_ITEM, RygelTrackableItem))
#define RYGEL_IS_TRACKABLE_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_TRACKABLE_ITEM))
#define RYGEL_TRACKABLE_ITEM_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), RYGEL_TYPE_TRACKABLE_ITEM, RygelTrackableItemIface))

typedef struct _RygelTrackableItem RygelTrackableItem;
typedef struct _RygelTrackableItemIface RygelTrackableItemIface;
typedef struct _RygelMediaItemPrivate RygelMediaItemPrivate;

#define RYGEL_TYPE_AUDIO_ITEM (rygel_audio_item_get_type ())
#define RYGEL_AUDIO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_AUDIO_ITEM, RygelAudioItem))
#define RYGEL_AUDIO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_AUDIO_ITEM, RygelAudioItemClass))
#define RYGEL_IS_AUDIO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_AUDIO_ITEM))
#define RYGEL_IS_AUDIO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_AUDIO_ITEM))
#define RYGEL_AUDIO_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_AUDIO_ITEM, RygelAudioItemClass))

typedef struct _RygelAudioItem RygelAudioItem;
typedef struct _RygelAudioItemClass RygelAudioItemClass;
typedef struct _RygelAudioItemPrivate RygelAudioItemPrivate;

#define RYGEL_TYPE_MUSIC_ITEM (rygel_music_item_get_type ())
#define RYGEL_MUSIC_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_MUSIC_ITEM, RygelMusicItem))
#define RYGEL_MUSIC_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_MUSIC_ITEM, RygelMusicItemClass))
#define RYGEL_IS_MUSIC_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_MUSIC_ITEM))
#define RYGEL_IS_MUSIC_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_MUSIC_ITEM))
#define RYGEL_MUSIC_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_MUSIC_ITEM, RygelMusicItemClass))

typedef struct _RygelMusicItem RygelMusicItem;
typedef struct _RygelMusicItemClass RygelMusicItemClass;
typedef struct _RygelMusicItemPrivate RygelMusicItemPrivate;

#define RYGEL_TYPE_IMAGE_ITEM (rygel_image_item_get_type ())
#define RYGEL_IMAGE_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_IMAGE_ITEM, RygelImageItem))
#define RYGEL_IMAGE_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_IMAGE_ITEM, RygelImageItemClass))
#define RYGEL_IS_IMAGE_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_IMAGE_ITEM))
#define RYGEL_IS_IMAGE_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_IMAGE_ITEM))
#define RYGEL_IMAGE_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_IMAGE_ITEM, RygelImageItemClass))

typedef struct _RygelImageItem RygelImageItem;
typedef struct _RygelImageItemClass RygelImageItemClass;
typedef struct _RygelImageItemPrivate RygelImageItemPrivate;

#define RYGEL_TYPE_VIDEO_ITEM (rygel_video_item_get_type ())
#define RYGEL_VIDEO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_VIDEO_ITEM, RygelVideoItem))
#define RYGEL_VIDEO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_VIDEO_ITEM, RygelVideoItemClass))
#define RYGEL_IS_VIDEO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_VIDEO_ITEM))
#define RYGEL_IS_VIDEO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_VIDEO_ITEM))
#define RYGEL_VIDEO_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_VIDEO_ITEM, RygelVideoItemClass))

typedef struct _RygelVideoItem RygelVideoItem;
typedef struct _RygelVideoItemClass RygelVideoItemClass;
typedef struct _RygelVideoItemPrivate RygelVideoItemPrivate;

#define RYGEL_TYPE_PHOTO_ITEM (rygel_photo_item_get_type ())
#define RYGEL_PHOTO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_PHOTO_ITEM, RygelPhotoItem))
#define RYGEL_PHOTO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_PHOTO_ITEM, RygelPhotoItemClass))
#define RYGEL_IS_PHOTO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_PHOTO_ITEM))
#define RYGEL_IS_PHOTO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_PHOTO_ITEM))
#define RYGEL_PHOTO_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_PHOTO_ITEM, RygelPhotoItemClass))

typedef struct _RygelPhotoItem RygelPhotoItem;
typedef struct _RygelPhotoItemClass RygelPhotoItemClass;
typedef struct _RygelPhotoItemPrivate RygelPhotoItemPrivate;

#define RYGEL_TYPE_PLAYLIST_ITEM (rygel_playlist_item_get_type ())
#define RYGEL_PLAYLIST_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_PLAYLIST_ITEM, RygelPlaylistItem))
#define RYGEL_PLAYLIST_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_PLAYLIST_ITEM, RygelPlaylistItemClass))
#define RYGEL_IS_PLAYLIST_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_PLAYLIST_ITEM))
#define RYGEL_IS_PLAYLIST_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_PLAYLIST_ITEM))
#define RYGEL_PLAYLIST_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_PLAYLIST_ITEM, RygelPlaylistItemClass))

typedef struct _RygelPlaylistItem RygelPlaylistItem;
typedef struct _RygelPlaylistItemClass RygelPlaylistItemClass;
typedef struct _RygelPlaylistItemPrivate RygelPlaylistItemPrivate;

#define RYGEL_TYPE_ROOT_DEVICE (rygel_root_device_get_type ())
#define RYGEL_ROOT_DEVICE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_ROOT_DEVICE, RygelRootDevice))
#define RYGEL_ROOT_DEVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_ROOT_DEVICE, RygelRootDeviceClass))
#define RYGEL_IS_ROOT_DEVICE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_ROOT_DEVICE))
#define RYGEL_IS_ROOT_DEVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_ROOT_DEVICE))
#define RYGEL_ROOT_DEVICE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_ROOT_DEVICE, RygelRootDeviceClass))

typedef struct _RygelRootDevice RygelRootDevice;
typedef struct _RygelRootDeviceClass RygelRootDeviceClass;
typedef struct _RygelRootDevicePrivate RygelRootDevicePrivate;

#define RYGEL_TYPE_CONTENT_DIRECTORY (rygel_content_directory_get_type ())
#define RYGEL_CONTENT_DIRECTORY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_CONTENT_DIRECTORY, RygelContentDirectory))
#define RYGEL_CONTENT_DIRECTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_CONTENT_DIRECTORY, RygelContentDirectoryClass))
#define RYGEL_IS_CONTENT_DIRECTORY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_CONTENT_DIRECTORY))
#define RYGEL_IS_CONTENT_DIRECTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_CONTENT_DIRECTORY))
#define RYGEL_CONTENT_DIRECTORY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_CONTENT_DIRECTORY, RygelContentDirectoryClass))

typedef struct _RygelContentDirectory RygelContentDirectory;
typedef struct _RygelContentDirectoryClass RygelContentDirectoryClass;
typedef struct _RygelContentDirectoryPrivate RygelContentDirectoryPrivate;
typedef struct _RygelMediaContainerPrivate RygelMediaContainerPrivate;
typedef struct _Block1Data Block1Data;
typedef struct _RygelMediaContainerFindObjectData RygelMediaContainerFindObjectData;
typedef struct _RygelMediaObjectsPrivate RygelMediaObjectsPrivate;

#define RYGEL_TYPE_WRITABLE_CONTAINER (rygel_writable_container_get_type ())
#define RYGEL_WRITABLE_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_WRITABLE_CONTAINER, RygelWritableContainer))
#define RYGEL_WRITABLE_CONTAINER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_WRITABLE_CONTAINER, RygelWritableContainerClass))
#define RYGEL_IS_WRITABLE_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_WRITABLE_CONTAINER))
#define RYGEL_IS_WRITABLE_CONTAINER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_WRITABLE_CONTAINER))
#define RYGEL_WRITABLE_CONTAINER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_WRITABLE_CONTAINER, RygelWritableContainerClass))

typedef struct _RygelWritableContainer RygelWritableContainer;
typedef struct _RygelWritableContainerClass RygelWritableContainerClass;
typedef struct _RygelWritableContainerPrivate RygelWritableContainerPrivate;
typedef struct _RygelWritableContainerGetWritableData RygelWritableContainerGetWritableData;
typedef struct _RygelWritableContainerAddItemData RygelWritableContainerAddItemData;
typedef struct _RygelWritableContainerAddContainerData RygelWritableContainerAddContainerData;

#define RYGEL_TYPE_SEARCHABLE_CONTAINER (rygel_searchable_container_get_type ())
#define RYGEL_SEARCHABLE_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_SEARCHABLE_CONTAINER, RygelSearchableContainer))
#define RYGEL_SEARCHABLE_CONTAINER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_SEARCHABLE_CONTAINER, RygelSearchableContainerClass))
#define RYGEL_IS_SEARCHABLE_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_SEARCHABLE_CONTAINER))
#define RYGEL_IS_SEARCHABLE_CONTAINER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_SEARCHABLE_CONTAINER))
#define RYGEL_SEARCHABLE_CONTAINER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_SEARCHABLE_CONTAINER, RygelSearchableContainerClass))

typedef struct _RygelSearchableContainer RygelSearchableContainer;
typedef struct _RygelSearchableContainerClass RygelSearchableContainerClass;
typedef struct _RygelSearchableContainerPrivate RygelSearchableContainerPrivate;
#define _rygel_search_expression_unref0(var) ((var == NULL) ? NULL : (var = (rygel_search_expression_unref (var), NULL)))

#define RYGEL_TYPE_SEARCH_EXPRESSION (rygel_search_expression_get_type ())
#define RYGEL_SEARCH_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_SEARCH_EXPRESSION, RygelSearchExpression))
#define RYGEL_SEARCH_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_SEARCH_EXPRESSION, RygelSearchExpressionClass))
#define RYGEL_IS_SEARCH_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_SEARCH_EXPRESSION))
#define RYGEL_IS_SEARCH_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_SEARCH_EXPRESSION))
#define RYGEL_SEARCH_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_SEARCH_EXPRESSION, RygelSearchExpressionClass))

typedef struct _RygelSearchExpression RygelSearchExpression;
typedef struct _RygelSearchExpressionClass RygelSearchExpressionClass;
typedef struct _Block2Data Block2Data;
typedef struct _RygelSearchableContainerSearchData RygelSearchableContainerSearchData;

#define RYGEL_TYPE_TRANSCODER (rygel_transcoder_get_type ())
#define RYGEL_TRANSCODER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_TRANSCODER, RygelTranscoder))
#define RYGEL_TRANSCODER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_TRANSCODER, RygelTranscoderClass))
#define RYGEL_IS_TRANSCODER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_TRANSCODER))
#define RYGEL_IS_TRANSCODER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_TRANSCODER))
#define RYGEL_TRANSCODER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_TRANSCODER, RygelTranscoderClass))

typedef struct _RygelTranscoder RygelTranscoder;
typedef struct _RygelTranscoderClass RygelTranscoderClass;
typedef struct _RygelTranscoderPrivate RygelTranscoderPrivate;
typedef struct _RygelParamSpecTranscoder RygelParamSpecTranscoder;

#define RYGEL_TYPE_HTTP_OBJECT_CREATOR_TEST (rygel_http_object_creator_test_get_type ())
#define RYGEL_HTTP_OBJECT_CREATOR_TEST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_HTTP_OBJECT_CREATOR_TEST, RygelHTTPObjectCreatorTest))
#define RYGEL_HTTP_OBJECT_CREATOR_TEST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_HTTP_OBJECT_CREATOR_TEST, RygelHTTPObjectCreatorTestClass))
#define RYGEL_IS_HTTP_OBJECT_CREATOR_TEST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_HTTP_OBJECT_CREATOR_TEST))
#define RYGEL_IS_HTTP_OBJECT_CREATOR_TEST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_HTTP_OBJECT_CREATOR_TEST))
#define RYGEL_HTTP_OBJECT_CREATOR_TEST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_HTTP_OBJECT_CREATOR_TEST, RygelHTTPObjectCreatorTestClass))

typedef struct _RygelHTTPObjectCreatorTest RygelHTTPObjectCreatorTest;
typedef struct _RygelHTTPObjectCreatorTestClass RygelHTTPObjectCreatorTestClass;
typedef struct _RygelHTTPObjectCreatorTestPrivate RygelHTTPObjectCreatorTestPrivate;
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))

#define TYPE_SERIALIZER_TYPE (serializer_type_get_type ())

#define RYGEL_TYPE_OBJECT_CREATOR (rygel_object_creator_get_type ())
#define RYGEL_OBJECT_CREATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_OBJECT_CREATOR, RygelObjectCreator))
#define RYGEL_OBJECT_CREATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_OBJECT_CREATOR, RygelObjectCreatorClass))
#define RYGEL_IS_OBJECT_CREATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_OBJECT_CREATOR))
#define RYGEL_IS_OBJECT_CREATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_OBJECT_CREATOR))
#define RYGEL_OBJECT_CREATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_OBJECT_CREATOR, RygelObjectCreatorClass))

typedef struct _RygelObjectCreator RygelObjectCreator;
typedef struct _RygelObjectCreatorClass RygelObjectCreatorClass;

#define RYGEL_TYPE_STATE_MACHINE (rygel_state_machine_get_type ())
#define RYGEL_STATE_MACHINE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_STATE_MACHINE, RygelStateMachine))
#define RYGEL_IS_STATE_MACHINE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_STATE_MACHINE))
#define RYGEL_STATE_MACHINE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), RYGEL_TYPE_STATE_MACHINE, RygelStateMachineIface))

typedef struct _RygelStateMachine RygelStateMachine;
typedef struct _RygelStateMachineIface RygelStateMachineIface;
typedef struct _Block3Data Block3Data;
#define _g_main_loop_unref0(var) ((var == NULL) ? NULL : (var = (g_main_loop_unref (var), NULL)))
#define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);

struct _RygelServiceAction {
	GObject parent_instance;
	RygelServiceActionPrivate * priv;
	gint error_code;
	gchar* error_message;
	gchar* id;
	gchar* elements;
};

struct _RygelServiceActionClass {
	GObjectClass parent_class;
};

struct _RygelHTTPServer {
	GObject parent_instance;
	RygelHTTPServerPrivate * priv;
};

struct _RygelHTTPServerClass {
	GObjectClass parent_class;
};

struct _RygelObjectRemovalQueue {
	GObject parent_instance;
	RygelObjectRemovalQueuePrivate * priv;
};

struct _RygelObjectRemovalQueueClass {
	GObjectClass parent_class;
};

struct _RygelMediaServerPlugin {
	GObject parent_instance;
	RygelMediaServerPluginPrivate * priv;
	GList* upload_profiles;
};

struct _RygelMediaServerPluginClass {
	GObjectClass parent_class;
};

struct _RygelMediaObject {
	GObject parent_instance;
	RygelMediaObjectPrivate * priv;
	gchar* ref_id;
	gchar* upnp_class;
	GUPnPOCMFlags ocm_flags;
	GeeArrayList* uris;
	guint object_update_id;
};

struct _RygelMediaObjectClass {
	GObjectClass parent_class;
	void (*get_children) (RygelMediaObject* self, guint offset, guint max_count, const gchar* sort_criteria, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
	RygelMediaObjects* (*get_children_finish) (RygelMediaObject* self, GAsyncResult* _res_, GError** error);
	void (*find_object) (RygelMediaObject* self, const gchar* id, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
	RygelMediaObject* (*find_object_finish) (RygelMediaObject* self, GAsyncResult* _res_, GError** error);
};

struct _RygelMediaObjectPrivate {
	gchar* _id;
	RygelMediaContainer* _parent;
	gchar* _title;
};

struct _RygelMediaObjectGetChildrenData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	RygelMediaObject* self;
	guint offset;
	guint max_count;
	gchar* sort_criteria;
	GCancellable* cancellable;
	RygelMediaObjects* result;
};

struct _RygelMediaObjectFindObjectData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	RygelMediaObject* self;
	gchar* id;
	GCancellable* cancellable;
	RygelMediaObject* result;
};

struct _RygelTrackableContainerIface {
	GTypeInterface parent_iface;
};

struct _RygelTrackableItemIface {
	GTypeInterface parent_iface;
};

struct _RygelMediaItem {
	RygelMediaObject parent_instance;
	RygelMediaItemPrivate * priv;
	gchar* dlna_profile;
	gchar* mime_type;
	glong size;
	gboolean place_holder;
	gchar* date;
};

struct _RygelMediaItemClass {
	RygelMediaObjectClass parent_class;
};

struct _RygelAudioItem {
	RygelMediaItem parent_instance;
	RygelAudioItemPrivate * priv;
	gchar* artist;
	gchar* album;
};

struct _RygelAudioItemClass {
	RygelMediaItemClass parent_class;
};

struct _RygelMusicItem {
	RygelAudioItem parent_instance;
	RygelMusicItemPrivate * priv;
};

struct _RygelMusicItemClass {
	RygelAudioItemClass parent_class;
};

struct _RygelImageItem {
	RygelMediaItem parent_instance;
	RygelImageItemPrivate * priv;
};

struct _RygelImageItemClass {
	RygelMediaItemClass parent_class;
};

struct _RygelVideoItem {
	RygelMediaItem parent_instance;
	RygelVideoItemPrivate * priv;
};

struct _RygelVideoItemClass {
	RygelMediaItemClass parent_class;
};

struct _RygelPhotoItem {
	RygelMediaItem parent_instance;
	RygelPhotoItemPrivate * priv;
	gchar* creator;
};

struct _RygelPhotoItemClass {
	RygelMediaItemClass parent_class;
};

struct _RygelPlaylistItem {
	RygelMediaItem parent_instance;
	RygelPlaylistItemPrivate * priv;
};

struct _RygelPlaylistItemClass {
	RygelMediaItemClass parent_class;
};

struct _RygelRootDevice {
	GObject parent_instance;
	RygelRootDevicePrivate * priv;
	RygelMediaServerPlugin* resource_factory;
};

struct _RygelRootDeviceClass {
	GObjectClass parent_class;
};

struct _RygelContentDirectory {
	GObject parent_instance;
	RygelContentDirectoryPrivate * priv;
	GCancellable* cancellable;
	RygelMediaContainer* root_container;
	RygelHTTPServer* http_server;
	RygelRootDevice* root_device;
};

struct _RygelContentDirectoryClass {
	GObjectClass parent_class;
};

struct _RygelMediaContainer {
	RygelMediaObject parent_instance;
	RygelMediaContainerPrivate * priv;
	GeeArrayList* create_classes;
	gchar* sort_criteria;
	guint update_id;
	RygelMediaObject* found_object;
};

struct _RygelMediaContainerClass {
	RygelMediaObjectClass parent_class;
};

struct _RygelMediaContainerPrivate {
	gint _child_count;
};

struct _Block1Data {
	int _ref_count_;
	RygelMediaContainer* self;
	gpointer _async_data_;
};

struct _RygelMediaContainerFindObjectData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	RygelMediaContainer* self;
	gchar* id;
	GCancellable* cancellable;
	RygelMediaObject* result;
	Block1Data* _data1_;
	RygelMediaObject* _tmp0_;
	RygelMediaObject* _tmp1_;
};

struct _RygelMediaObjects {
	GeeArrayList parent_instance;
	RygelMediaObjectsPrivate * priv;
};

struct _RygelMediaObjectsClass {
	GeeArrayListClass parent_class;
};

struct _RygelWritableContainer {
	RygelMediaContainer parent_instance;
	RygelWritableContainerPrivate * priv;
};

struct _RygelWritableContainerClass {
	RygelMediaContainerClass parent_class;
};

struct _RygelWritableContainerGetWritableData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	RygelWritableContainer* self;
	GCancellable* cancellable;
	GFile* result;
	GFile* _tmp0_;
};

struct _RygelWritableContainerAddItemData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	RygelWritableContainer* self;
	RygelMediaItem* item;
	GCancellable* cancellable;
};

struct _RygelWritableContainerAddContainerData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	RygelWritableContainer* self;
	RygelMediaContainer* container;
	GCancellable* cancellable;
};

struct _RygelSearchableContainer {
	RygelMediaContainer parent_instance;
	RygelSearchableContainerPrivate * priv;
	RygelMediaObjects* result;
};

struct _RygelSearchableContainerClass {
	RygelMediaContainerClass parent_class;
};

struct _Block2Data {
	int _ref_count_;
	RygelSearchableContainer* self;
	gpointer _async_data_;
};

struct _RygelSearchableContainerSearchData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GSimpleAsyncResult* _async_result;
	RygelSearchableContainer* self;
	RygelSearchExpression* expression;
	gint offset;
	gint count;
	gint total_matches;
	gchar* soer_criteria;
	GCancellable* cancellable;
	RygelMediaObjects* result;
	Block2Data* _data2_;
	RygelMediaObjects* _tmp0_;
	RygelMediaObjects* _tmp1_;
};

typedef enum  {
	RYGEL_CONTENT_DIRECTORY_ERROR_BAD_METADATA,
	RYGEL_CONTENT_DIRECTORY_ERROR_NO_SUCH_OBJECT,
	RYGEL_CONTENT_DIRECTORY_ERROR_NO_SUCH_CONTAINER,
	RYGEL_CONTENT_DIRECTORY_ERROR_INVALID_ARGS,
	RYGEL_CONTENT_DIRECTORY_ERROR_RESTRICTED_PARENT,
	RYGEL_CONTENT_DIRECTORY_ERROR_ERROR
} RygelContentDirectoryError;
#define RYGEL_CONTENT_DIRECTORY_ERROR rygel_content_directory_error_quark ()
struct _RygelTranscoder {
	GTypeInstance parent_instance;
	volatile int ref_count;
	RygelTranscoderPrivate * priv;
};

struct _RygelTranscoderClass {
	GTypeClass parent_class;
	void (*finalize) (RygelTranscoder *self);
};

struct _RygelParamSpecTranscoder {
	GParamSpec parent_instance;
};

struct _RygelHTTPObjectCreatorTest {
	GObject parent_instance;
	RygelHTTPObjectCreatorTestPrivate * priv;
};

struct _RygelHTTPObjectCreatorTestClass {
	GObjectClass parent_class;
};

struct _RygelHTTPObjectCreatorTestPrivate {
	GError* no_such_object;
	GError* no_such_container;
	GError* restricted_parent;
	GError* bad_metadata;
	GError* invalid_args;
};

typedef enum  {
	SERIALIZER_TYPE_GENERIC_DIDL,
	SERIALIZER_TYPE_DIDL_S,
	SERIALIZER_TYPE_M3UEXT
} SerializerType;

struct _RygelStateMachineIface {
	GTypeInterface parent_iface;
	void (*run) (RygelStateMachine* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
	void (*run_finish) (RygelStateMachine* self, GAsyncResult* _res_);
	GCancellable* (*get_cancellable) (RygelStateMachine* self);
	void (*set_cancellable) (RygelStateMachine* self, GCancellable* value);
};

struct _Block3Data {
	int _ref_count_;
	RygelHTTPObjectCreatorTest* self;
	GMainLoop* main_loop;
};


static gpointer rygel_service_action_parent_class = NULL;
static gpointer rygel_http_server_parent_class = NULL;
static gpointer rygel_object_removal_queue_parent_class = NULL;
static gpointer rygel_media_server_plugin_parent_class = NULL;
static gpointer rygel_media_object_parent_class = NULL;
static gpointer rygel_media_item_parent_class = NULL;
static gpointer rygel_music_item_parent_class = NULL;
static gpointer rygel_audio_item_parent_class = NULL;
static gpointer rygel_image_item_parent_class = NULL;
static gpointer rygel_video_item_parent_class = NULL;
static gpointer rygel_photo_item_parent_class = NULL;
static gpointer rygel_playlist_item_parent_class = NULL;
static gpointer rygel_root_device_parent_class = NULL;
static gpointer rygel_content_directory_parent_class = NULL;
static gpointer rygel_media_container_parent_class = NULL;
static gpointer rygel_media_objects_parent_class = NULL;
static gpointer rygel_writable_container_parent_class = NULL;
static gpointer rygel_searchable_container_parent_class = NULL;
static gpointer rygel_transcoder_parent_class = NULL;
static gpointer rygel_http_object_creator_test_parent_class = NULL;

#define DIDL_ITEM "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" \
"<DIDL-Lite\n" \
"    xmlns:dc=\"http://purl.org/dc/elements/1.1/\"\n" \
"    xmlns=\"urn:schemas-upnp-org:metadata-1-0/DIDL-Lite/\"\n" \
"    xmlns:upnp=\"urn:schemas-upnp-org:metadata-1-0/upnp/\"\n" \
"    xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n" \
"    xsi:schemaLocation=\"urn:schemas-upnp-org:metadata-1-0/DIDL-Lite/\n" \
"        http://www.upnp.org/schemas/av/didl-lite-v2-20060531.xsd\n" \
"      urn:schemas-upnp-org:metadata-1-0/upnp/\n" \
"        http://www.upnp.org/schemas/av/upnp-v2-20060531.xsd\">\n" \
"    <item id=\"\" parentID=\"0\" restricted=\"0\">\n" \
"        <dc:title>New Song</dc:title>\n" \
"        <upnp:class>object.item.audioItem</upnp:class>\n" \
"        <res protocolInfo=\"*:*:*:*\" />\n" \
"    </item>\n" \
"</DIDL-Lite>"
GType rygel_service_action_get_type (void) G_GNUC_CONST;
enum  {
	RYGEL_SERVICE_ACTION_DUMMY_PROPERTY
};
RygelServiceAction* rygel_service_action_new (const gchar* container_id, const gchar* elements);
RygelServiceAction* rygel_service_action_construct (GType object_type, const gchar* container_id, const gchar* elements);
void rygel_service_action_return (RygelServiceAction* self);
void rygel_service_action_return_error (RygelServiceAction* self, gint code, const gchar* message);
void rygel_service_action_get (RygelServiceAction* self, const gchar* arg1_name, GType arg1_type, gchar** arg1_val, const gchar* arg2_name, GType arg2_type, gchar** arg2_val);
void rygel_service_action_set (RygelServiceAction* self, const gchar* arg1_name, GType arg1_type, const gchar* arg1_val, const gchar* arg2_name, GType arg2_type, const gchar* arg2_val);
static void rygel_service_action_finalize (GObject* obj);
GType rygel_http_server_get_type (void) G_GNUC_CONST;
enum  {
	RYGEL_HTTP_SERVER_DUMMY_PROPERTY
};
RygelHTTPServer* rygel_http_server_new (void);
RygelHTTPServer* rygel_http_server_construct (GType object_type);
GType rygel_object_removal_queue_get_type (void) G_GNUC_CONST;
enum  {
	RYGEL_OBJECT_REMOVAL_QUEUE_DUMMY_PROPERTY
};
RygelObjectRemovalQueue* rygel_object_removal_queue_get_default (void);
RygelObjectRemovalQueue* rygel_object_removal_queue_new (void);
RygelObjectRemovalQueue* rygel_object_removal_queue_construct (GType object_type);
GType rygel_media_object_get_type (void) G_GNUC_CONST;
void rygel_object_removal_queue_queue (RygelObjectRemovalQueue* self, RygelMediaObject* object, GCancellable* cancellable);
GType rygel_media_server_plugin_get_type (void) G_GNUC_CONST;
gpointer rygel_dlna_profile_ref (gpointer instance);
void rygel_dlna_profile_unref (gpointer instance);
GParamSpec* rygel_param_spec_dlna_profile (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
void rygel_value_set_dlna_profile (GValue* value, gpointer v_object);
void rygel_value_take_dlna_profile (GValue* value, gpointer v_object);
gpointer rygel_value_get_dlna_profile (const GValue* value);
GType rygel_dlna_profile_get_type (void) G_GNUC_CONST;
enum  {
	RYGEL_MEDIA_SERVER_PLUGIN_DUMMY_PROPERTY
};
static void _rygel_dlna_profile_unref0_ (gpointer var);
static void _g_list_free__rygel_dlna_profile_unref0_ (GList* self);
RygelMediaServerPlugin* rygel_media_server_plugin_new (void);
RygelMediaServerPlugin* rygel_media_server_plugin_construct (GType object_type);
static void rygel_media_server_plugin_finalize (GObject* obj);
GType rygel_media_objects_get_type (void) G_GNUC_CONST;
GType rygel_media_container_get_type (void) G_GNUC_CONST;
#define RYGEL_MEDIA_OBJECT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), RYGEL_TYPE_MEDIA_OBJECT, RygelMediaObjectPrivate))
enum  {
	RYGEL_MEDIA_OBJECT_DUMMY_PROPERTY,
	RYGEL_MEDIA_OBJECT_ID,
	RYGEL_MEDIA_OBJECT_PARENT,
	RYGEL_MEDIA_OBJECT_TITLE
};
void rygel_media_object_add_uri (RygelMediaObject* self, const gchar* uri);
GType rygel_serializer_get_type (void) G_GNUC_CONST;
void rygel_media_object_serialize (RygelMediaObject* self, RygelSerializer* serializer, RygelHTTPServer* server);
void rygel_media_object_apply_didl_lite (RygelMediaObject* self, GUPnPDIDLLiteObject* object);
static void rygel_media_object_real_get_children_data_free (gpointer _data);
static void rygel_media_object_real_get_children (RygelMediaObject* self, guint offset, guint max_count, const gchar* sort_criteria, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
void rygel_media_object_get_children (RygelMediaObject* self, guint offset, guint max_count, const gchar* sort_criteria, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
RygelMediaObjects* rygel_media_object_get_children_finish (RygelMediaObject* self, GAsyncResult* _res_, GError** error);
static gboolean rygel_media_object_real_get_children_co (RygelMediaObjectGetChildrenData* _data_);
static void rygel_media_object_real_find_object_data_free (gpointer _data);
static void rygel_media_object_real_find_object (RygelMediaObject* self, const gchar* id, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
void rygel_media_object_find_object (RygelMediaObject* self, const gchar* id, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
RygelMediaObject* rygel_media_object_find_object_finish (RygelMediaObject* self, GAsyncResult* _res_, GError** error);
static gboolean rygel_media_object_real_find_object_co (RygelMediaObjectFindObjectData* _data_);
RygelMediaObject* rygel_media_object_new (void);
RygelMediaObject* rygel_media_object_construct (GType object_type);
const gchar* rygel_media_object_get_id (RygelMediaObject* self);
void rygel_media_object_set_id (RygelMediaObject* self, const gchar* value);
RygelMediaContainer* rygel_media_object_get_parent (RygelMediaObject* self);
void rygel_media_object_set_parent (RygelMediaObject* self, RygelMediaContainer* value);
const gchar* rygel_media_object_get_title (RygelMediaObject* self);
void rygel_media_object_set_title (RygelMediaObject* self, const gchar* value);
static void rygel_media_object_finalize (GObject* obj);
static void _vala_rygel_media_object_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
static void _vala_rygel_media_object_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
GType rygel_trackable_container_get_type (void) G_GNUC_CONST;
GType rygel_media_item_get_type (void) G_GNUC_CONST;
GType rygel_trackable_item_get_type (void) G_GNUC_CONST;
enum  {
	RYGEL_MEDIA_ITEM_DUMMY_PROPERTY
};
RygelMediaItem* rygel_media_item_new (const gchar* id, RygelMediaContainer* parent, const gchar* title);
RygelMediaItem* rygel_media_item_construct (GType object_type, const gchar* id, RygelMediaContainer* parent, const gchar* title);
static void rygel_media_item_finalize (GObject* obj);
GType rygel_audio_item_get_type (void) G_GNUC_CONST;
GType rygel_music_item_get_type (void) G_GNUC_CONST;
enum  {
	RYGEL_MUSIC_ITEM_DUMMY_PROPERTY
};
#define RYGEL_MUSIC_ITEM_UPNP_CLASS "object.item.audioItem.musicTrack"
RygelMusicItem* rygel_music_item_new (const gchar* id, RygelMediaContainer* parent, const gchar* title);
RygelMusicItem* rygel_music_item_construct (GType object_type, const gchar* id, RygelMediaContainer* parent, const gchar* title);
RygelAudioItem* rygel_audio_item_new (const gchar* id, RygelMediaContainer* parent, const gchar* title);
RygelAudioItem* rygel_audio_item_construct (GType object_type, const gchar* id, RygelMediaContainer* parent, const gchar* title);
enum  {
	RYGEL_AUDIO_ITEM_DUMMY_PROPERTY
};
#define RYGEL_AUDIO_ITEM_UPNP_CLASS "object.item.audioItem"
static void rygel_audio_item_finalize (GObject* obj);
GType rygel_image_item_get_type (void) G_GNUC_CONST;
enum  {
	RYGEL_IMAGE_ITEM_DUMMY_PROPERTY
};
#define RYGEL_IMAGE_ITEM_UPNP_CLASS "object.item.imageItem"
RygelImageItem* rygel_image_item_new (const gchar* id, RygelMediaContainer* parent, const gchar* title);
RygelImageItem* rygel_image_item_construct (GType object_type, const gchar* id, RygelMediaContainer* parent, const gchar* title);
GType rygel_video_item_get_type (void) G_GNUC_CONST;
enum  {
	RYGEL_VIDEO_ITEM_DUMMY_PROPERTY
};
#define RYGEL_VIDEO_ITEM_UPNP_CLASS "object.item.videoItem"
RygelVideoItem* rygel_video_item_new (const gchar* id, RygelMediaContainer* parent, const gchar* title);
RygelVideoItem* rygel_video_item_construct (GType object_type, const gchar* id, RygelMediaContainer* parent, const gchar* title);
GType rygel_photo_item_get_type (void) G_GNUC_CONST;
enum  {
	RYGEL_PHOTO_ITEM_DUMMY_PROPERTY
};
#define RYGEL_PHOTO_ITEM_UPNP_CLASS "object.item.imageItem.photo"
RygelPhotoItem* rygel_photo_item_new (const gchar* id, RygelMediaContainer* parent, const gchar* title);
RygelPhotoItem* rygel_photo_item_construct (GType object_type, const gchar* id, RygelMediaContainer* parent, const gchar* title);
static void rygel_photo_item_finalize (GObject* obj);
GType rygel_playlist_item_get_type (void) G_GNUC_CONST;
enum  {
	RYGEL_PLAYLIST_ITEM_DUMMY_PROPERTY
};
#define RYGEL_PLAYLIST_ITEM_UPNP_CLASS "object.item.playlistItem"
RygelPlaylistItem* rygel_playlist_item_new (const gchar* id, RygelMediaContainer* parent, const gchar* title);
RygelPlaylistItem* rygel_playlist_item_construct (GType object_type, const gchar* id, RygelMediaContainer* parent, const gchar* title);
GType rygel_root_device_get_type (void) G_GNUC_CONST;
enum  {
	RYGEL_ROOT_DEVICE_DUMMY_PROPERTY
};
RygelRootDevice* rygel_root_device_new (void);
RygelRootDevice* rygel_root_device_construct (GType object_type);
static void rygel_root_device_finalize (GObject* obj);
GType rygel_content_directory_get_type (void) G_GNUC_CONST;
enum  {
	RYGEL_CONTENT_DIRECTORY_DUMMY_PROPERTY
};
RygelContentDirectory* rygel_content_directory_new (void);
RygelContentDirectory* rygel_content_directory_construct (GType object_type);
static void rygel_content_directory_finalize (GObject* obj);
#define RYGEL_MEDIA_CONTAINER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), RYGEL_TYPE_MEDIA_CONTAINER, RygelMediaContainerPrivate))
enum  {
	RYGEL_MEDIA_CONTAINER_DUMMY_PROPERTY,
	RYGEL_MEDIA_CONTAINER_CHILD_COUNT
};
#define RYGEL_MEDIA_CONTAINER_ANY "DLNA.ORG_AnyContainer"
#define RYGEL_MEDIA_CONTAINER_UPNP_CLASS "object.container"
#define RYGEL_MEDIA_CONTAINER_STORAGE_FOLDER "object.container.storageFolder"
#define RYGEL_MEDIA_CONTAINER_PLAYLIST "object.container.playlistContainer"
static void rygel_media_container_real_find_object_data_free (gpointer _data);
static void rygel_media_container_real_find_object (RygelMediaObject* base, const gchar* id, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean rygel_media_container_real_find_object_co (RygelMediaContainerFindObjectData* _data_);
static Block1Data* block1_data_ref (Block1Data* _data1_);
static void block1_data_unref (void * _userdata_);
static gboolean __lambda4_ (Block1Data* _data1_);
static gboolean ___lambda4__gsource_func (gpointer self);
RygelMediaContainer* rygel_media_container_new (void);
RygelMediaContainer* rygel_media_container_construct (GType object_type);
gint rygel_media_container_get_child_count (RygelMediaContainer* self);
void rygel_media_container_set_child_count (RygelMediaContainer* self, gint value);
static void rygel_media_container_finalize (GObject* obj);
static void _vala_rygel_media_container_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
static void _vala_rygel_media_container_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
enum  {
	RYGEL_MEDIA_OBJECTS_DUMMY_PROPERTY
};
RygelMediaObjects* rygel_media_objects_new (void);
RygelMediaObjects* rygel_media_objects_construct (GType object_type);
GType rygel_writable_container_get_type (void) G_GNUC_CONST;
enum  {
	RYGEL_WRITABLE_CONTAINER_DUMMY_PROPERTY
};
gboolean rygel_writable_container_can_create (RygelWritableContainer* self, const gchar* upnp_class);
static void rygel_writable_container_get_writable_data_free (gpointer _data);
void rygel_writable_container_get_writable (RygelWritableContainer* self, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
GFile* rygel_writable_container_get_writable_finish (RygelWritableContainer* self, GAsyncResult* _res_);
static gboolean rygel_writable_container_get_writable_co (RygelWritableContainerGetWritableData* _data_);
static void rygel_writable_container_add_item_data_free (gpointer _data);
void rygel_writable_container_add_item (RygelWritableContainer* self, RygelMediaItem* item, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
void rygel_writable_container_add_item_finish (RygelWritableContainer* self, GAsyncResult* _res_);
static gboolean rygel_writable_container_add_item_co (RygelWritableContainerAddItemData* _data_);
static void rygel_writable_container_add_container_data_free (gpointer _data);
void rygel_writable_container_add_container (RygelWritableContainer* self, RygelMediaContainer* container, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
void rygel_writable_container_add_container_finish (RygelWritableContainer* self, GAsyncResult* _res_);
static gboolean rygel_writable_container_add_container_co (RygelWritableContainerAddContainerData* _data_);
RygelWritableContainer* rygel_writable_container_new (void);
RygelWritableContainer* rygel_writable_container_construct (GType object_type);
GType rygel_searchable_container_get_type (void) G_GNUC_CONST;
enum  {
	RYGEL_SEARCHABLE_CONTAINER_DUMMY_PROPERTY
};
static void rygel_searchable_container_search_data_free (gpointer _data);
gpointer rygel_search_expression_ref (gpointer instance);
void rygel_search_expression_unref (gpointer instance);
GParamSpec* rygel_param_spec_search_expression (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
void rygel_value_set_search_expression (GValue* value, gpointer v_object);
void rygel_value_take_search_expression (GValue* value, gpointer v_object);
gpointer rygel_value_get_search_expression (const GValue* value);
GType rygel_search_expression_get_type (void) G_GNUC_CONST;
void rygel_searchable_container_search (RygelSearchableContainer* self, RygelSearchExpression* expression, gint offset, gint count, const gchar* soer_criteria, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
RygelMediaObjects* rygel_searchable_container_search_finish (RygelSearchableContainer* self, GAsyncResult* _res_, gint* total_matches);
static gboolean rygel_searchable_container_search_co (RygelSearchableContainerSearchData* _data_);
static Block2Data* block2_data_ref (Block2Data* _data2_);
static void block2_data_unref (void * _userdata_);
static gboolean __lambda5_ (Block2Data* _data2_);
static gboolean ___lambda5__gsource_func (gpointer self);
RygelSearchableContainer* rygel_searchable_container_new (void);
RygelSearchableContainer* rygel_searchable_container_construct (GType object_type);
static void rygel_searchable_container_finalize (GObject* obj);
GQuark rygel_content_directory_error_quark (void);
gpointer rygel_transcoder_ref (gpointer instance);
void rygel_transcoder_unref (gpointer instance);
GParamSpec* rygel_param_spec_transcoder (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
void rygel_value_set_transcoder (GValue* value, gpointer v_object);
void rygel_value_take_transcoder (GValue* value, gpointer v_object);
gpointer rygel_value_get_transcoder (const GValue* value);
GType rygel_transcoder_get_type (void) G_GNUC_CONST;
enum  {
	RYGEL_TRANSCODER_DUMMY_PROPERTY
};
RygelTranscoder* rygel_transcoder_new (void);
RygelTranscoder* rygel_transcoder_construct (GType object_type);
static void rygel_transcoder_finalize (RygelTranscoder* obj);
void log_func (const gchar* domain, GLogLevelFlags flags, const gchar* message);
GType rygel_http_object_creator_test_get_type (void) G_GNUC_CONST;
#define RYGEL_HTTP_OBJECT_CREATOR_TEST_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), RYGEL_TYPE_HTTP_OBJECT_CREATOR_TEST, RygelHTTPObjectCreatorTestPrivate))
enum  {
	RYGEL_HTTP_OBJECT_CREATOR_TEST_DUMMY_PROPERTY
};
gint rygel_http_object_creator_test_main (gchar** args, int args_length1);
static void _log_func_glog_func (const gchar* log_domain, GLogLevelFlags log_levels, const gchar* message, gpointer self);
RygelHTTPObjectCreatorTest* rygel_http_object_creator_test_new (void);
RygelHTTPObjectCreatorTest* rygel_http_object_creator_test_construct (GType object_type);
static void rygel_http_object_creator_test_test_parse_args (RygelHTTPObjectCreatorTest* self);
static void rygel_http_object_creator_test_test_didl_parsing (RygelHTTPObjectCreatorTest* self);
static void rygel_http_object_creator_test_test_fetch_container (RygelHTTPObjectCreatorTest* self);
GType serializer_type_get_type (void) G_GNUC_CONST;
RygelSerializer* rygel_serializer_new (SerializerType type);
RygelSerializer* rygel_serializer_construct (GType object_type, SerializerType type);
GUPnPDIDLLiteItem* rygel_serializer_add_item (RygelSerializer* self);
GUPnPDIDLLiteContainer* rygel_serializer_add_container (RygelSerializer* self);
void rygel_serializer_filter (RygelSerializer* self, const gchar* filter_string);
GType rygel_object_creator_get_type (void) G_GNUC_CONST;
RygelObjectCreator* rygel_object_creator_new (RygelContentDirectory* content_dir, RygelServiceAction* action);
RygelObjectCreator* rygel_object_creator_construct (GType object_type, RygelContentDirectory* content_dir, RygelServiceAction* action);
GType rygel_state_machine_get_type (void) G_GNUC_CONST;
void rygel_state_machine_run (RygelStateMachine* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
void rygel_state_machine_run_finish (RygelStateMachine* self, GAsyncResult* _res_);
static void rygel_http_object_creator_test_test_didl_parsing_step (RygelHTTPObjectCreatorTest* self, xmlDoc* doc, gint expected_code);
static void rygel_http_object_creator_test_test_fetch_container_run (RygelHTTPObjectCreatorTest* self, RygelObjectCreator* creator);
static Block3Data* block3_data_ref (Block3Data* _data3_);
static void block3_data_unref (void * _userdata_);
static void __lambda9_ (Block3Data* _data3_);
static void ___lambda9__gasync_ready_callback (GObject* source_object, GAsyncResult* res, gpointer self);
static void rygel_http_object_creator_test_finalize (GObject* obj);


RygelServiceAction* rygel_service_action_construct (GType object_type, const gchar* container_id, const gchar* elements) {
	RygelServiceAction * self = NULL;
	const gchar* _tmp0_ = NULL;
	gchar* _tmp1_ = NULL;
	const gchar* _tmp2_ = NULL;
	gchar* _tmp3_ = NULL;
	self = (RygelServiceAction*) g_object_new (object_type, NULL);
	_tmp0_ = container_id;
	_tmp1_ = g_strdup (_tmp0_);
	_g_free0 (self->id);
	self->id = _tmp1_;
	_tmp2_ = elements;
	_tmp3_ = g_strdup (_tmp2_);
	_g_free0 (self->elements);
	self->elements = _tmp3_;
	return self;
}


RygelServiceAction* rygel_service_action_new (const gchar* container_id, const gchar* elements) {
	return rygel_service_action_construct (RYGEL_TYPE_SERVICE_ACTION, container_id, elements);
}


void rygel_service_action_return (RygelServiceAction* self) {
	g_return_if_fail (self != NULL);
}


void rygel_service_action_return_error (RygelServiceAction* self, gint code, const gchar* message) {
	gint _tmp0_ = 0;
	const gchar* _tmp1_ = NULL;
	gchar* _tmp2_ = NULL;
	g_return_if_fail (self != NULL);
	g_return_if_fail (message != NULL);
	_tmp0_ = code;
	self->error_code = _tmp0_;
	_tmp1_ = message;
	_tmp2_ = g_strdup (_tmp1_);
	_g_free0 (self->error_message);
	self->error_message = _tmp2_;
}


void rygel_service_action_get (RygelServiceAction* self, const gchar* arg1_name, GType arg1_type, gchar** arg1_val, const gchar* arg2_name, GType arg2_type, gchar** arg2_val) {
	gchar* _vala_arg1_val = NULL;
	gchar* _vala_arg2_val = NULL;
	const gchar* _tmp0_ = NULL;
	GType _tmp1_ = 0UL;
	const gchar* _tmp2_ = NULL;
	gchar* _tmp3_ = NULL;
	const gchar* _tmp4_ = NULL;
	GType _tmp5_ = 0UL;
	const gchar* _tmp6_ = NULL;
	gchar* _tmp7_ = NULL;
	g_return_if_fail (self != NULL);
	g_return_if_fail (arg1_name != NULL);
	g_return_if_fail (arg2_name != NULL);
	_tmp0_ = arg1_name;
	_vala_assert (g_strcmp0 (_tmp0_, "ContainerID") == 0, "arg1_name == \"ContainerID\"");
	_tmp1_ = arg1_type;
	_vala_assert (_tmp1_ == G_TYPE_STRING, "arg1_type == typeof (string)");
	_tmp2_ = self->id;
	_tmp3_ = g_strdup (_tmp2_);
	_g_free0 (_vala_arg1_val);
	_vala_arg1_val = _tmp3_;
	_tmp4_ = arg2_name;
	_vala_assert (g_strcmp0 (_tmp4_, "Elements") == 0, "arg2_name == \"Elements\"");
	_tmp5_ = arg2_type;
	_vala_assert (_tmp5_ == G_TYPE_STRING, "arg2_type == typeof (string)");
	_tmp6_ = self->elements;
	_tmp7_ = g_strdup (_tmp6_);
	_g_free0 (_vala_arg2_val);
	_vala_arg2_val = _tmp7_;
	if (arg1_val) {
		*arg1_val = _vala_arg1_val;
	} else {
		_g_free0 (_vala_arg1_val);
	}
	if (arg2_val) {
		*arg2_val = _vala_arg2_val;
	} else {
		_g_free0 (_vala_arg2_val);
	}
}


void rygel_service_action_set (RygelServiceAction* self, const gchar* arg1_name, GType arg1_type, const gchar* arg1_val, const gchar* arg2_name, GType arg2_type, const gchar* arg2_val) {
	const gchar* _tmp0_ = NULL;
	GType _tmp1_ = 0UL;
	const gchar* _tmp2_ = NULL;
	GType _tmp3_ = 0UL;
	g_return_if_fail (self != NULL);
	g_return_if_fail (arg1_name != NULL);
	g_return_if_fail (arg1_val != NULL);
	g_return_if_fail (arg2_name != NULL);
	g_return_if_fail (arg2_val != NULL);
	_tmp0_ = arg1_name;
	_vala_assert (g_strcmp0 (_tmp0_, "ObjectID") == 0, "arg1_name == \"ObjectID\"");
	_tmp1_ = arg1_type;
	_vala_assert (_tmp1_ == G_TYPE_STRING, "arg1_type == typeof (string)");
	_tmp2_ = arg2_name;
	_vala_assert (g_strcmp0 (_tmp2_, "Result") == 0, "arg2_name == \"Result\"");
	_tmp3_ = arg2_type;
	_vala_assert (_tmp3_ == G_TYPE_STRING, "arg2_type == typeof (string)");
}


static void rygel_service_action_class_init (RygelServiceActionClass * klass) {
	rygel_service_action_parent_class = g_type_class_peek_parent (klass);
	G_OBJECT_CLASS (klass)->finalize = rygel_service_action_finalize;
}


static void rygel_service_action_instance_init (RygelServiceAction * self) {
}


static void rygel_service_action_finalize (GObject* obj) {
	RygelServiceAction * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, RYGEL_TYPE_SERVICE_ACTION, RygelServiceAction);
	_g_free0 (self->error_message);
	_g_free0 (self->id);
	_g_free0 (self->elements);
	G_OBJECT_CLASS (rygel_service_action_parent_class)->finalize (obj);
}


GType rygel_service_action_get_type (void) {
	static volatile gsize rygel_service_action_type_id__volatile = 0;
	if (g_once_init_enter (&rygel_service_action_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (RygelServiceActionClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) rygel_service_action_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (RygelServiceAction), 0, (GInstanceInitFunc) rygel_service_action_instance_init, NULL };
		GType rygel_service_action_type_id;
		rygel_service_action_type_id = g_type_register_static (G_TYPE_OBJECT, "RygelServiceAction", &g_define_type_info, 0);
		g_once_init_leave (&rygel_service_action_type_id__volatile, rygel_service_action_type_id);
	}
	return rygel_service_action_type_id__volatile;
}


RygelHTTPServer* rygel_http_server_construct (GType object_type) {
	RygelHTTPServer * self = NULL;
	self = (RygelHTTPServer*) g_object_new (object_type, NULL);
	return self;
}


RygelHTTPServer* rygel_http_server_new (void) {
	return rygel_http_server_construct (RYGEL_TYPE_HTTP_SERVER);
}


static void rygel_http_server_class_init (RygelHTTPServerClass * klass) {
	rygel_http_server_parent_class = g_type_class_peek_parent (klass);
}


static void rygel_http_server_instance_init (RygelHTTPServer * self) {
}


GType rygel_http_server_get_type (void) {
	static volatile gsize rygel_http_server_type_id__volatile = 0;
	if (g_once_init_enter (&rygel_http_server_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (RygelHTTPServerClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) rygel_http_server_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (RygelHTTPServer), 0, (GInstanceInitFunc) rygel_http_server_instance_init, NULL };
		GType rygel_http_server_type_id;
		rygel_http_server_type_id = g_type_register_static (G_TYPE_OBJECT, "RygelHTTPServer", &g_define_type_info, 0);
		g_once_init_leave (&rygel_http_server_type_id__volatile, rygel_http_server_type_id);
	}
	return rygel_http_server_type_id__volatile;
}


RygelObjectRemovalQueue* rygel_object_removal_queue_get_default (void) {
	RygelObjectRemovalQueue* result = NULL;
	RygelObjectRemovalQueue* _tmp0_ = NULL;
	_tmp0_ = rygel_object_removal_queue_new ();
	result = _tmp0_;
	return result;
}


void rygel_object_removal_queue_queue (RygelObjectRemovalQueue* self, RygelMediaObject* object, GCancellable* cancellable) {
	g_return_if_fail (self != NULL);
	g_return_if_fail (object != NULL);
}


RygelObjectRemovalQueue* rygel_object_removal_queue_construct (GType object_type) {
	RygelObjectRemovalQueue * self = NULL;
	self = (RygelObjectRemovalQueue*) g_object_new (object_type, NULL);
	return self;
}


RygelObjectRemovalQueue* rygel_object_removal_queue_new (void) {
	return rygel_object_removal_queue_construct (RYGEL_TYPE_OBJECT_REMOVAL_QUEUE);
}


static void rygel_object_removal_queue_class_init (RygelObjectRemovalQueueClass * klass) {
	rygel_object_removal_queue_parent_class = g_type_class_peek_parent (klass);
}


static void rygel_object_removal_queue_instance_init (RygelObjectRemovalQueue * self) {
}


GType rygel_object_removal_queue_get_type (void) {
	static volatile gsize rygel_object_removal_queue_type_id__volatile = 0;
	if (g_once_init_enter (&rygel_object_removal_queue_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (RygelObjectRemovalQueueClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) rygel_object_removal_queue_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (RygelObjectRemovalQueue), 0, (GInstanceInitFunc) rygel_object_removal_queue_instance_init, NULL };
		GType rygel_object_removal_queue_type_id;
		rygel_object_removal_queue_type_id = g_type_register_static (G_TYPE_OBJECT, "RygelObjectRemovalQueue", &g_define_type_info, 0);
		g_once_init_leave (&rygel_object_removal_queue_type_id__volatile, rygel_object_removal_queue_type_id);
	}
	return rygel_object_removal_queue_type_id__volatile;
}


static void _rygel_dlna_profile_unref0_ (gpointer var) {
	(var == NULL) ? NULL : (var = (rygel_dlna_profile_unref (var), NULL));
}


static void _g_list_free__rygel_dlna_profile_unref0_ (GList* self) {
	g_list_foreach (self, (GFunc) _rygel_dlna_profile_unref0_, NULL);
	g_list_free (self);
}


RygelMediaServerPlugin* rygel_media_server_plugin_construct (GType object_type) {
	RygelMediaServerPlugin * self = NULL;
	self = (RygelMediaServerPlugin*) g_object_new (object_type, NULL);
	return self;
}


RygelMediaServerPlugin* rygel_media_server_plugin_new (void) {
	return rygel_media_server_plugin_construct (RYGEL_TYPE_MEDIA_SERVER_PLUGIN);
}


static void rygel_media_server_plugin_class_init (RygelMediaServerPluginClass * klass) {
	rygel_media_server_plugin_parent_class = g_type_class_peek_parent (klass);
	G_OBJECT_CLASS (klass)->finalize = rygel_media_server_plugin_finalize;
}


static void rygel_media_server_plugin_instance_init (RygelMediaServerPlugin * self) {
	self->upload_profiles = NULL;
}


static void rygel_media_server_plugin_finalize (GObject* obj) {
	RygelMediaServerPlugin * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, RYGEL_TYPE_MEDIA_SERVER_PLUGIN, RygelMediaServerPlugin);
	__g_list_free__rygel_dlna_profile_unref0_0 (self->upload_profiles);
	G_OBJECT_CLASS (rygel_media_server_plugin_parent_class)->finalize (obj);
}


GType rygel_media_server_plugin_get_type (void) {
	static volatile gsize rygel_media_server_plugin_type_id__volatile = 0;
	if (g_once_init_enter (&rygel_media_server_plugin_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (RygelMediaServerPluginClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) rygel_media_server_plugin_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (RygelMediaServerPlugin), 0, (GInstanceInitFunc) rygel_media_server_plugin_instance_init, NULL };
		GType rygel_media_server_plugin_type_id;
		rygel_media_server_plugin_type_id = g_type_register_static (G_TYPE_OBJECT, "RygelMediaServerPlugin", &g_define_type_info, 0);
		g_once_init_leave (&rygel_media_server_plugin_type_id__volatile, rygel_media_server_plugin_type_id);
	}
	return rygel_media_server_plugin_type_id__volatile;
}


void rygel_media_object_add_uri (RygelMediaObject* self, const gchar* uri) {
	GeeArrayList* _tmp0_ = NULL;
	const gchar* _tmp1_ = NULL;
	g_return_if_fail (self != NULL);
	g_return_if_fail (uri != NULL);
	_tmp0_ = self->uris;
	_tmp1_ = uri;
	gee_abstract_collection_add ((GeeAbstractCollection*) _tmp0_, _tmp1_);
}


void rygel_media_object_serialize (RygelMediaObject* self, RygelSerializer* serializer, RygelHTTPServer* server) {
	g_return_if_fail (self != NULL);
	g_return_if_fail (serializer != NULL);
	g_return_if_fail (server != NULL);
}


void rygel_media_object_apply_didl_lite (RygelMediaObject* self, GUPnPDIDLLiteObject* object) {
	g_return_if_fail (self != NULL);
	g_return_if_fail (object != NULL);
}


static void rygel_media_object_real_get_children_data_free (gpointer _data) {
	RygelMediaObjectGetChildrenData* _data_;
	_data_ = _data;
	_g_free0 (_data_->sort_criteria);
	_g_object_unref0 (_data_->cancellable);
	_g_object_unref0 (_data_->result);
	_g_object_unref0 (_data_->self);
	g_slice_free (RygelMediaObjectGetChildrenData, _data_);
}


static gpointer _g_object_ref0 (gpointer self) {
	return self ? g_object_ref (self) : NULL;
}


static void rygel_media_object_real_get_children (RygelMediaObject* self, guint offset, guint max_count, const gchar* sort_criteria, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	RygelMediaObjectGetChildrenData* _data_;
	RygelMediaObject* _tmp0_ = NULL;
	guint _tmp1_ = 0U;
	guint _tmp2_ = 0U;
	const gchar* _tmp3_ = NULL;
	gchar* _tmp4_ = NULL;
	GCancellable* _tmp5_ = NULL;
	GCancellable* _tmp6_ = NULL;
	_data_ = g_slice_new0 (RygelMediaObjectGetChildrenData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, rygel_media_object_real_get_children);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, rygel_media_object_real_get_children_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = offset;
	_data_->offset = _tmp1_;
	_tmp2_ = max_count;
	_data_->max_count = _tmp2_;
	_tmp3_ = sort_criteria;
	_tmp4_ = g_strdup (_tmp3_);
	_g_free0 (_data_->sort_criteria);
	_data_->sort_criteria = _tmp4_;
	_tmp5_ = cancellable;
	_tmp6_ = _g_object_ref0 (_tmp5_);
	_g_object_unref0 (_data_->cancellable);
	_data_->cancellable = _tmp6_;
	rygel_media_object_real_get_children_co (_data_);
}


static RygelMediaObjects* rygel_media_object_real_get_children_finish (RygelMediaObject* self, GAsyncResult* _res_, GError** error) {
	RygelMediaObjects* result;
	RygelMediaObjectGetChildrenData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return NULL;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	_data_->result = NULL;
	return result;
}


static gboolean rygel_media_object_real_get_children_co (RygelMediaObjectGetChildrenData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	_data_->result = NULL;
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


void rygel_media_object_get_children (RygelMediaObject* self, guint offset, guint max_count, const gchar* sort_criteria, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	RYGEL_MEDIA_OBJECT_GET_CLASS (self)->get_children (self, offset, max_count, sort_criteria, cancellable, _callback_, _user_data_);
}


RygelMediaObjects* rygel_media_object_get_children_finish (RygelMediaObject* self, GAsyncResult* _res_, GError** error) {
	return RYGEL_MEDIA_OBJECT_GET_CLASS (self)->get_children_finish (self, _res_, error);
}


static void rygel_media_object_real_find_object_data_free (gpointer _data) {
	RygelMediaObjectFindObjectData* _data_;
	_data_ = _data;
	_g_free0 (_data_->id);
	_g_object_unref0 (_data_->cancellable);
	_g_object_unref0 (_data_->result);
	_g_object_unref0 (_data_->self);
	g_slice_free (RygelMediaObjectFindObjectData, _data_);
}


static void rygel_media_object_real_find_object (RygelMediaObject* self, const gchar* id, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	RygelMediaObjectFindObjectData* _data_;
	RygelMediaObject* _tmp0_ = NULL;
	const gchar* _tmp1_ = NULL;
	gchar* _tmp2_ = NULL;
	GCancellable* _tmp3_ = NULL;
	GCancellable* _tmp4_ = NULL;
	_data_ = g_slice_new0 (RygelMediaObjectFindObjectData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, rygel_media_object_real_find_object);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, rygel_media_object_real_find_object_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = id;
	_tmp2_ = g_strdup (_tmp1_);
	_g_free0 (_data_->id);
	_data_->id = _tmp2_;
	_tmp3_ = cancellable;
	_tmp4_ = _g_object_ref0 (_tmp3_);
	_g_object_unref0 (_data_->cancellable);
	_data_->cancellable = _tmp4_;
	rygel_media_object_real_find_object_co (_data_);
}


static RygelMediaObject* rygel_media_object_real_find_object_finish (RygelMediaObject* self, GAsyncResult* _res_, GError** error) {
	RygelMediaObject* result;
	RygelMediaObjectFindObjectData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return NULL;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	_data_->result = NULL;
	return result;
}


static gboolean rygel_media_object_real_find_object_co (RygelMediaObjectFindObjectData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	_data_->result = NULL;
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


void rygel_media_object_find_object (RygelMediaObject* self, const gchar* id, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	RYGEL_MEDIA_OBJECT_GET_CLASS (self)->find_object (self, id, cancellable, _callback_, _user_data_);
}


RygelMediaObject* rygel_media_object_find_object_finish (RygelMediaObject* self, GAsyncResult* _res_, GError** error) {
	return RYGEL_MEDIA_OBJECT_GET_CLASS (self)->find_object_finish (self, _res_, error);
}


RygelMediaObject* rygel_media_object_construct (GType object_type) {
	RygelMediaObject * self = NULL;
	self = (RygelMediaObject*) g_object_new (object_type, NULL);
	return self;
}


RygelMediaObject* rygel_media_object_new (void) {
	return rygel_media_object_construct (RYGEL_TYPE_MEDIA_OBJECT);
}


const gchar* rygel_media_object_get_id (RygelMediaObject* self) {
	const gchar* result;
	const gchar* _tmp0_ = NULL;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_id;
	result = _tmp0_;
	return result;
}


void rygel_media_object_set_id (RygelMediaObject* self, const gchar* value) {
	const gchar* _tmp0_ = NULL;
	gchar* _tmp1_ = NULL;
	g_return_if_fail (self != NULL);
	_tmp0_ = value;
	_tmp1_ = g_strdup (_tmp0_);
	_g_free0 (self->priv->_id);
	self->priv->_id = _tmp1_;
	g_object_notify ((GObject *) self, "id");
}


RygelMediaContainer* rygel_media_object_get_parent (RygelMediaObject* self) {
	RygelMediaContainer* result;
	RygelMediaContainer* _tmp0_ = NULL;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_parent;
	result = _tmp0_;
	return result;
}


void rygel_media_object_set_parent (RygelMediaObject* self, RygelMediaContainer* value) {
	RygelMediaContainer* _tmp0_ = NULL;
	g_return_if_fail (self != NULL);
	_tmp0_ = value;
	self->priv->_parent = _tmp0_;
	g_object_notify ((GObject *) self, "parent");
}


const gchar* rygel_media_object_get_title (RygelMediaObject* self) {
	const gchar* result;
	const gchar* _tmp0_ = NULL;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_title;
	result = _tmp0_;
	return result;
}


void rygel_media_object_set_title (RygelMediaObject* self, const gchar* value) {
	const gchar* _tmp0_ = NULL;
	gchar* _tmp1_ = NULL;
	g_return_if_fail (self != NULL);
	_tmp0_ = value;
	_tmp1_ = g_strdup (_tmp0_);
	_g_free0 (self->priv->_title);
	self->priv->_title = _tmp1_;
	g_object_notify ((GObject *) self, "title");
}


static void rygel_media_object_class_init (RygelMediaObjectClass * klass) {
	rygel_media_object_parent_class = g_type_class_peek_parent (klass);
	g_type_class_add_private (klass, sizeof (RygelMediaObjectPrivate));
	RYGEL_MEDIA_OBJECT_CLASS (klass)->get_children = rygel_media_object_real_get_children;
	RYGEL_MEDIA_OBJECT_CLASS (klass)->get_children_finish = rygel_media_object_real_get_children_finish;
	RYGEL_MEDIA_OBJECT_CLASS (klass)->find_object = rygel_media_object_real_find_object;
	RYGEL_MEDIA_OBJECT_CLASS (klass)->find_object_finish = rygel_media_object_real_find_object_finish;
	G_OBJECT_CLASS (klass)->get_property = _vala_rygel_media_object_get_property;
	G_OBJECT_CLASS (klass)->set_property = _vala_rygel_media_object_set_property;
	G_OBJECT_CLASS (klass)->finalize = rygel_media_object_finalize;
	g_object_class_install_property (G_OBJECT_CLASS (klass), RYGEL_MEDIA_OBJECT_ID, g_param_spec_string ("id", "id", "id", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), RYGEL_MEDIA_OBJECT_PARENT, g_param_spec_object ("parent", "parent", "parent", RYGEL_TYPE_MEDIA_CONTAINER, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), RYGEL_MEDIA_OBJECT_TITLE, g_param_spec_string ("title", "title", "title", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
}


static void rygel_media_object_instance_init (RygelMediaObject * self) {
	self->priv = RYGEL_MEDIA_OBJECT_GET_PRIVATE (self);
}


static void rygel_media_object_finalize (GObject* obj) {
	RygelMediaObject * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, RYGEL_TYPE_MEDIA_OBJECT, RygelMediaObject);
	_g_free0 (self->priv->_id);
	_g_free0 (self->ref_id);
	_g_free0 (self->upnp_class);
	_g_free0 (self->priv->_title);
	_g_object_unref0 (self->uris);
	G_OBJECT_CLASS (rygel_media_object_parent_class)->finalize (obj);
}


GType rygel_media_object_get_type (void) {
	static volatile gsize rygel_media_object_type_id__volatile = 0;
	if (g_once_init_enter (&rygel_media_object_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (RygelMediaObjectClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) rygel_media_object_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (RygelMediaObject), 0, (GInstanceInitFunc) rygel_media_object_instance_init, NULL };
		GType rygel_media_object_type_id;
		rygel_media_object_type_id = g_type_register_static (G_TYPE_OBJECT, "RygelMediaObject", &g_define_type_info, 0);
		g_once_init_leave (&rygel_media_object_type_id__volatile, rygel_media_object_type_id);
	}
	return rygel_media_object_type_id__volatile;
}


static void _vala_rygel_media_object_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
	RygelMediaObject * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, RYGEL_TYPE_MEDIA_OBJECT, RygelMediaObject);
	switch (property_id) {
		case RYGEL_MEDIA_OBJECT_ID:
		g_value_set_string (value, rygel_media_object_get_id (self));
		break;
		case RYGEL_MEDIA_OBJECT_PARENT:
		g_value_set_object (value, rygel_media_object_get_parent (self));
		break;
		case RYGEL_MEDIA_OBJECT_TITLE:
		g_value_set_string (value, rygel_media_object_get_title (self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}


static void _vala_rygel_media_object_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
	RygelMediaObject * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, RYGEL_TYPE_MEDIA_OBJECT, RygelMediaObject);
	switch (property_id) {
		case RYGEL_MEDIA_OBJECT_ID:
		rygel_media_object_set_id (self, g_value_get_string (value));
		break;
		case RYGEL_MEDIA_OBJECT_PARENT:
		rygel_media_object_set_parent (self, g_value_get_object (value));
		break;
		case RYGEL_MEDIA_OBJECT_TITLE:
		rygel_media_object_set_title (self, g_value_get_string (value));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}


static void rygel_trackable_container_base_init (RygelTrackableContainerIface * iface) {
	static gboolean initialized = FALSE;
	if (!initialized) {
		initialized = TRUE;
	}
}


GType rygel_trackable_container_get_type (void) {
	static volatile gsize rygel_trackable_container_type_id__volatile = 0;
	if (g_once_init_enter (&rygel_trackable_container_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (RygelTrackableContainerIface), (GBaseInitFunc) rygel_trackable_container_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) NULL, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
		GType rygel_trackable_container_type_id;
		rygel_trackable_container_type_id = g_type_register_static (G_TYPE_INTERFACE, "RygelTrackableContainer", &g_define_type_info, 0);
		g_type_interface_add_prerequisite (rygel_trackable_container_type_id, RYGEL_TYPE_MEDIA_CONTAINER);
		g_once_init_leave (&rygel_trackable_container_type_id__volatile, rygel_trackable_container_type_id);
	}
	return rygel_trackable_container_type_id__volatile;
}


static void rygel_trackable_item_base_init (RygelTrackableItemIface * iface) {
	static gboolean initialized = FALSE;
	if (!initialized) {
		initialized = TRUE;
	}
}


GType rygel_trackable_item_get_type (void) {
	static volatile gsize rygel_trackable_item_type_id__volatile = 0;
	if (g_once_init_enter (&rygel_trackable_item_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (RygelTrackableItemIface), (GBaseInitFunc) rygel_trackable_item_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) NULL, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
		GType rygel_trackable_item_type_id;
		rygel_trackable_item_type_id = g_type_register_static (G_TYPE_INTERFACE, "RygelTrackableItem", &g_define_type_info, 0);
		g_type_interface_add_prerequisite (rygel_trackable_item_type_id, RYGEL_TYPE_MEDIA_ITEM);
		g_once_init_leave (&rygel_trackable_item_type_id__volatile, rygel_trackable_item_type_id);
	}
	return rygel_trackable_item_type_id__volatile;
}


RygelMediaItem* rygel_media_item_construct (GType object_type, const gchar* id, RygelMediaContainer* parent, const gchar* title) {
	RygelMediaItem * self = NULL;
	const gchar* _tmp0_ = NULL;
	RygelMediaContainer* _tmp1_ = NULL;
	const gchar* _tmp2_ = NULL;
	g_return_val_if_fail (id != NULL, NULL);
	g_return_val_if_fail (parent != NULL, NULL);
	g_return_val_if_fail (title != NULL, NULL);
	self = (RygelMediaItem*) rygel_media_object_construct (object_type);
	_tmp0_ = id;
	rygel_media_object_set_id ((RygelMediaObject*) self, _tmp0_);
	_tmp1_ = parent;
	rygel_media_object_set_parent ((RygelMediaObject*) self, _tmp1_);
	_tmp2_ = title;
	rygel_media_object_set_title ((RygelMediaObject*) self, _tmp2_);
	return self;
}


RygelMediaItem* rygel_media_item_new (const gchar* id, RygelMediaContainer* parent, const gchar* title) {
	return rygel_media_item_construct (RYGEL_TYPE_MEDIA_ITEM, id, parent, title);
}


static void rygel_media_item_class_init (RygelMediaItemClass * klass) {
	rygel_media_item_parent_class = g_type_class_peek_parent (klass);
	G_OBJECT_CLASS (klass)->finalize = rygel_media_item_finalize;
}


static void rygel_media_item_instance_init (RygelMediaItem * self) {
}


static void rygel_media_item_finalize (GObject* obj) {
	RygelMediaItem * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, RYGEL_TYPE_MEDIA_ITEM, RygelMediaItem);
	_g_free0 (self->dlna_profile);
	_g_free0 (self->mime_type);
	_g_free0 (self->date);
	G_OBJECT_CLASS (rygel_media_item_parent_class)->finalize (obj);
}


GType rygel_media_item_get_type (void) {
	static volatile gsize rygel_media_item_type_id__volatile = 0;
	if (g_once_init_enter (&rygel_media_item_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (RygelMediaItemClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) rygel_media_item_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (RygelMediaItem), 0, (GInstanceInitFunc) rygel_media_item_instance_init, NULL };
		GType rygel_media_item_type_id;
		rygel_media_item_type_id = g_type_register_static (RYGEL_TYPE_MEDIA_OBJECT, "RygelMediaItem", &g_define_type_info, 0);
		g_once_init_leave (&rygel_media_item_type_id__volatile, rygel_media_item_type_id);
	}
	return rygel_media_item_type_id__volatile;
}


RygelMusicItem* rygel_music_item_construct (GType object_type, const gchar* id, RygelMediaContainer* parent, const gchar* title) {
	RygelMusicItem * self = NULL;
	const gchar* _tmp0_ = NULL;
	RygelMediaContainer* _tmp1_ = NULL;
	const gchar* _tmp2_ = NULL;
	g_return_val_if_fail (id != NULL, NULL);
	g_return_val_if_fail (parent != NULL, NULL);
	g_return_val_if_fail (title != NULL, NULL);
	_tmp0_ = id;
	_tmp1_ = parent;
	_tmp2_ = title;
	self = (RygelMusicItem*) rygel_audio_item_construct (object_type, _tmp0_, _tmp1_, _tmp2_);
	return self;
}


RygelMusicItem* rygel_music_item_new (const gchar* id, RygelMediaContainer* parent, const gchar* title) {
	return rygel_music_item_construct (RYGEL_TYPE_MUSIC_ITEM, id, parent, title);
}


static void rygel_music_item_class_init (RygelMusicItemClass * klass) {
	rygel_music_item_parent_class = g_type_class_peek_parent (klass);
}


static void rygel_music_item_instance_init (RygelMusicItem * self) {
}


GType rygel_music_item_get_type (void) {
	static volatile gsize rygel_music_item_type_id__volatile = 0;
	if (g_once_init_enter (&rygel_music_item_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (RygelMusicItemClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) rygel_music_item_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (RygelMusicItem), 0, (GInstanceInitFunc) rygel_music_item_instance_init, NULL };
		GType rygel_music_item_type_id;
		rygel_music_item_type_id = g_type_register_static (RYGEL_TYPE_AUDIO_ITEM, "RygelMusicItem", &g_define_type_info, 0);
		g_once_init_leave (&rygel_music_item_type_id__volatile, rygel_music_item_type_id);
	}
	return rygel_music_item_type_id__volatile;
}


RygelAudioItem* rygel_audio_item_construct (GType object_type, const gchar* id, RygelMediaContainer* parent, const gchar* title) {
	RygelAudioItem * self = NULL;
	const gchar* _tmp0_ = NULL;
	RygelMediaContainer* _tmp1_ = NULL;
	const gchar* _tmp2_ = NULL;
	g_return_val_if_fail (id != NULL, NULL);
	g_return_val_if_fail (parent != NULL, NULL);
	g_return_val_if_fail (title != NULL, NULL);
	_tmp0_ = id;
	_tmp1_ = parent;
	_tmp2_ = title;
	self = (RygelAudioItem*) rygel_media_item_construct (object_type, _tmp0_, _tmp1_, _tmp2_);
	return self;
}


RygelAudioItem* rygel_audio_item_new (const gchar* id, RygelMediaContainer* parent, const gchar* title) {
	return rygel_audio_item_construct (RYGEL_TYPE_AUDIO_ITEM, id, parent, title);
}


static void rygel_audio_item_class_init (RygelAudioItemClass * klass) {
	rygel_audio_item_parent_class = g_type_class_peek_parent (klass);
	G_OBJECT_CLASS (klass)->finalize = rygel_audio_item_finalize;
}


static void rygel_audio_item_instance_init (RygelAudioItem * self) {
}


static void rygel_audio_item_finalize (GObject* obj) {
	RygelAudioItem * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, RYGEL_TYPE_AUDIO_ITEM, RygelAudioItem);
	_g_free0 (self->artist);
	_g_free0 (self->album);
	G_OBJECT_CLASS (rygel_audio_item_parent_class)->finalize (obj);
}


GType rygel_audio_item_get_type (void) {
	static volatile gsize rygel_audio_item_type_id__volatile = 0;
	if (g_once_init_enter (&rygel_audio_item_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (RygelAudioItemClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) rygel_audio_item_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (RygelAudioItem), 0, (GInstanceInitFunc) rygel_audio_item_instance_init, NULL };
		GType rygel_audio_item_type_id;
		rygel_audio_item_type_id = g_type_register_static (RYGEL_TYPE_MEDIA_ITEM, "RygelAudioItem", &g_define_type_info, 0);
		g_once_init_leave (&rygel_audio_item_type_id__volatile, rygel_audio_item_type_id);
	}
	return rygel_audio_item_type_id__volatile;
}


RygelImageItem* rygel_image_item_construct (GType object_type, const gchar* id, RygelMediaContainer* parent, const gchar* title) {
	RygelImageItem * self = NULL;
	const gchar* _tmp0_ = NULL;
	RygelMediaContainer* _tmp1_ = NULL;
	const gchar* _tmp2_ = NULL;
	g_return_val_if_fail (id != NULL, NULL);
	g_return_val_if_fail (parent != NULL, NULL);
	g_return_val_if_fail (title != NULL, NULL);
	_tmp0_ = id;
	_tmp1_ = parent;
	_tmp2_ = title;
	self = (RygelImageItem*) rygel_media_item_construct (object_type, _tmp0_, _tmp1_, _tmp2_);
	return self;
}


RygelImageItem* rygel_image_item_new (const gchar* id, RygelMediaContainer* parent, const gchar* title) {
	return rygel_image_item_construct (RYGEL_TYPE_IMAGE_ITEM, id, parent, title);
}


static void rygel_image_item_class_init (RygelImageItemClass * klass) {
	rygel_image_item_parent_class = g_type_class_peek_parent (klass);
}


static void rygel_image_item_instance_init (RygelImageItem * self) {
}


GType rygel_image_item_get_type (void) {
	static volatile gsize rygel_image_item_type_id__volatile = 0;
	if (g_once_init_enter (&rygel_image_item_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (RygelImageItemClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) rygel_image_item_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (RygelImageItem), 0, (GInstanceInitFunc) rygel_image_item_instance_init, NULL };
		GType rygel_image_item_type_id;
		rygel_image_item_type_id = g_type_register_static (RYGEL_TYPE_MEDIA_ITEM, "RygelImageItem", &g_define_type_info, 0);
		g_once_init_leave (&rygel_image_item_type_id__volatile, rygel_image_item_type_id);
	}
	return rygel_image_item_type_id__volatile;
}


RygelVideoItem* rygel_video_item_construct (GType object_type, const gchar* id, RygelMediaContainer* parent, const gchar* title) {
	RygelVideoItem * self = NULL;
	const gchar* _tmp0_ = NULL;
	RygelMediaContainer* _tmp1_ = NULL;
	const gchar* _tmp2_ = NULL;
	g_return_val_if_fail (id != NULL, NULL);
	g_return_val_if_fail (parent != NULL, NULL);
	g_return_val_if_fail (title != NULL, NULL);
	_tmp0_ = id;
	_tmp1_ = parent;
	_tmp2_ = title;
	self = (RygelVideoItem*) rygel_media_item_construct (object_type, _tmp0_, _tmp1_, _tmp2_);
	return self;
}


RygelVideoItem* rygel_video_item_new (const gchar* id, RygelMediaContainer* parent, const gchar* title) {
	return rygel_video_item_construct (RYGEL_TYPE_VIDEO_ITEM, id, parent, title);
}


static void rygel_video_item_class_init (RygelVideoItemClass * klass) {
	rygel_video_item_parent_class = g_type_class_peek_parent (klass);
}


static void rygel_video_item_instance_init (RygelVideoItem * self) {
}


GType rygel_video_item_get_type (void) {
	static volatile gsize rygel_video_item_type_id__volatile = 0;
	if (g_once_init_enter (&rygel_video_item_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (RygelVideoItemClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) rygel_video_item_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (RygelVideoItem), 0, (GInstanceInitFunc) rygel_video_item_instance_init, NULL };
		GType rygel_video_item_type_id;
		rygel_video_item_type_id = g_type_register_static (RYGEL_TYPE_MEDIA_ITEM, "RygelVideoItem", &g_define_type_info, 0);
		g_once_init_leave (&rygel_video_item_type_id__volatile, rygel_video_item_type_id);
	}
	return rygel_video_item_type_id__volatile;
}


RygelPhotoItem* rygel_photo_item_construct (GType object_type, const gchar* id, RygelMediaContainer* parent, const gchar* title) {
	RygelPhotoItem * self = NULL;
	const gchar* _tmp0_ = NULL;
	RygelMediaContainer* _tmp1_ = NULL;
	const gchar* _tmp2_ = NULL;
	g_return_val_if_fail (id != NULL, NULL);
	g_return_val_if_fail (parent != NULL, NULL);
	g_return_val_if_fail (title != NULL, NULL);
	_tmp0_ = id;
	_tmp1_ = parent;
	_tmp2_ = title;
	self = (RygelPhotoItem*) rygel_media_item_construct (object_type, _tmp0_, _tmp1_, _tmp2_);
	return self;
}


RygelPhotoItem* rygel_photo_item_new (const gchar* id, RygelMediaContainer* parent, const gchar* title) {
	return rygel_photo_item_construct (RYGEL_TYPE_PHOTO_ITEM, id, parent, title);
}


static void rygel_photo_item_class_init (RygelPhotoItemClass * klass) {
	rygel_photo_item_parent_class = g_type_class_peek_parent (klass);
	G_OBJECT_CLASS (klass)->finalize = rygel_photo_item_finalize;
}


static void rygel_photo_item_instance_init (RygelPhotoItem * self) {
}


static void rygel_photo_item_finalize (GObject* obj) {
	RygelPhotoItem * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, RYGEL_TYPE_PHOTO_ITEM, RygelPhotoItem);
	_g_free0 (self->creator);
	G_OBJECT_CLASS (rygel_photo_item_parent_class)->finalize (obj);
}


GType rygel_photo_item_get_type (void) {
	static volatile gsize rygel_photo_item_type_id__volatile = 0;
	if (g_once_init_enter (&rygel_photo_item_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (RygelPhotoItemClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) rygel_photo_item_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (RygelPhotoItem), 0, (GInstanceInitFunc) rygel_photo_item_instance_init, NULL };
		GType rygel_photo_item_type_id;
		rygel_photo_item_type_id = g_type_register_static (RYGEL_TYPE_MEDIA_ITEM, "RygelPhotoItem", &g_define_type_info, 0);
		g_once_init_leave (&rygel_photo_item_type_id__volatile, rygel_photo_item_type_id);
	}
	return rygel_photo_item_type_id__volatile;
}


RygelPlaylistItem* rygel_playlist_item_construct (GType object_type, const gchar* id, RygelMediaContainer* parent, const gchar* title) {
	RygelPlaylistItem * self = NULL;
	const gchar* _tmp0_ = NULL;
	RygelMediaContainer* _tmp1_ = NULL;
	const gchar* _tmp2_ = NULL;
	g_return_val_if_fail (id != NULL, NULL);
	g_return_val_if_fail (parent != NULL, NULL);
	g_return_val_if_fail (title != NULL, NULL);
	_tmp0_ = id;
	_tmp1_ = parent;
	_tmp2_ = title;
	self = (RygelPlaylistItem*) rygel_media_item_construct (object_type, _tmp0_, _tmp1_, _tmp2_);
	return self;
}


RygelPlaylistItem* rygel_playlist_item_new (const gchar* id, RygelMediaContainer* parent, const gchar* title) {
	return rygel_playlist_item_construct (RYGEL_TYPE_PLAYLIST_ITEM, id, parent, title);
}


static void rygel_playlist_item_class_init (RygelPlaylistItemClass * klass) {
	rygel_playlist_item_parent_class = g_type_class_peek_parent (klass);
}


static void rygel_playlist_item_instance_init (RygelPlaylistItem * self) {
}


GType rygel_playlist_item_get_type (void) {
	static volatile gsize rygel_playlist_item_type_id__volatile = 0;
	if (g_once_init_enter (&rygel_playlist_item_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (RygelPlaylistItemClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) rygel_playlist_item_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (RygelPlaylistItem), 0, (GInstanceInitFunc) rygel_playlist_item_instance_init, NULL };
		GType rygel_playlist_item_type_id;
		rygel_playlist_item_type_id = g_type_register_static (RYGEL_TYPE_MEDIA_ITEM, "RygelPlaylistItem", &g_define_type_info, 0);
		g_once_init_leave (&rygel_playlist_item_type_id__volatile, rygel_playlist_item_type_id);
	}
	return rygel_playlist_item_type_id__volatile;
}


RygelRootDevice* rygel_root_device_construct (GType object_type) {
	RygelRootDevice * self = NULL;
	RygelMediaServerPlugin* _tmp0_ = NULL;
	self = (RygelRootDevice*) g_object_new (object_type, NULL);
	_tmp0_ = rygel_media_server_plugin_new ();
	_g_object_unref0 (self->resource_factory);
	self->resource_factory = _tmp0_;
	return self;
}


RygelRootDevice* rygel_root_device_new (void) {
	return rygel_root_device_construct (RYGEL_TYPE_ROOT_DEVICE);
}


static void rygel_root_device_class_init (RygelRootDeviceClass * klass) {
	rygel_root_device_parent_class = g_type_class_peek_parent (klass);
	G_OBJECT_CLASS (klass)->finalize = rygel_root_device_finalize;
}


static void rygel_root_device_instance_init (RygelRootDevice * self) {
}


static void rygel_root_device_finalize (GObject* obj) {
	RygelRootDevice * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, RYGEL_TYPE_ROOT_DEVICE, RygelRootDevice);
	_g_object_unref0 (self->resource_factory);
	G_OBJECT_CLASS (rygel_root_device_parent_class)->finalize (obj);
}


GType rygel_root_device_get_type (void) {
	static volatile gsize rygel_root_device_type_id__volatile = 0;
	if (g_once_init_enter (&rygel_root_device_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (RygelRootDeviceClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) rygel_root_device_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (RygelRootDevice), 0, (GInstanceInitFunc) rygel_root_device_instance_init, NULL };
		GType rygel_root_device_type_id;
		rygel_root_device_type_id = g_type_register_static (G_TYPE_OBJECT, "RygelRootDevice", &g_define_type_info, 0);
		g_once_init_leave (&rygel_root_device_type_id__volatile, rygel_root_device_type_id);
	}
	return rygel_root_device_type_id__volatile;
}


RygelContentDirectory* rygel_content_directory_construct (GType object_type) {
	RygelContentDirectory * self = NULL;
	RygelRootDevice* _tmp0_ = NULL;
	self = (RygelContentDirectory*) g_object_new (object_type, NULL);
	_tmp0_ = rygel_root_device_new ();
	_g_object_unref0 (self->root_device);
	self->root_device = _tmp0_;
	return self;
}


RygelContentDirectory* rygel_content_directory_new (void) {
	return rygel_content_directory_construct (RYGEL_TYPE_CONTENT_DIRECTORY);
}


static void rygel_content_directory_class_init (RygelContentDirectoryClass * klass) {
	rygel_content_directory_parent_class = g_type_class_peek_parent (klass);
	G_OBJECT_CLASS (klass)->finalize = rygel_content_directory_finalize;
}


static void rygel_content_directory_instance_init (RygelContentDirectory * self) {
}


static void rygel_content_directory_finalize (GObject* obj) {
	RygelContentDirectory * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, RYGEL_TYPE_CONTENT_DIRECTORY, RygelContentDirectory);
	_g_object_unref0 (self->cancellable);
	_g_object_unref0 (self->root_container);
	_g_object_unref0 (self->http_server);
	_g_object_unref0 (self->root_device);
	G_OBJECT_CLASS (rygel_content_directory_parent_class)->finalize (obj);
}


GType rygel_content_directory_get_type (void) {
	static volatile gsize rygel_content_directory_type_id__volatile = 0;
	if (g_once_init_enter (&rygel_content_directory_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (RygelContentDirectoryClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) rygel_content_directory_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (RygelContentDirectory), 0, (GInstanceInitFunc) rygel_content_directory_instance_init, NULL };
		GType rygel_content_directory_type_id;
		rygel_content_directory_type_id = g_type_register_static (G_TYPE_OBJECT, "RygelContentDirectory", &g_define_type_info, 0);
		g_once_init_leave (&rygel_content_directory_type_id__volatile, rygel_content_directory_type_id);
	}
	return rygel_content_directory_type_id__volatile;
}


static void rygel_media_container_real_find_object_data_free (gpointer _data) {
	RygelMediaContainerFindObjectData* _data_;
	_data_ = _data;
	_g_free0 (_data_->id);
	_g_object_unref0 (_data_->cancellable);
	_g_object_unref0 (_data_->result);
	_g_object_unref0 (_data_->self);
	g_slice_free (RygelMediaContainerFindObjectData, _data_);
}


static void rygel_media_container_real_find_object (RygelMediaObject* base, const gchar* id, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	RygelMediaContainer * self;
	RygelMediaContainerFindObjectData* _data_;
	RygelMediaContainer* _tmp0_ = NULL;
	const gchar* _tmp1_ = NULL;
	gchar* _tmp2_ = NULL;
	GCancellable* _tmp3_ = NULL;
	GCancellable* _tmp4_ = NULL;
	self = (RygelMediaContainer*) base;
	_data_ = g_slice_new0 (RygelMediaContainerFindObjectData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, rygel_media_container_real_find_object);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, rygel_media_container_real_find_object_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = id;
	_tmp2_ = g_strdup (_tmp1_);
	_g_free0 (_data_->id);
	_data_->id = _tmp2_;
	_tmp3_ = cancellable;
	_tmp4_ = _g_object_ref0 (_tmp3_);
	_g_object_unref0 (_data_->cancellable);
	_data_->cancellable = _tmp4_;
	rygel_media_container_real_find_object_co (_data_);
}


static RygelMediaObject* rygel_media_container_real_find_object_finish (RygelMediaObject* base, GAsyncResult* _res_, GError** error) {
	RygelMediaObject* result;
	RygelMediaContainerFindObjectData* _data_;
	if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
		return NULL;
	}
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	_data_->result = NULL;
	return result;
}


static Block1Data* block1_data_ref (Block1Data* _data1_) {
	g_atomic_int_inc (&_data1_->_ref_count_);
	return _data1_;
}


static void block1_data_unref (void * _userdata_) {
	Block1Data* _data1_;
	_data1_ = (Block1Data*) _userdata_;
	if (g_atomic_int_dec_and_test (&_data1_->_ref_count_)) {
		RygelMediaContainer* self;
		self = _data1_->self;
		_g_object_unref0 (self);
		g_slice_free (Block1Data, _data1_);
	}
}


static gboolean __lambda4_ (Block1Data* _data1_) {
	RygelMediaContainer* self;
	gboolean result = FALSE;
	self = _data1_->self;
	rygel_media_container_real_find_object_co (_data1_->_async_data_);
	result = FALSE;
	return result;
}


static gboolean ___lambda4__gsource_func (gpointer self) {
	gboolean result;
	result = __lambda4_ (self);
	return result;
}


static gboolean rygel_media_container_real_find_object_co (RygelMediaContainerFindObjectData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	_data_->_data1_ = g_slice_new0 (Block1Data);
	_data_->_data1_->_ref_count_ = 1;
	_data_->_data1_->self = g_object_ref (_data_->self);
	_data_->_data1_->_async_data_ = _data_;
	g_idle_add_full (G_PRIORITY_DEFAULT_IDLE, ___lambda4__gsource_func, block1_data_ref (_data_->_data1_), block1_data_unref);
	_data_->_state_ = 1;
	return FALSE;
	_state_1:
	;
	_data_->_tmp0_ = NULL;
	_data_->_tmp0_ = _data_->self->found_object;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = _g_object_ref0 (_data_->_tmp0_);
	_data_->result = _data_->_tmp1_;
	block1_data_unref (_data_->_data1_);
	_data_->_data1_ = NULL;
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	block1_data_unref (_data_->_data1_);
	_data_->_data1_ = NULL;
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


RygelMediaContainer* rygel_media_container_construct (GType object_type) {
	RygelMediaContainer * self = NULL;
	self = (RygelMediaContainer*) rygel_media_object_construct (object_type);
	return self;
}


RygelMediaContainer* rygel_media_container_new (void) {
	return rygel_media_container_construct (RYGEL_TYPE_MEDIA_CONTAINER);
}


gint rygel_media_container_get_child_count (RygelMediaContainer* self) {
	gint result;
	gint _tmp0_ = 0;
	g_return_val_if_fail (self != NULL, 0);
	_tmp0_ = self->priv->_child_count;
	result = _tmp0_;
	return result;
}


void rygel_media_container_set_child_count (RygelMediaContainer* self, gint value) {
	gint _tmp0_ = 0;
	g_return_if_fail (self != NULL);
	_tmp0_ = value;
	self->priv->_child_count = _tmp0_;
	g_object_notify ((GObject *) self, "child-count");
}


static void rygel_media_container_class_init (RygelMediaContainerClass * klass) {
	rygel_media_container_parent_class = g_type_class_peek_parent (klass);
	g_type_class_add_private (klass, sizeof (RygelMediaContainerPrivate));
	RYGEL_MEDIA_OBJECT_CLASS (klass)->find_object = rygel_media_container_real_find_object;
	RYGEL_MEDIA_OBJECT_CLASS (klass)->find_object_finish = rygel_media_container_real_find_object_finish;
	G_OBJECT_CLASS (klass)->get_property = _vala_rygel_media_container_get_property;
	G_OBJECT_CLASS (klass)->set_property = _vala_rygel_media_container_set_property;
	G_OBJECT_CLASS (klass)->finalize = rygel_media_container_finalize;
	g_object_class_install_property (G_OBJECT_CLASS (klass), RYGEL_MEDIA_CONTAINER_CHILD_COUNT, g_param_spec_int ("child-count", "child-count", "child-count", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_signal_new ("container_updated", RYGEL_TYPE_MEDIA_CONTAINER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, RYGEL_TYPE_MEDIA_CONTAINER);
}


static void rygel_media_container_instance_init (RygelMediaContainer * self) {
	GeeArrayList* _tmp0_ = NULL;
	gchar* _tmp1_ = NULL;
	self->priv = RYGEL_MEDIA_CONTAINER_GET_PRIVATE (self);
	_tmp0_ = gee_array_list_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, NULL, NULL, NULL);
	self->create_classes = _tmp0_;
	_tmp1_ = g_strdup ("+dc:title");
	self->sort_criteria = _tmp1_;
	self->found_object = NULL;
}


static void rygel_media_container_finalize (GObject* obj) {
	RygelMediaContainer * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, RYGEL_TYPE_MEDIA_CONTAINER, RygelMediaContainer);
	_g_object_unref0 (self->create_classes);
	_g_free0 (self->sort_criteria);
	_g_object_unref0 (self->found_object);
	G_OBJECT_CLASS (rygel_media_container_parent_class)->finalize (obj);
}


GType rygel_media_container_get_type (void) {
	static volatile gsize rygel_media_container_type_id__volatile = 0;
	if (g_once_init_enter (&rygel_media_container_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (RygelMediaContainerClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) rygel_media_container_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (RygelMediaContainer), 0, (GInstanceInitFunc) rygel_media_container_instance_init, NULL };
		GType rygel_media_container_type_id;
		rygel_media_container_type_id = g_type_register_static (RYGEL_TYPE_MEDIA_OBJECT, "RygelMediaContainer", &g_define_type_info, 0);
		g_once_init_leave (&rygel_media_container_type_id__volatile, rygel_media_container_type_id);
	}
	return rygel_media_container_type_id__volatile;
}


static void _vala_rygel_media_container_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
	RygelMediaContainer * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, RYGEL_TYPE_MEDIA_CONTAINER, RygelMediaContainer);
	switch (property_id) {
		case RYGEL_MEDIA_CONTAINER_CHILD_COUNT:
		g_value_set_int (value, rygel_media_container_get_child_count (self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}


static void _vala_rygel_media_container_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
	RygelMediaContainer * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, RYGEL_TYPE_MEDIA_CONTAINER, RygelMediaContainer);
	switch (property_id) {
		case RYGEL_MEDIA_CONTAINER_CHILD_COUNT:
		rygel_media_container_set_child_count (self, g_value_get_int (value));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}


RygelMediaObjects* rygel_media_objects_construct (GType object_type) {
	RygelMediaObjects * self = NULL;
	self = (RygelMediaObjects*) gee_array_list_construct (object_type, RYGEL_TYPE_MEDIA_OBJECT, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL, NULL);
	return self;
}


RygelMediaObjects* rygel_media_objects_new (void) {
	return rygel_media_objects_construct (RYGEL_TYPE_MEDIA_OBJECTS);
}


static void rygel_media_objects_class_init (RygelMediaObjectsClass * klass) {
	rygel_media_objects_parent_class = g_type_class_peek_parent (klass);
}


static void rygel_media_objects_instance_init (RygelMediaObjects * self) {
}


GType rygel_media_objects_get_type (void) {
	static volatile gsize rygel_media_objects_type_id__volatile = 0;
	if (g_once_init_enter (&rygel_media_objects_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (RygelMediaObjectsClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) rygel_media_objects_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (RygelMediaObjects), 0, (GInstanceInitFunc) rygel_media_objects_instance_init, NULL };
		GType rygel_media_objects_type_id;
		rygel_media_objects_type_id = g_type_register_static (GEE_TYPE_ARRAY_LIST, "RygelMediaObjects", &g_define_type_info, 0);
		g_once_init_leave (&rygel_media_objects_type_id__volatile, rygel_media_objects_type_id);
	}
	return rygel_media_objects_type_id__volatile;
}


gboolean rygel_writable_container_can_create (RygelWritableContainer* self, const gchar* upnp_class) {
	gboolean result = FALSE;
	GeeArrayList* _tmp0_ = NULL;
	const gchar* _tmp1_ = NULL;
	gboolean _tmp2_ = FALSE;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (upnp_class != NULL, FALSE);
	_tmp0_ = ((RygelMediaContainer*) self)->create_classes;
	_tmp1_ = upnp_class;
	_tmp2_ = gee_abstract_collection_contains ((GeeAbstractCollection*) _tmp0_, _tmp1_);
	result = _tmp2_;
	return result;
}


static void rygel_writable_container_get_writable_data_free (gpointer _data) {
	RygelWritableContainerGetWritableData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->cancellable);
	_g_object_unref0 (_data_->result);
	_g_object_unref0 (_data_->self);
	g_slice_free (RygelWritableContainerGetWritableData, _data_);
}


void rygel_writable_container_get_writable (RygelWritableContainer* self, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	RygelWritableContainerGetWritableData* _data_;
	RygelWritableContainer* _tmp0_ = NULL;
	GCancellable* _tmp1_ = NULL;
	GCancellable* _tmp2_ = NULL;
	_data_ = g_slice_new0 (RygelWritableContainerGetWritableData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, rygel_writable_container_get_writable);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, rygel_writable_container_get_writable_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = cancellable;
	_tmp2_ = _g_object_ref0 (_tmp1_);
	_g_object_unref0 (_data_->cancellable);
	_data_->cancellable = _tmp2_;
	rygel_writable_container_get_writable_co (_data_);
}


GFile* rygel_writable_container_get_writable_finish (RygelWritableContainer* self, GAsyncResult* _res_) {
	GFile* result;
	RygelWritableContainerGetWritableData* _data_;
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	result = _data_->result;
	_data_->result = NULL;
	return result;
}


static gboolean rygel_writable_container_get_writable_co (RygelWritableContainerGetWritableData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	_data_->_tmp0_ = NULL;
	_data_->_tmp0_ = g_file_new_for_commandline_arg ("/tmp");
	_data_->result = _data_->_tmp0_;
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void rygel_writable_container_add_item_data_free (gpointer _data) {
	RygelWritableContainerAddItemData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->item);
	_g_object_unref0 (_data_->cancellable);
	_g_object_unref0 (_data_->self);
	g_slice_free (RygelWritableContainerAddItemData, _data_);
}


void rygel_writable_container_add_item (RygelWritableContainer* self, RygelMediaItem* item, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	RygelWritableContainerAddItemData* _data_;
	RygelWritableContainer* _tmp0_ = NULL;
	RygelMediaItem* _tmp1_ = NULL;
	RygelMediaItem* _tmp2_ = NULL;
	GCancellable* _tmp3_ = NULL;
	GCancellable* _tmp4_ = NULL;
	_data_ = g_slice_new0 (RygelWritableContainerAddItemData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, rygel_writable_container_add_item);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, rygel_writable_container_add_item_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = item;
	_tmp2_ = _g_object_ref0 (_tmp1_);
	_g_object_unref0 (_data_->item);
	_data_->item = _tmp2_;
	_tmp3_ = cancellable;
	_tmp4_ = _g_object_ref0 (_tmp3_);
	_g_object_unref0 (_data_->cancellable);
	_data_->cancellable = _tmp4_;
	rygel_writable_container_add_item_co (_data_);
}


void rygel_writable_container_add_item_finish (RygelWritableContainer* self, GAsyncResult* _res_) {
	RygelWritableContainerAddItemData* _data_;
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static gboolean rygel_writable_container_add_item_co (RygelWritableContainerAddItemData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


static void rygel_writable_container_add_container_data_free (gpointer _data) {
	RygelWritableContainerAddContainerData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->container);
	_g_object_unref0 (_data_->cancellable);
	_g_object_unref0 (_data_->self);
	g_slice_free (RygelWritableContainerAddContainerData, _data_);
}


void rygel_writable_container_add_container (RygelWritableContainer* self, RygelMediaContainer* container, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	RygelWritableContainerAddContainerData* _data_;
	RygelWritableContainer* _tmp0_ = NULL;
	RygelMediaContainer* _tmp1_ = NULL;
	RygelMediaContainer* _tmp2_ = NULL;
	GCancellable* _tmp3_ = NULL;
	GCancellable* _tmp4_ = NULL;
	_data_ = g_slice_new0 (RygelWritableContainerAddContainerData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, rygel_writable_container_add_container);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, rygel_writable_container_add_container_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = container;
	_tmp2_ = _g_object_ref0 (_tmp1_);
	_g_object_unref0 (_data_->container);
	_data_->container = _tmp2_;
	_tmp3_ = cancellable;
	_tmp4_ = _g_object_ref0 (_tmp3_);
	_g_object_unref0 (_data_->cancellable);
	_data_->cancellable = _tmp4_;
	rygel_writable_container_add_container_co (_data_);
}


void rygel_writable_container_add_container_finish (RygelWritableContainer* self, GAsyncResult* _res_) {
	RygelWritableContainerAddContainerData* _data_;
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
}


static gboolean rygel_writable_container_add_container_co (RygelWritableContainerAddContainerData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


RygelWritableContainer* rygel_writable_container_construct (GType object_type) {
	RygelWritableContainer * self = NULL;
	self = (RygelWritableContainer*) rygel_media_container_construct (object_type);
	return self;
}


RygelWritableContainer* rygel_writable_container_new (void) {
	return rygel_writable_container_construct (RYGEL_TYPE_WRITABLE_CONTAINER);
}


static void rygel_writable_container_class_init (RygelWritableContainerClass * klass) {
	rygel_writable_container_parent_class = g_type_class_peek_parent (klass);
}


static void rygel_writable_container_instance_init (RygelWritableContainer * self) {
}


GType rygel_writable_container_get_type (void) {
	static volatile gsize rygel_writable_container_type_id__volatile = 0;
	if (g_once_init_enter (&rygel_writable_container_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (RygelWritableContainerClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) rygel_writable_container_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (RygelWritableContainer), 0, (GInstanceInitFunc) rygel_writable_container_instance_init, NULL };
		GType rygel_writable_container_type_id;
		rygel_writable_container_type_id = g_type_register_static (RYGEL_TYPE_MEDIA_CONTAINER, "RygelWritableContainer", &g_define_type_info, 0);
		g_once_init_leave (&rygel_writable_container_type_id__volatile, rygel_writable_container_type_id);
	}
	return rygel_writable_container_type_id__volatile;
}


static void rygel_searchable_container_search_data_free (gpointer _data) {
	RygelSearchableContainerSearchData* _data_;
	_data_ = _data;
	_rygel_search_expression_unref0 (_data_->expression);
	_g_free0 (_data_->soer_criteria);
	_g_object_unref0 (_data_->cancellable);
	_g_object_unref0 (_data_->result);
	_g_object_unref0 (_data_->self);
	g_slice_free (RygelSearchableContainerSearchData, _data_);
}


static gpointer _rygel_search_expression_ref0 (gpointer self) {
	return self ? rygel_search_expression_ref (self) : NULL;
}


void rygel_searchable_container_search (RygelSearchableContainer* self, RygelSearchExpression* expression, gint offset, gint count, const gchar* soer_criteria, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	RygelSearchableContainerSearchData* _data_;
	RygelSearchableContainer* _tmp0_ = NULL;
	RygelSearchExpression* _tmp1_ = NULL;
	RygelSearchExpression* _tmp2_ = NULL;
	gint _tmp3_ = 0;
	gint _tmp4_ = 0;
	const gchar* _tmp5_ = NULL;
	gchar* _tmp6_ = NULL;
	GCancellable* _tmp7_ = NULL;
	GCancellable* _tmp8_ = NULL;
	_data_ = g_slice_new0 (RygelSearchableContainerSearchData);
	_data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, rygel_searchable_container_search);
	g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, rygel_searchable_container_search_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = expression;
	_tmp2_ = _rygel_search_expression_ref0 (_tmp1_);
	_rygel_search_expression_unref0 (_data_->expression);
	_data_->expression = _tmp2_;
	_tmp3_ = offset;
	_data_->offset = _tmp3_;
	_tmp4_ = count;
	_data_->count = _tmp4_;
	_tmp5_ = soer_criteria;
	_tmp6_ = g_strdup (_tmp5_);
	_g_free0 (_data_->soer_criteria);
	_data_->soer_criteria = _tmp6_;
	_tmp7_ = cancellable;
	_tmp8_ = _g_object_ref0 (_tmp7_);
	_g_object_unref0 (_data_->cancellable);
	_data_->cancellable = _tmp8_;
	rygel_searchable_container_search_co (_data_);
}


RygelMediaObjects* rygel_searchable_container_search_finish (RygelSearchableContainer* self, GAsyncResult* _res_, gint* total_matches) {
	RygelMediaObjects* result;
	RygelSearchableContainerSearchData* _data_;
	_data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
	if (total_matches) {
		*total_matches = _data_->total_matches;
	}
	result = _data_->result;
	_data_->result = NULL;
	return result;
}


static Block2Data* block2_data_ref (Block2Data* _data2_) {
	g_atomic_int_inc (&_data2_->_ref_count_);
	return _data2_;
}


static void block2_data_unref (void * _userdata_) {
	Block2Data* _data2_;
	_data2_ = (Block2Data*) _userdata_;
	if (g_atomic_int_dec_and_test (&_data2_->_ref_count_)) {
		RygelSearchableContainer* self;
		self = _data2_->self;
		_g_object_unref0 (self);
		g_slice_free (Block2Data, _data2_);
	}
}


static gboolean __lambda5_ (Block2Data* _data2_) {
	RygelSearchableContainer* self;
	gboolean result = FALSE;
	self = _data2_->self;
	rygel_searchable_container_search_co (_data2_->_async_data_);
	result = FALSE;
	return result;
}


static gboolean ___lambda5__gsource_func (gpointer self) {
	gboolean result;
	result = __lambda5_ (self);
	return result;
}


static gboolean rygel_searchable_container_search_co (RygelSearchableContainerSearchData* _data_) {
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	_data_->_data2_ = g_slice_new0 (Block2Data);
	_data_->_data2_->_ref_count_ = 1;
	_data_->_data2_->self = g_object_ref (_data_->self);
	_data_->_data2_->_async_data_ = _data_;
	_data_->total_matches = 0;
	g_idle_add_full (G_PRIORITY_DEFAULT_IDLE, ___lambda5__gsource_func, block2_data_ref (_data_->_data2_), block2_data_unref);
	_data_->_state_ = 1;
	return FALSE;
	_state_1:
	;
	_data_->_tmp0_ = NULL;
	_data_->_tmp0_ = _data_->self->result;
	_data_->_tmp1_ = NULL;
	_data_->_tmp1_ = _g_object_ref0 (_data_->_tmp0_);
	_data_->result = _data_->_tmp1_;
	block2_data_unref (_data_->_data2_);
	_data_->_data2_ = NULL;
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
	block2_data_unref (_data_->_data2_);
	_data_->_data2_ = NULL;
	if (_data_->_state_ == 0) {
		g_simple_async_result_complete_in_idle (_data_->_async_result);
	} else {
		g_simple_async_result_complete (_data_->_async_result);
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}


RygelSearchableContainer* rygel_searchable_container_construct (GType object_type) {
	RygelSearchableContainer * self = NULL;
	self = (RygelSearchableContainer*) rygel_media_container_construct (object_type);
	return self;
}


RygelSearchableContainer* rygel_searchable_container_new (void) {
	return rygel_searchable_container_construct (RYGEL_TYPE_SEARCHABLE_CONTAINER);
}


static void rygel_searchable_container_class_init (RygelSearchableContainerClass * klass) {
	rygel_searchable_container_parent_class = g_type_class_peek_parent (klass);
	G_OBJECT_CLASS (klass)->finalize = rygel_searchable_container_finalize;
}


static void rygel_searchable_container_instance_init (RygelSearchableContainer * self) {
	RygelMediaObjects* _tmp0_ = NULL;
	_tmp0_ = rygel_media_objects_new ();
	self->result = _tmp0_;
}


static void rygel_searchable_container_finalize (GObject* obj) {
	RygelSearchableContainer * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, RYGEL_TYPE_SEARCHABLE_CONTAINER, RygelSearchableContainer);
	_g_object_unref0 (self->result);
	G_OBJECT_CLASS (rygel_searchable_container_parent_class)->finalize (obj);
}


GType rygel_searchable_container_get_type (void) {
	static volatile gsize rygel_searchable_container_type_id__volatile = 0;
	if (g_once_init_enter (&rygel_searchable_container_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (RygelSearchableContainerClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) rygel_searchable_container_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (RygelSearchableContainer), 0, (GInstanceInitFunc) rygel_searchable_container_instance_init, NULL };
		GType rygel_searchable_container_type_id;
		rygel_searchable_container_type_id = g_type_register_static (RYGEL_TYPE_MEDIA_CONTAINER, "RygelSearchableContainer", &g_define_type_info, 0);
		g_once_init_leave (&rygel_searchable_container_type_id__volatile, rygel_searchable_container_type_id);
	}
	return rygel_searchable_container_type_id__volatile;
}


GQuark rygel_content_directory_error_quark (void) {
	return g_quark_from_static_string ("rygel_content_directory_error-quark");
}


RygelTranscoder* rygel_transcoder_construct (GType object_type) {
	RygelTranscoder* self = NULL;
	self = (RygelTranscoder*) g_type_create_instance (object_type);
	return self;
}


RygelTranscoder* rygel_transcoder_new (void) {
	return rygel_transcoder_construct (RYGEL_TYPE_TRANSCODER);
}


static void rygel_value_transcoder_init (GValue* value) {
	value->data[0].v_pointer = NULL;
}


static void rygel_value_transcoder_free_value (GValue* value) {
	if (value->data[0].v_pointer) {
		rygel_transcoder_unref (value->data[0].v_pointer);
	}
}


static void rygel_value_transcoder_copy_value (const GValue* src_value, GValue* dest_value) {
	if (src_value->data[0].v_pointer) {
		dest_value->data[0].v_pointer = rygel_transcoder_ref (src_value->data[0].v_pointer);
	} else {
		dest_value->data[0].v_pointer = NULL;
	}
}


static gpointer rygel_value_transcoder_peek_pointer (const GValue* value) {
	return value->data[0].v_pointer;
}


static gchar* rygel_value_transcoder_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
	if (collect_values[0].v_pointer) {
		RygelTranscoder* object;
		object = collect_values[0].v_pointer;
		if (object->parent_instance.g_class == NULL) {
			return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
		} else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
			return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
		}
		value->data[0].v_pointer = rygel_transcoder_ref (object);
	} else {
		value->data[0].v_pointer = NULL;
	}
	return NULL;
}


static gchar* rygel_value_transcoder_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
	RygelTranscoder** object_p;
	object_p = collect_values[0].v_pointer;
	if (!object_p) {
		return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
	}
	if (!value->data[0].v_pointer) {
		*object_p = NULL;
	} else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
		*object_p = value->data[0].v_pointer;
	} else {
		*object_p = rygel_transcoder_ref (value->data[0].v_pointer);
	}
	return NULL;
}


GParamSpec* rygel_param_spec_transcoder (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
	RygelParamSpecTranscoder* spec;
	g_return_val_if_fail (g_type_is_a (object_type, RYGEL_TYPE_TRANSCODER), NULL);
	spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
	G_PARAM_SPEC (spec)->value_type = object_type;
	return G_PARAM_SPEC (spec);
}


gpointer rygel_value_get_transcoder (const GValue* value) {
	g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, RYGEL_TYPE_TRANSCODER), NULL);
	return value->data[0].v_pointer;
}


void rygel_value_set_transcoder (GValue* value, gpointer v_object) {
	RygelTranscoder* old;
	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, RYGEL_TYPE_TRANSCODER));
	old = value->data[0].v_pointer;
	if (v_object) {
		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, RYGEL_TYPE_TRANSCODER));
		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
		value->data[0].v_pointer = v_object;
		rygel_transcoder_ref (value->data[0].v_pointer);
	} else {
		value->data[0].v_pointer = NULL;
	}
	if (old) {
		rygel_transcoder_unref (old);
	}
}


void rygel_value_take_transcoder (GValue* value, gpointer v_object) {
	RygelTranscoder* old;
	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, RYGEL_TYPE_TRANSCODER));
	old = value->data[0].v_pointer;
	if (v_object) {
		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, RYGEL_TYPE_TRANSCODER));
		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
		value->data[0].v_pointer = v_object;
	} else {
		value->data[0].v_pointer = NULL;
	}
	if (old) {
		rygel_transcoder_unref (old);
	}
}


static void rygel_transcoder_class_init (RygelTranscoderClass * klass) {
	rygel_transcoder_parent_class = g_type_class_peek_parent (klass);
	RYGEL_TRANSCODER_CLASS (klass)->finalize = rygel_transcoder_finalize;
}


static void rygel_transcoder_instance_init (RygelTranscoder * self) {
	self->ref_count = 1;
}


static void rygel_transcoder_finalize (RygelTranscoder* obj) {
	RygelTranscoder * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, RYGEL_TYPE_TRANSCODER, RygelTranscoder);
}


GType rygel_transcoder_get_type (void) {
	static volatile gsize rygel_transcoder_type_id__volatile = 0;
	if (g_once_init_enter (&rygel_transcoder_type_id__volatile)) {
		static const GTypeValueTable g_define_type_value_table = { rygel_value_transcoder_init, rygel_value_transcoder_free_value, rygel_value_transcoder_copy_value, rygel_value_transcoder_peek_pointer, "p", rygel_value_transcoder_collect_value, "p", rygel_value_transcoder_lcopy_value };
		static const GTypeInfo g_define_type_info = { sizeof (RygelTranscoderClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) rygel_transcoder_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (RygelTranscoder), 0, (GInstanceInitFunc) rygel_transcoder_instance_init, &g_define_type_value_table };
		static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
		GType rygel_transcoder_type_id;
		rygel_transcoder_type_id = g_type_register_fundamental (g_type_fundamental_next (), "RygelTranscoder", &g_define_type_info, &g_define_type_fundamental_info, 0);
		g_once_init_leave (&rygel_transcoder_type_id__volatile, rygel_transcoder_type_id);
	}
	return rygel_transcoder_type_id__volatile;
}


gpointer rygel_transcoder_ref (gpointer instance) {
	RygelTranscoder* self;
	self = instance;
	g_atomic_int_inc (&self->ref_count);
	return instance;
}


void rygel_transcoder_unref (gpointer instance) {
	RygelTranscoder* self;
	self = instance;
	if (g_atomic_int_dec_and_test (&self->ref_count)) {
		RYGEL_TRANSCODER_GET_CLASS (self)->finalize (self);
		g_type_free_instance ((GTypeInstance *) self);
	}
}


void log_func (const gchar* domain, GLogLevelFlags flags, const gchar* message) {
	const gchar* _tmp0_ = NULL;
	gboolean _tmp1_ = FALSE;
	gboolean _tmp6_ = FALSE;
	gboolean _tmp7_ = FALSE;
	GLogLevelFlags _tmp8_ = 0;
	g_return_if_fail (message != NULL);
	_tmp0_ = message;
	_tmp1_ = g_str_has_prefix (_tmp0_, "Read-only property 'read-only-view' on class");
	if (_tmp1_) {
		GLogFunc _tmp2_ = NULL;
		void* _tmp2__target = NULL;
		const gchar* _tmp3_ = NULL;
		GLogLevelFlags _tmp4_ = 0;
		const gchar* _tmp5_ = NULL;
		_tmp2_ = g_log_default_handler;
		_tmp2__target = NULL;
		_tmp3_ = domain;
		_tmp4_ = flags;
		_tmp5_ = message;
		_tmp2_ (_tmp3_, _tmp4_, _tmp5_, _tmp2__target);
		return;
	}
	_tmp8_ = flags;
	if ((_tmp8_ & G_LOG_LEVEL_CRITICAL) == G_LOG_LEVEL_CRITICAL) {
		_tmp7_ = TRUE;
	} else {
		GLogLevelFlags _tmp9_ = 0;
		_tmp9_ = flags;
		_tmp7_ = (_tmp9_ & G_LOG_LEVEL_ERROR) == G_LOG_LEVEL_ERROR;
	}
	if (_tmp7_) {
		_tmp6_ = TRUE;
	} else {
		GLogLevelFlags _tmp10_ = 0;
		_tmp10_ = flags;
		_tmp6_ = (_tmp10_ & G_LOG_FLAG_FATAL) == G_LOG_FLAG_FATAL;
	}
	if (_tmp6_) {
		const gchar* _tmp11_ = NULL;
		const gchar* _tmp12_ = NULL;
		const gchar* _tmp13_ = NULL;
		_tmp12_ = domain;
		_tmp11_ = _tmp12_;
		if (_tmp11_ == NULL) {
			_tmp11_ = "";
		}
		_tmp13_ = message;
		g_print ("======> FAILED: %s: %s\n", _tmp11_, _tmp13_);
		g_assert_not_reached ();
	}
}


static void _log_func_glog_func (const gchar* log_domain, GLogLevelFlags log_levels, const gchar* message, gpointer self) {
	log_func (log_domain, log_levels, message);
}


gint rygel_http_object_creator_test_main (gchar** args, int args_length1) {
	gint result = 0;
	RygelHTTPObjectCreatorTest* test = NULL;
	RygelHTTPObjectCreatorTest* _tmp0_ = NULL;
	RygelSerializer* serializer = NULL;
	RygelSerializer* _tmp1_ = NULL;
	GUPnPDIDLLiteItem* _tmp2_ = NULL;
	GUPnPDIDLLiteItem* _tmp3_ = NULL;
	GUPnPDIDLLiteContainer* _tmp4_ = NULL;
	GUPnPDIDLLiteContainer* _tmp5_ = NULL;
	g_log_set_default_handler (_log_func_glog_func, NULL);
	_tmp0_ = rygel_http_object_creator_test_new ();
	test = _tmp0_;
	rygel_http_object_creator_test_test_parse_args (test);
	rygel_http_object_creator_test_test_didl_parsing (test);
	rygel_http_object_creator_test_test_fetch_container (test);
	_tmp1_ = rygel_serializer_new (SERIALIZER_TYPE_GENERIC_DIDL);
	serializer = _tmp1_;
	_tmp2_ = rygel_serializer_add_item (serializer);
	_tmp3_ = _tmp2_;
	_g_object_unref0 (_tmp3_);
	_tmp4_ = rygel_serializer_add_container (serializer);
	_tmp5_ = _tmp4_;
	_g_object_unref0 (_tmp5_);
	rygel_serializer_filter (serializer, "something");
	result = 0;
	_g_object_unref0 (serializer);
	_g_object_unref0 (test);
	return result;
}


int main (int argc, char ** argv) {
#if !GLIB_CHECK_VERSION (2,35,0)
	g_type_init ();
#endif
	return rygel_http_object_creator_test_main (argv, argc);
}


RygelHTTPObjectCreatorTest* rygel_http_object_creator_test_construct (GType object_type) {
	RygelHTTPObjectCreatorTest * self = NULL;
	GError* _tmp0_ = NULL;
	GError* _tmp1_ = NULL;
	GError* _tmp2_ = NULL;
	GError* _tmp3_ = NULL;
	GError* _tmp4_ = NULL;
	self = (RygelHTTPObjectCreatorTest*) g_object_new (object_type, NULL);
	_tmp0_ = g_error_new_literal (RYGEL_CONTENT_DIRECTORY_ERROR, RYGEL_CONTENT_DIRECTORY_ERROR_NO_SUCH_OBJECT, "");
	_g_error_free0 (self->priv->no_such_object);
	self->priv->no_such_object = _tmp0_;
	_tmp1_ = g_error_new_literal (RYGEL_CONTENT_DIRECTORY_ERROR, RYGEL_CONTENT_DIRECTORY_ERROR_NO_SUCH_CONTAINER, "");
	_g_error_free0 (self->priv->no_such_container);
	self->priv->no_such_container = _tmp1_;
	_tmp2_ = g_error_new_literal (RYGEL_CONTENT_DIRECTORY_ERROR, RYGEL_CONTENT_DIRECTORY_ERROR_RESTRICTED_PARENT, "");
	_g_error_free0 (self->priv->restricted_parent);
	self->priv->restricted_parent = _tmp2_;
	_tmp3_ = g_error_new_literal (RYGEL_CONTENT_DIRECTORY_ERROR, RYGEL_CONTENT_DIRECTORY_ERROR_BAD_METADATA, "");
	_g_error_free0 (self->priv->bad_metadata);
	self->priv->bad_metadata = _tmp3_;
	_tmp4_ = g_error_new_literal (RYGEL_CONTENT_DIRECTORY_ERROR, RYGEL_CONTENT_DIRECTORY_ERROR_INVALID_ARGS, "");
	_g_error_free0 (self->priv->invalid_args);
	self->priv->invalid_args = _tmp4_;
	return self;
}


RygelHTTPObjectCreatorTest* rygel_http_object_creator_test_new (void) {
	return rygel_http_object_creator_test_construct (RYGEL_TYPE_HTTP_OBJECT_CREATOR_TEST);
}


static void rygel_http_object_creator_test_test_parse_args (RygelHTTPObjectCreatorTest* self) {
	RygelContentDirectory* content_directory = NULL;
	RygelContentDirectory* _tmp0_ = NULL;
	RygelServiceAction* action = NULL;
	RygelServiceAction* _tmp1_ = NULL;
	RygelObjectCreator* creator = NULL;
	RygelServiceAction* _tmp2_ = NULL;
	RygelServiceAction* _tmp3_ = NULL;
	RygelObjectCreator* _tmp4_ = NULL;
	RygelObjectCreator* _tmp5_ = NULL;
	RygelServiceAction* _tmp6_ = NULL;
	gint _tmp7_ = 0;
	GError* _tmp8_ = NULL;
	gint _tmp9_ = 0;
	RygelServiceAction* _tmp10_ = NULL;
	RygelServiceAction* _tmp11_ = NULL;
	RygelServiceAction* _tmp12_ = NULL;
	RygelObjectCreator* _tmp13_ = NULL;
	RygelObjectCreator* _tmp14_ = NULL;
	RygelServiceAction* _tmp15_ = NULL;
	gint _tmp16_ = 0;
	GError* _tmp17_ = NULL;
	gint _tmp18_ = 0;
	RygelServiceAction* _tmp19_ = NULL;
	RygelServiceAction* _tmp20_ = NULL;
	RygelServiceAction* _tmp21_ = NULL;
	RygelObjectCreator* _tmp22_ = NULL;
	RygelObjectCreator* _tmp23_ = NULL;
	RygelServiceAction* _tmp24_ = NULL;
	gint _tmp25_ = 0;
	GError* _tmp26_ = NULL;
	gint _tmp27_ = 0;
	g_return_if_fail (self != NULL);
	_tmp0_ = rygel_content_directory_new ();
	content_directory = _tmp0_;
	_tmp1_ = rygel_service_action_new (NULL, "");
	action = _tmp1_;
	_tmp2_ = action;
	_tmp3_ = _g_object_ref0 (_tmp2_);
	_tmp4_ = rygel_object_creator_new (content_directory, _tmp3_);
	creator = _tmp4_;
	_tmp5_ = creator;
	rygel_state_machine_run ((RygelStateMachine*) _tmp5_, NULL, NULL);
	_tmp6_ = action;
	_tmp7_ = _tmp6_->error_code;
	_tmp8_ = self->priv->invalid_args;
	_tmp9_ = _tmp8_->code;
	_vala_assert (_tmp7_ == _tmp9_, "action.error_code == invalid_args.code");
	_tmp10_ = rygel_service_action_new ("0", "<!-- This is an XML comment -->");
	_g_object_unref0 (action);
	action = _tmp10_;
	_tmp11_ = action;
	_tmp12_ = _g_object_ref0 (_tmp11_);
	_tmp13_ = rygel_object_creator_new (content_directory, _tmp12_);
	_g_object_unref0 (creator);
	creator = _tmp13_;
	_tmp14_ = creator;
	rygel_state_machine_run ((RygelStateMachine*) _tmp14_, NULL, NULL);
	_tmp15_ = action;
	_tmp16_ = _tmp15_->error_code;
	_tmp17_ = self->priv->bad_metadata;
	_tmp18_ = _tmp17_->code;
	_vala_assert (_tmp16_ == _tmp18_, "action.error_code == bad_metadata.code");
	_tmp19_ = rygel_service_action_new ("0", NULL);
	_g_object_unref0 (action);
	action = _tmp19_;
	_tmp20_ = action;
	_tmp21_ = _g_object_ref0 (_tmp20_);
	_tmp22_ = rygel_object_creator_new (content_directory, _tmp21_);
	_g_object_unref0 (creator);
	creator = _tmp22_;
	_tmp23_ = creator;
	rygel_state_machine_run ((RygelStateMachine*) _tmp23_, NULL, NULL);
	_tmp24_ = action;
	_tmp25_ = _tmp24_->error_code;
	_tmp26_ = self->priv->bad_metadata;
	_tmp27_ = _tmp26_->code;
	_vala_assert (_tmp25_ == _tmp27_, "action.error_code == bad_metadata.code");
	_g_object_unref0 (creator);
	_g_object_unref0 (action);
	_g_object_unref0 (content_directory);
}


static void rygel_http_object_creator_test_test_didl_parsing_step (RygelHTTPObjectCreatorTest* self, xmlDoc* doc, gint expected_code) {
	gchar* xml = NULL;
	xmlDoc* _tmp0_ = NULL;
	gchar* _tmp1_ = NULL;
	RygelServiceAction* action = NULL;
	RygelServiceAction* _tmp2_ = NULL;
	RygelContentDirectory* content_directory = NULL;
	RygelContentDirectory* _tmp3_ = NULL;
	RygelObjectCreator* creator = NULL;
	RygelServiceAction* _tmp4_ = NULL;
	RygelObjectCreator* _tmp5_ = NULL;
	gint _tmp6_ = 0;
	gint _tmp7_ = 0;
	g_return_if_fail (self != NULL);
	_tmp0_ = doc;
	xmlDocDumpMemoryEnc (_tmp0_, (xmlChar**) (&_tmp1_), NULL, "UTF-8");
	_g_free0 (xml);
	xml = _tmp1_;
	_tmp2_ = rygel_service_action_new ("0", xml);
	action = _tmp2_;
	_tmp3_ = rygel_content_directory_new ();
	content_directory = _tmp3_;
	_tmp4_ = _g_object_ref0 (action);
	_tmp5_ = rygel_object_creator_new (content_directory, _tmp4_);
	creator = _tmp5_;
	rygel_state_machine_run ((RygelStateMachine*) creator, NULL, NULL);
	_tmp6_ = action->error_code;
	_tmp7_ = expected_code;
	_vala_assert (_tmp6_ == _tmp7_, "action.error_code == expected_code");
	_g_object_unref0 (creator);
	_g_object_unref0 (content_directory);
	_g_object_unref0 (action);
	_g_free0 (xml);
}


static void rygel_http_object_creator_test_test_didl_parsing (RygelHTTPObjectCreatorTest* self) {
	xmlDoc* xml = NULL;
	gint _tmp0_ = 0;
	gint _tmp1_ = 0;
	xmlDoc* _tmp2_ = NULL;
	xmlNode* didl_node = NULL;
	xmlNode* _tmp3_ = NULL;
	xmlNode* item_node = NULL;
	xmlNode* _tmp4_ = NULL;
	RygelContentDirectory* content_directory = NULL;
	RygelContentDirectory* _tmp5_ = NULL;
	RygelServiceAction* action = NULL;
	RygelServiceAction* _tmp6_ = NULL;
	RygelObjectCreator* creator = NULL;
	RygelServiceAction* _tmp7_ = NULL;
	RygelObjectCreator* _tmp8_ = NULL;
	gint _tmp9_ = 0;
	GError* _tmp10_ = NULL;
	gint _tmp11_ = 0;
	const gchar* _tmp12_ = NULL;
	GError* _tmp13_ = NULL;
	gint _tmp14_ = 0;
	xmlNode* tmp = NULL;
	xmlNode* _tmp15_ = NULL;
	xmlNode* _tmp16_ = NULL;
	xmlNode* _tmp17_ = NULL;
	GError* _tmp18_ = NULL;
	gint _tmp19_ = 0;
	xmlNode* _tmp20_ = NULL;
	GError* _tmp21_ = NULL;
	gint _tmp22_ = 0;
	xmlNode* _tmp23_ = NULL;
	xmlNode* _tmp24_ = NULL;
	xmlNode* _tmp25_ = NULL;
	xmlNode* _tmp26_ = NULL;
	GError* _tmp27_ = NULL;
	gint _tmp28_ = 0;
	xmlNode* _tmp29_ = NULL;
	GError* _tmp30_ = NULL;
	gint _tmp31_ = 0;
	xmlNode* _tmp32_ = NULL;
	xmlNode* _tmp33_ = NULL;
	xmlNode* title_node = NULL;
	xmlNode* _tmp34_ = NULL;
	xmlNode* _tmp35_ = NULL;
	xmlNode* _tmp36_ = NULL;
	GError* _tmp37_ = NULL;
	gint _tmp38_ = 0;
	xmlNode* _tmp39_ = NULL;
	xmlNode* _tmp40_ = NULL;
	xmlNode* class_node = NULL;
	xmlNode* _tmp41_ = NULL;
	xmlNode* _tmp42_ = NULL;
	xmlNode* _tmp43_ = NULL;
	GError* _tmp44_ = NULL;
	gint _tmp45_ = 0;
	GError* _tmp46_ = NULL;
	gint _tmp47_ = 0;
	g_return_if_fail (self != NULL);
	_tmp0_ = strlen (DIDL_ITEM);
	_tmp1_ = _tmp0_;
	_tmp2_ = xmlReadMemory (DIDL_ITEM, _tmp1_, NULL, NULL, (gint) (XML_PARSE_RECOVER | XML_PARSE_NOBLANKS));
	xml = _tmp2_;
	_tmp3_ = xml->children;
	didl_node = _tmp3_;
	_tmp4_ = didl_node->children;
	item_node = _tmp4_;
	_tmp5_ = rygel_content_directory_new ();
	content_directory = _tmp5_;
	_tmp6_ = rygel_service_action_new ("0", "");
	action = _tmp6_;
	_tmp7_ = _g_object_ref0 (action);
	_tmp8_ = rygel_object_creator_new (content_directory, _tmp7_);
	creator = _tmp8_;
	rygel_state_machine_run ((RygelStateMachine*) creator, NULL, NULL);
	_tmp9_ = action->error_code;
	_tmp10_ = self->priv->bad_metadata;
	_tmp11_ = _tmp10_->code;
	_vala_assert (_tmp9_ == _tmp11_, "action.error_code == bad_metadata.code");
	_tmp12_ = action->error_message;
	_vala_assert (g_strcmp0 (_tmp12_, "Bad metadata") == 0, "action.error_message == \"Bad metadata\"");
	xmlUnlinkNode (item_node);
	xmlNodeSetContent (didl_node, (xmlChar*) "  ");
	_tmp13_ = self->priv->bad_metadata;
	_tmp14_ = _tmp13_->code;
	rygel_http_object_creator_test_test_didl_parsing_step (self, xml, _tmp14_);
	_tmp15_ = xmlCopyNode (item_node, 1);
	tmp = _tmp15_;
	_tmp16_ = tmp;
	xmlUnsetProp (_tmp16_, (xmlChar*) "restricted");
	_tmp17_ = tmp;
	xmlAddChild (didl_node, _tmp17_);
	_tmp18_ = self->priv->bad_metadata;
	_tmp19_ = _tmp18_->code;
	rygel_http_object_creator_test_test_didl_parsing_step (self, xml, _tmp19_);
	_tmp20_ = tmp;
	xmlSetProp (_tmp20_, (xmlChar*) "restricted", (xmlChar*) "1");
	_tmp21_ = self->priv->bad_metadata;
	_tmp22_ = _tmp21_->code;
	rygel_http_object_creator_test_test_didl_parsing_step (self, xml, _tmp22_);
	_tmp23_ = tmp;
	xmlUnlinkNode (_tmp23_);
	_tmp24_ = xmlCopyNode (item_node, 1);
	tmp = _tmp24_;
	_tmp25_ = tmp;
	xmlSetProp (_tmp25_, (xmlChar*) "id", (xmlChar*) "InvalidItemId");
	_tmp26_ = tmp;
	xmlAddChild (didl_node, _tmp26_);
	_tmp27_ = self->priv->bad_metadata;
	_tmp28_ = _tmp27_->code;
	rygel_http_object_creator_test_test_didl_parsing_step (self, xml, _tmp28_);
	_tmp29_ = tmp;
	xmlUnsetProp (_tmp29_, (xmlChar*) "id");
	_tmp30_ = self->priv->bad_metadata;
	_tmp31_ = _tmp30_->code;
	rygel_http_object_creator_test_test_didl_parsing_step (self, xml, _tmp31_);
	_tmp32_ = tmp;
	xmlUnlinkNode (_tmp32_);
	_tmp33_ = xmlCopyNode (item_node, 1);
	tmp = _tmp33_;
	_tmp34_ = tmp;
	_tmp35_ = _tmp34_->children;
	title_node = _tmp35_;
	xmlUnlinkNode (title_node);
	_tmp36_ = tmp;
	xmlAddChild (didl_node, _tmp36_);
	_tmp37_ = self->priv->bad_metadata;
	_tmp38_ = _tmp37_->code;
	rygel_http_object_creator_test_test_didl_parsing_step (self, xml, _tmp38_);
	_tmp39_ = tmp;
	xmlUnlinkNode (_tmp39_);
	_tmp40_ = xmlCopyNode (item_node, 1);
	tmp = _tmp40_;
	_tmp41_ = tmp;
	_tmp42_ = _tmp41_->children;
	_tmp43_ = _tmp42_->next;
	class_node = _tmp43_;
	xmlNodeSetContent (class_node, (xmlChar*) "");
	_tmp44_ = self->priv->bad_metadata;
	_tmp45_ = _tmp44_->code;
	rygel_http_object_creator_test_test_didl_parsing_step (self, xml, _tmp45_);
	xmlUnlinkNode (class_node);
	_tmp46_ = self->priv->bad_metadata;
	_tmp47_ = _tmp46_->code;
	rygel_http_object_creator_test_test_didl_parsing_step (self, xml, _tmp47_);
	_g_object_unref0 (creator);
	_g_object_unref0 (action);
	_g_object_unref0 (content_directory);
}


static Block3Data* block3_data_ref (Block3Data* _data3_) {
	g_atomic_int_inc (&_data3_->_ref_count_);
	return _data3_;
}


static void block3_data_unref (void * _userdata_) {
	Block3Data* _data3_;
	_data3_ = (Block3Data*) _userdata_;
	if (g_atomic_int_dec_and_test (&_data3_->_ref_count_)) {
		RygelHTTPObjectCreatorTest* self;
		self = _data3_->self;
		_g_main_loop_unref0 (_data3_->main_loop);
		_g_object_unref0 (self);
		g_slice_free (Block3Data, _data3_);
	}
}


static void __lambda9_ (Block3Data* _data3_) {
	RygelHTTPObjectCreatorTest* self;
	self = _data3_->self;
	g_main_loop_quit (_data3_->main_loop);
}


static void ___lambda9__gasync_ready_callback (GObject* source_object, GAsyncResult* res, gpointer self) {
	__lambda9_ (self);
	block3_data_unref (self);
}


static void rygel_http_object_creator_test_test_fetch_container_run (RygelHTTPObjectCreatorTest* self, RygelObjectCreator* creator) {
	Block3Data* _data3_;
	GMainLoop* _tmp0_ = NULL;
	RygelObjectCreator* _tmp1_ = NULL;
	g_return_if_fail (self != NULL);
	g_return_if_fail (creator != NULL);
	_data3_ = g_slice_new0 (Block3Data);
	_data3_->_ref_count_ = 1;
	_data3_->self = g_object_ref (self);
	_tmp0_ = g_main_loop_new (NULL, FALSE);
	_data3_->main_loop = _tmp0_;
	_tmp1_ = creator;
	rygel_state_machine_run ((RygelStateMachine*) _tmp1_, ___lambda9__gasync_ready_callback, block3_data_ref (_data3_));
	g_main_loop_run (_data3_->main_loop);
	block3_data_unref (_data3_);
	_data3_ = NULL;
}


static void rygel_http_object_creator_test_test_fetch_container (RygelHTTPObjectCreatorTest* self) {
	RygelContentDirectory* content_directory = NULL;
	RygelContentDirectory* _tmp0_ = NULL;
	RygelSearchableContainer* root_container = NULL;
	RygelSearchableContainer* _tmp1_ = NULL;
	RygelMediaContainer* _tmp2_ = NULL;
	RygelServiceAction* action = NULL;
	RygelServiceAction* _tmp3_ = NULL;
	RygelObjectCreator* creator = NULL;
	RygelServiceAction* _tmp4_ = NULL;
	RygelObjectCreator* _tmp5_ = NULL;
	gint _tmp6_ = 0;
	GError* _tmp7_ = NULL;
	gint _tmp8_ = 0;
	RygelMediaObject* _tmp9_ = NULL;
	gint _tmp10_ = 0;
	GError* _tmp11_ = NULL;
	gint _tmp12_ = 0;
	RygelMediaContainer* _tmp13_ = NULL;
	gint _tmp14_ = 0;
	GError* _tmp15_ = NULL;
	gint _tmp16_ = 0;
	RygelMediaObject* _tmp17_ = NULL;
	RygelMediaObject* _tmp18_ = NULL;
	GUPnPOCMFlags _tmp19_ = 0;
	gint _tmp20_ = 0;
	GError* _tmp21_ = NULL;
	gint _tmp22_ = 0;
	RygelWritableContainer* container = NULL;
	RygelWritableContainer* _tmp23_ = NULL;
	GeeArrayList* _tmp24_ = NULL;
	GUPnPOCMFlags _tmp25_ = 0;
	RygelMediaObject* _tmp26_ = NULL;
	gint _tmp27_ = 0;
	GError* _tmp28_ = NULL;
	gint _tmp29_ = 0;
	RygelMediaContainer* _tmp30_ = NULL;
	gchar* _tmp31_ = NULL;
	gint _tmp32_ = 0;
	GError* _tmp33_ = NULL;
	gint _tmp34_ = 0;
	RygelSearchableContainer* _tmp35_ = NULL;
	gint _tmp36_ = 0;
	GError* _tmp37_ = NULL;
	gint _tmp38_ = 0;
	g_return_if_fail (self != NULL);
	_tmp0_ = rygel_content_directory_new ();
	content_directory = _tmp0_;
	_tmp1_ = rygel_searchable_container_new ();
	root_container = _tmp1_;
	_tmp2_ = _g_object_ref0 ((RygelMediaContainer*) root_container);
	_g_object_unref0 (content_directory->root_container);
	content_directory->root_container = _tmp2_;
	_tmp3_ = rygel_service_action_new ("0", DIDL_ITEM);
	action = _tmp3_;
	_tmp4_ = _g_object_ref0 (action);
	_tmp5_ = rygel_object_creator_new (content_directory, _tmp4_);
	creator = _tmp5_;
	rygel_http_object_creator_test_test_fetch_container_run (self, creator);
	_tmp6_ = action->error_code;
	_tmp7_ = self->priv->no_such_container;
	_tmp8_ = _tmp7_->code;
	_vala_assert (_tmp6_ == _tmp8_, "action.error_code == no_such_container.code");
	_tmp9_ = rygel_media_object_new ();
	_g_object_unref0 (((RygelMediaContainer*) root_container)->found_object);
	((RygelMediaContainer*) root_container)->found_object = _tmp9_;
	rygel_http_object_creator_test_test_fetch_container_run (self, creator);
	_tmp10_ = action->error_code;
	_tmp11_ = self->priv->no_such_container;
	_tmp12_ = _tmp11_->code;
	_vala_assert (_tmp10_ == _tmp12_, "action.error_code == no_such_container.code");
	_tmp13_ = rygel_media_container_new ();
	_g_object_unref0 (((RygelMediaContainer*) root_container)->found_object);
	((RygelMediaContainer*) root_container)->found_object = (RygelMediaObject*) _tmp13_;
	rygel_http_object_creator_test_test_fetch_container_run (self, creator);
	_tmp14_ = action->error_code;
	_tmp15_ = self->priv->restricted_parent;
	_tmp16_ = _tmp15_->code;
	_vala_assert (_tmp14_ == _tmp16_, "action.error_code == restricted_parent.code");
	_tmp17_ = ((RygelMediaContainer*) root_container)->found_object;
	_tmp18_ = ((RygelMediaContainer*) root_container)->found_object;
	_tmp19_ = _tmp18_->ocm_flags;
	_tmp18_->ocm_flags = _tmp19_ | GUPNP_OCM_FLAGS_UPLOAD;
	rygel_http_object_creator_test_test_fetch_container_run (self, creator);
	_tmp20_ = action->error_code;
	_tmp21_ = self->priv->restricted_parent;
	_tmp22_ = _tmp21_->code;
	_vala_assert (_tmp20_ == _tmp22_, "action.error_code == restricted_parent.code");
	_tmp23_ = rygel_writable_container_new ();
	container = _tmp23_;
	_tmp24_ = ((RygelMediaContainer*) container)->create_classes;
	gee_abstract_collection_add ((GeeAbstractCollection*) _tmp24_, "object.item.imageItem.musicTrack");
	_tmp25_ = ((RygelMediaObject*) container)->ocm_flags;
	((RygelMediaObject*) container)->ocm_flags = _tmp25_ | GUPNP_OCM_FLAGS_UPLOAD;
	_tmp26_ = _g_object_ref0 ((RygelMediaObject*) container);
	_g_object_unref0 (((RygelMediaContainer*) root_container)->found_object);
	((RygelMediaContainer*) root_container)->found_object = _tmp26_;
	rygel_http_object_creator_test_test_fetch_container_run (self, creator);
	_tmp27_ = action->error_code;
	_tmp28_ = self->priv->bad_metadata;
	_tmp29_ = _tmp28_->code;
	_vala_assert (_tmp27_ == _tmp29_, "action.error_code == bad_metadata.code");
	_tmp30_ = rygel_media_container_new ();
	_g_object_unref0 (content_directory->root_container);
	content_directory->root_container = _tmp30_;
	_tmp31_ = g_strdup ("DLNA.ORG_AnyContainer");
	_g_free0 (action->id);
	action->id = _tmp31_;
	rygel_http_object_creator_test_test_fetch_container_run (self, creator);
	_tmp32_ = action->error_code;
	_tmp33_ = self->priv->no_such_container;
	_tmp34_ = _tmp33_->code;
	_vala_assert (_tmp32_ == _tmp34_, "action.error_code == no_such_container.code");
	_tmp35_ = rygel_searchable_container_new ();
	_g_object_unref0 (content_directory->root_container);
	content_directory->root_container = (RygelMediaContainer*) _tmp35_;
	rygel_http_object_creator_test_test_fetch_container_run (self, creator);
	_tmp36_ = action->error_code;
	_tmp37_ = self->priv->bad_metadata;
	_tmp38_ = _tmp37_->code;
	_vala_assert (_tmp36_ == _tmp38_, "action.error_code == bad_metadata.code");
	_g_object_unref0 (container);
	_g_object_unref0 (creator);
	_g_object_unref0 (action);
	_g_object_unref0 (root_container);
	_g_object_unref0 (content_directory);
}


static void rygel_http_object_creator_test_class_init (RygelHTTPObjectCreatorTestClass * klass) {
	rygel_http_object_creator_test_parent_class = g_type_class_peek_parent (klass);
	g_type_class_add_private (klass, sizeof (RygelHTTPObjectCreatorTestPrivate));
	G_OBJECT_CLASS (klass)->finalize = rygel_http_object_creator_test_finalize;
}


static void rygel_http_object_creator_test_instance_init (RygelHTTPObjectCreatorTest * self) {
	self->priv = RYGEL_HTTP_OBJECT_CREATOR_TEST_GET_PRIVATE (self);
}


static void rygel_http_object_creator_test_finalize (GObject* obj) {
	RygelHTTPObjectCreatorTest * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, RYGEL_TYPE_HTTP_OBJECT_CREATOR_TEST, RygelHTTPObjectCreatorTest);
	_g_error_free0 (self->priv->no_such_object);
	_g_error_free0 (self->priv->no_such_container);
	_g_error_free0 (self->priv->restricted_parent);
	_g_error_free0 (self->priv->bad_metadata);
	_g_error_free0 (self->priv->invalid_args);
	G_OBJECT_CLASS (rygel_http_object_creator_test_parent_class)->finalize (obj);
}


GType rygel_http_object_creator_test_get_type (void) {
	static volatile gsize rygel_http_object_creator_test_type_id__volatile = 0;
	if (g_once_init_enter (&rygel_http_object_creator_test_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (RygelHTTPObjectCreatorTestClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) rygel_http_object_creator_test_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (RygelHTTPObjectCreatorTest), 0, (GInstanceInitFunc) rygel_http_object_creator_test_instance_init, NULL };
		GType rygel_http_object_creator_test_type_id;
		rygel_http_object_creator_test_type_id = g_type_register_static (G_TYPE_OBJECT, "RygelHTTPObjectCreatorTest", &g_define_type_info, 0);
		g_once_init_leave (&rygel_http_object_creator_test_type_id__volatile, rygel_http_object_creator_test_type_id);
	}
	return rygel_http_object_creator_test_type_id__volatile;
}



