/* test.c generated by valac 0.40.8, the Vala compiler
 * generated from 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.1 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 library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */


#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;
enum  {
	RYGEL_SERVICE_ACTION_0_PROPERTY,
	RYGEL_SERVICE_ACTION_NUM_PROPERTIES
};
static GParamSpec* rygel_service_action_properties[RYGEL_SERVICE_ACTION_NUM_PROPERTIES];
#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;
enum  {
	RYGEL_HTTP_SERVER_0_PROPERTY,
	RYGEL_HTTP_SERVER_NUM_PROPERTIES
};
static GParamSpec* rygel_http_server_properties[RYGEL_HTTP_SERVER_NUM_PROPERTIES];

#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;
enum  {
	RYGEL_OBJECT_REMOVAL_QUEUE_0_PROPERTY,
	RYGEL_OBJECT_REMOVAL_QUEUE_NUM_PROPERTIES
};
static GParamSpec* rygel_object_removal_queue_properties[RYGEL_OBJECT_REMOVAL_QUEUE_NUM_PROPERTIES];

#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;
enum  {
	RYGEL_MEDIA_SERVER_PLUGIN_0_PROPERTY,
	RYGEL_MEDIA_SERVER_PLUGIN_NUM_PROPERTIES
};
static GParamSpec* rygel_media_server_plugin_properties[RYGEL_MEDIA_SERVER_PLUGIN_NUM_PROPERTIES];
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;
enum  {
	RYGEL_MEDIA_OBJECT_0_PROPERTY,
	RYGEL_MEDIA_OBJECT_ID_PROPERTY,
	RYGEL_MEDIA_OBJECT_PARENT_PROPERTY,
	RYGEL_MEDIA_OBJECT_TITLE_PROPERTY,
	RYGEL_MEDIA_OBJECT_NUM_PROPERTIES
};
static GParamSpec* rygel_media_object_properties[RYGEL_MEDIA_OBJECT_NUM_PROPERTIES];
#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;
enum  {
	RYGEL_MEDIA_ITEM_0_PROPERTY,
	RYGEL_MEDIA_ITEM_NUM_PROPERTIES
};
static GParamSpec* rygel_media_item_properties[RYGEL_MEDIA_ITEM_NUM_PROPERTIES];

#define RYGEL_TYPE_MEDIA_FILE_ITEM (rygel_media_file_item_get_type ())
#define RYGEL_MEDIA_FILE_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_MEDIA_FILE_ITEM, RygelMediaFileItem))
#define RYGEL_MEDIA_FILE_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_MEDIA_FILE_ITEM, RygelMediaFileItemClass))
#define RYGEL_IS_MEDIA_FILE_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_MEDIA_FILE_ITEM))
#define RYGEL_IS_MEDIA_FILE_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_MEDIA_FILE_ITEM))
#define RYGEL_MEDIA_FILE_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_MEDIA_FILE_ITEM, RygelMediaFileItemClass))

typedef struct _RygelMediaFileItem RygelMediaFileItem;
typedef struct _RygelMediaFileItemClass RygelMediaFileItemClass;
typedef struct _RygelMediaFileItemPrivate RygelMediaFileItemPrivate;
enum  {
	RYGEL_MEDIA_FILE_ITEM_0_PROPERTY,
	RYGEL_MEDIA_FILE_ITEM_NUM_PROPERTIES
};
static GParamSpec* rygel_media_file_item_properties[RYGEL_MEDIA_FILE_ITEM_NUM_PROPERTIES];

#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;
enum  {
	RYGEL_MUSIC_ITEM_0_PROPERTY,
	RYGEL_MUSIC_ITEM_NUM_PROPERTIES
};
static GParamSpec* rygel_music_item_properties[RYGEL_MUSIC_ITEM_NUM_PROPERTIES];
enum  {
	RYGEL_AUDIO_ITEM_0_PROPERTY,
	RYGEL_AUDIO_ITEM_NUM_PROPERTIES
};
static GParamSpec* rygel_audio_item_properties[RYGEL_AUDIO_ITEM_NUM_PROPERTIES];

#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;
enum  {
	RYGEL_IMAGE_ITEM_0_PROPERTY,
	RYGEL_IMAGE_ITEM_NUM_PROPERTIES
};
static GParamSpec* rygel_image_item_properties[RYGEL_IMAGE_ITEM_NUM_PROPERTIES];

#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;
enum  {
	RYGEL_VIDEO_ITEM_0_PROPERTY,
	RYGEL_VIDEO_ITEM_NUM_PROPERTIES
};
static GParamSpec* rygel_video_item_properties[RYGEL_VIDEO_ITEM_NUM_PROPERTIES];

#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;
enum  {
	RYGEL_PHOTO_ITEM_0_PROPERTY,
	RYGEL_PHOTO_ITEM_NUM_PROPERTIES
};
static GParamSpec* rygel_photo_item_properties[RYGEL_PHOTO_ITEM_NUM_PROPERTIES];

#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;
enum  {
	RYGEL_PLAYLIST_ITEM_0_PROPERTY,
	RYGEL_PLAYLIST_ITEM_NUM_PROPERTIES
};
static GParamSpec* rygel_playlist_item_properties[RYGEL_PLAYLIST_ITEM_NUM_PROPERTIES];

#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;
enum  {
	RYGEL_ROOT_DEVICE_0_PROPERTY,
	RYGEL_ROOT_DEVICE_NUM_PROPERTIES
};
static GParamSpec* rygel_root_device_properties[RYGEL_ROOT_DEVICE_NUM_PROPERTIES];

#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;
enum  {
	RYGEL_CONTENT_DIRECTORY_0_PROPERTY,
	RYGEL_CONTENT_DIRECTORY_NUM_PROPERTIES
};
static GParamSpec* rygel_content_directory_properties[RYGEL_CONTENT_DIRECTORY_NUM_PROPERTIES];
typedef struct _RygelMediaContainerPrivate RygelMediaContainerPrivate;
enum  {
	RYGEL_MEDIA_CONTAINER_0_PROPERTY,
	RYGEL_MEDIA_CONTAINER_CHILD_COUNT_PROPERTY,
	RYGEL_MEDIA_CONTAINER_NUM_PROPERTIES
};
static GParamSpec* rygel_media_container_properties[RYGEL_MEDIA_CONTAINER_NUM_PROPERTIES];
typedef struct _Block1Data Block1Data;
typedef struct _RygelMediaContainerFindObjectData RygelMediaContainerFindObjectData;
enum  {
	RYGEL_MEDIA_CONTAINER_CONTAINER_UPDATED_SIGNAL,
	RYGEL_MEDIA_CONTAINER_NUM_SIGNALS
};
static guint rygel_media_container_signals[RYGEL_MEDIA_CONTAINER_NUM_SIGNALS] = {0};
typedef struct _RygelMediaObjectsPrivate RygelMediaObjectsPrivate;
enum  {
	RYGEL_MEDIA_OBJECTS_0_PROPERTY,
	RYGEL_MEDIA_OBJECTS_NUM_PROPERTIES
};
static GParamSpec* rygel_media_objects_properties[RYGEL_MEDIA_OBJECTS_NUM_PROPERTIES];

#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;
enum  {
	RYGEL_WRITABLE_CONTAINER_0_PROPERTY,
	RYGEL_WRITABLE_CONTAINER_NUM_PROPERTIES
};
static GParamSpec* rygel_writable_container_properties[RYGEL_WRITABLE_CONTAINER_NUM_PROPERTIES];
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;
enum  {
	RYGEL_SEARCHABLE_CONTAINER_0_PROPERTY,
	RYGEL_SEARCHABLE_CONTAINER_NUM_PROPERTIES
};
static GParamSpec* rygel_searchable_container_properties[RYGEL_SEARCHABLE_CONTAINER_NUM_PROPERTIES];
#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;
enum  {
	RYGEL_HTTP_OBJECT_CREATOR_TEST_0_PROPERTY,
	RYGEL_HTTP_OBJECT_CREATOR_TEST_NUM_PROPERTIES
};
static GParamSpec* rygel_http_object_creator_test_properties[RYGEL_HTTP_OBJECT_CREATOR_TEST_NUM_PROPERTIES];
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))

#define RYGEL_TYPE_SERIALIZER_TYPE (rygel_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);
#define _vala_return_if_fail(expr, msg) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return; }
#define _vala_return_val_if_fail(expr, msg, val) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return val; }
#define _vala_warn_if_fail(expr, msg) if G_LIKELY (expr) ; else g_warn_message (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_;
	GTask* _async_result;
	GAsyncReadyCallback _callback_;
	gboolean _task_complete_;
	RygelMediaObject* self;
	guint offset;
	guint max_count;
	gchar* sort_criteria;
	GCancellable* cancellable;
	RygelMediaObjects* result;
};

struct _RygelMediaObjectFindObjectData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GTask* _async_result;
	GAsyncReadyCallback _callback_;
	gboolean _task_complete_;
	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;
};

struct _RygelMediaItemClass {
	RygelMediaObjectClass parent_class;
};

struct _RygelMediaFileItem {
	RygelMediaItem parent_instance;
	RygelMediaFileItemPrivate * priv;
	gchar* dlna_profile;
	gchar* mime_type;
	glong size;
	gboolean place_holder;
	gchar* date;
};

struct _RygelMediaFileItemClass {
	RygelMediaItemClass parent_class;
};

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

struct _RygelAudioItemClass {
	RygelMediaFileItemClass parent_class;
};

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

struct _RygelMusicItemClass {
	RygelAudioItemClass parent_class;
};

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

struct _RygelImageItemClass {
	RygelMediaFileItemClass parent_class;
};

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

struct _RygelVideoItemClass {
	RygelMediaFileItemClass parent_class;
};

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

struct _RygelPhotoItemClass {
	RygelMediaFileItemClass parent_class;
};

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

struct _RygelPlaylistItemClass {
	RygelMediaFileItemClass 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_;
	GTask* _async_result;
	GAsyncReadyCallback _callback_;
	gboolean _task_complete_;
	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_;
	GTask* _async_result;
	GAsyncReadyCallback _callback_;
	gboolean _task_complete_;
	RygelWritableContainer* self;
	GCancellable* cancellable;
	GFile* result;
	GFile* _tmp0_;
};

struct _RygelWritableContainerAddItemData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GTask* _async_result;
	GAsyncReadyCallback _callback_;
	gboolean _task_complete_;
	RygelWritableContainer* self;
	RygelMediaItem* item;
	GCancellable* cancellable;
};

struct _RygelWritableContainerAddContainerData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GTask* _async_result;
	GAsyncReadyCallback _callback_;
	gboolean _task_complete_;
	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_;
	GTask* _async_result;
	GAsyncReadyCallback _callback_;
	gboolean _task_complete_;
	RygelSearchableContainer* self;
	RygelSearchExpression* expression;
	gint offset;
	gint count;
	gchar* soer_criteria;
	GCancellable* cancellable;
	gint total_matches;
	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  {
	RYGEL_SERIALIZER_TYPE_GENERIC_DIDL,
	RYGEL_SERIALIZER_TYPE_DIDL_S,
	RYGEL_SERIALIZER_TYPE_M3UEXT
} RygelSerializerType;

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_media_file_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;
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;
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;
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;
static void _rygel_dlna_profile_unref0_ (gpointer var);
static inline 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))
void rygel_media_object_add_uri (RygelMediaObject* self,
                                 const gchar* uri);
GeeArrayList* rygel_media_object_get_uris (RygelMediaObject* self);
gchar* rygel_media_object_get_primary_uri (RygelMediaObject* self);
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_async_ready_wrapper (GObject *source_object,
                                                               GAsyncResult *res,
                                                               void *user_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_async_ready_wrapper (GObject *source_object,
                                                              GAsyncResult *res,
                                                              void *user_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;
RygelMediaItem* rygel_media_item_new (void);
RygelMediaItem* rygel_media_item_construct (GType object_type);
GType rygel_media_file_item_get_type (void) G_GNUC_CONST;
RygelMediaFileItem* rygel_media_file_item_new (const gchar* id,
                                               RygelMediaContainer* parent,
                                               const gchar* title);
RygelMediaFileItem* rygel_media_file_item_construct (GType object_type,
                                                     const gchar* id,
                                                     RygelMediaContainer* parent,
                                                     const gchar* title);
static void rygel_media_file_item_finalize (GObject * obj);
GType rygel_audio_item_get_type (void) G_GNUC_CONST;
GType rygel_music_item_get_type (void) G_GNUC_CONST;
#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);
#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;
#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;
#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;
#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;
#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;
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;
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))
#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_async_ready_wrapper (GObject *source_object,
                                                                 GAsyncResult *res,
                                                                 void *user_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);
RygelMediaObjects* rygel_media_objects_new (void);
RygelMediaObjects* rygel_media_objects_construct (GType object_type);
GType rygel_writable_container_get_type (void) G_GNUC_CONST;
gboolean rygel_writable_container_can_create (RygelWritableContainer* self,
                                              const gchar* upnp_class);
static void rygel_writable_container_get_writable_data_free (gpointer _data);
static void rygel_writable_container_get_writable_async_ready_wrapper (GObject *source_object,
                                                                GAsyncResult *res,
                                                                void *user_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);
static void rygel_writable_container_add_item_async_ready_wrapper (GObject *source_object,
                                                            GAsyncResult *res,
                                                            void *user_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);
static void rygel_writable_container_add_container_async_ready_wrapper (GObject *source_object,
                                                                 GAsyncResult *res,
                                                                 void *user_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;
static void rygel_searchable_container_search_data_free (gpointer _data);
static void rygel_searchable_container_search_async_ready_wrapper (GObject *source_object,
                                                            GAsyncResult *res,
                                                            void *user_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;
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))
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 rygel_serializer_type_get_type (void) G_GNUC_CONST;
RygelSerializer* rygel_serializer_new (RygelSerializerType type);
RygelSerializer* rygel_serializer_construct (GType object_type,
                                             RygelSerializerType 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;
	gchar* _tmp0_;
	gchar* _tmp1_;
	self = (RygelServiceAction*) g_object_new (object_type, NULL);
	_tmp0_ = g_strdup (container_id);
	_g_free0 (self->id);
	self->id = _tmp0_;
	_tmp1_ = g_strdup (elements);
	_g_free0 (self->elements);
	self->elements = _tmp1_;
	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)
{
	gchar* _tmp0_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (message != NULL);
	self->error_code = code;
	_tmp0_ = g_strdup (message);
	_g_free0 (self->error_message);
	self->error_message = _tmp0_;
}


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_;
	gchar* _tmp1_;
	const gchar* _tmp2_;
	gchar* _tmp3_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (arg1_name != NULL);
	g_return_if_fail (arg2_name != NULL);
	_vala_assert (g_strcmp0 (arg1_name, "ContainerID") == 0, "arg1_name == \"ContainerID\"");
	_vala_assert (arg1_type == G_TYPE_STRING, "arg1_type == typeof (string)");
	_tmp0_ = self->id;
	_tmp1_ = g_strdup (_tmp0_);
	_g_free0 (_vala_arg1_val);
	_vala_arg1_val = _tmp1_;
	_vala_assert (g_strcmp0 (arg2_name, "Elements") == 0, "arg2_name == \"Elements\"");
	_vala_assert (arg2_type == G_TYPE_STRING, "arg2_type == typeof (string)");
	_tmp2_ = self->elements;
	_tmp3_ = g_strdup (_tmp2_);
	_g_free0 (_vala_arg2_val);
	_vala_arg2_val = _tmp3_;
	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)
{
	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);
	_vala_assert (g_strcmp0 (arg1_name, "ObjectID") == 0, "arg1_name == \"ObjectID\"");
	_vala_assert (arg1_type == G_TYPE_STRING, "arg1_type == typeof (string)");
	_vala_assert (g_strcmp0 (arg2_name, "Result") == 0, "arg2_name == \"Result\"");
	_vala_assert (arg2_type == 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_;
	_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 inline void
_g_list_free__rygel_dlna_profile_unref0_ (GList* self)
{
	g_list_free_full (self, (GDestroyNotify) _rygel_dlna_profile_unref0_);
}


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);
	(self->upload_profiles == NULL) ? NULL : (self->upload_profiles = (_g_list_free__rygel_dlna_profile_unref0_ (self->upload_profiles), NULL));
	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_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (uri != NULL);
	_tmp0_ = self->uris;
	gee_abstract_collection_add ((GeeAbstractCollection*) _tmp0_, uri);
}


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


GeeArrayList*
rygel_media_object_get_uris (RygelMediaObject* self)
{
	GeeArrayList* result = NULL;
	GeeArrayList* _tmp0_;
	GeeArrayList* _tmp1_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->uris;
	_tmp1_ = _g_object_ref0 (_tmp0_);
	result = _tmp1_;
	return result;
}


gchar*
rygel_media_object_get_primary_uri (RygelMediaObject* self)
{
	gchar* result = NULL;
	GeeArrayList* _tmp0_;
	gpointer _tmp1_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->uris;
	_tmp1_ = gee_abstract_list_get ((GeeAbstractList*) _tmp0_, 0);
	result = (gchar*) _tmp1_;
	return result;
}


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 void
rygel_media_object_real_get_children_async_ready_wrapper (GObject *source_object,
                                                          GAsyncResult *res,
                                                          void *user_data)
{
	RygelMediaObjectGetChildrenData* _task_data_;
	_task_data_ = g_task_get_task_data (G_TASK (res));
	if (_task_data_->_callback_ != NULL) {
		_task_data_->_callback_ (source_object, res, user_data);
	}
	_task_data_->_task_complete_ = TRUE;
}


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_;
	gchar* _tmp1_;
	GCancellable* _tmp2_;
	_data_ = g_slice_new0 (RygelMediaObjectGetChildrenData);
	_data_->_callback_ = _callback_;
	_data_->_async_result = g_task_new (G_OBJECT (self), cancellable, rygel_media_object_real_get_children_async_ready_wrapper, _user_data_);
	if (_callback_ == NULL) {
		_data_->_task_complete_ = TRUE;
	}
	g_task_set_task_data (_data_->_async_result, _data_, rygel_media_object_real_get_children_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_data_->offset = offset;
	_data_->max_count = max_count;
	_tmp1_ = g_strdup (sort_criteria);
	_g_free0 (_data_->sort_criteria);
	_data_->sort_criteria = _tmp1_;
	_tmp2_ = _g_object_ref0 (cancellable);
	_g_object_unref0 (_data_->cancellable);
	_data_->cancellable = _tmp2_;
	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_;
	_data_ = g_task_propagate_pointer (G_TASK (_res_), error);
	if (NULL == _data_) {
		return NULL;
	}
	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;
	g_task_return_pointer (_data_->_async_result, _data_, NULL);
	if (_data_->_state_ != 0) {
		while (_data_->_task_complete_ != TRUE) {
			g_main_context_iteration (g_task_get_context (_data_->_async_result), TRUE);
		}
	}
	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_async_ready_wrapper (GObject *source_object,
                                                         GAsyncResult *res,
                                                         void *user_data)
{
	RygelMediaObjectFindObjectData* _task_data_;
	_task_data_ = g_task_get_task_data (G_TASK (res));
	if (_task_data_->_callback_ != NULL) {
		_task_data_->_callback_ (source_object, res, user_data);
	}
	_task_data_->_task_complete_ = TRUE;
}


static void
rygel_media_object_real_find_object (RygelMediaObject* self,
                                     const gchar* id,
                                     GCancellable* cancellable,
                                     GAsyncReadyCallback _callback_,
                                     gpointer _user_data_)
{
	RygelMediaObjectFindObjectData* _data_;
	RygelMediaObject* _tmp0_;
	gchar* _tmp1_;
	GCancellable* _tmp2_;
	_data_ = g_slice_new0 (RygelMediaObjectFindObjectData);
	_data_->_callback_ = _callback_;
	_data_->_async_result = g_task_new (G_OBJECT (self), cancellable, rygel_media_object_real_find_object_async_ready_wrapper, _user_data_);
	if (_callback_ == NULL) {
		_data_->_task_complete_ = TRUE;
	}
	g_task_set_task_data (_data_->_async_result, _data_, rygel_media_object_real_find_object_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = g_strdup (id);
	_g_free0 (_data_->id);
	_data_->id = _tmp1_;
	_tmp2_ = _g_object_ref0 (cancellable);
	_g_object_unref0 (_data_->cancellable);
	_data_->cancellable = _tmp2_;
	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_;
	_data_ = g_task_propagate_pointer (G_TASK (_res_), error);
	if (NULL == _data_) {
		return NULL;
	}
	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;
	g_task_return_pointer (_data_->_async_result, _data_, NULL);
	if (_data_->_state_ != 0) {
		while (_data_->_task_complete_ != TRUE) {
			g_main_context_iteration (g_task_get_context (_data_->_async_result), TRUE);
		}
	}
	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_;
	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)
{
	g_return_if_fail (self != NULL);
	if (g_strcmp0 (value, rygel_media_object_get_id (self)) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_id);
		self->priv->_id = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, rygel_media_object_properties[RYGEL_MEDIA_OBJECT_ID_PROPERTY]);
	}
}


RygelMediaContainer*
rygel_media_object_get_parent (RygelMediaObject* self)
{
	RygelMediaContainer* result;
	RygelMediaContainer* _tmp0_;
	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)
{
	g_return_if_fail (self != NULL);
	if (rygel_media_object_get_parent (self) != value) {
		self->priv->_parent = value;
		g_object_notify_by_pspec ((GObject *) self, rygel_media_object_properties[RYGEL_MEDIA_OBJECT_PARENT_PROPERTY]);
	}
}


const gchar*
rygel_media_object_get_title (RygelMediaObject* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	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)
{
	g_return_if_fail (self != NULL);
	if (g_strcmp0 (value, rygel_media_object_get_title (self)) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_title);
		self->priv->_title = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, rygel_media_object_properties[RYGEL_MEDIA_OBJECT_TITLE_PROPERTY]);
	}
}


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));
	((RygelMediaObjectClass *) klass)->get_children = (void (*) (RygelMediaObject *, guint, guint, const gchar*, GCancellable*, GAsyncReadyCallback, gpointer)) rygel_media_object_real_get_children;
	((RygelMediaObjectClass *) klass)->get_children_finish = (RygelMediaObjects* (*) (RygelMediaObject *, GAsyncResult*, GError**)) rygel_media_object_real_get_children_finish;
	((RygelMediaObjectClass *) klass)->find_object = (void (*) (RygelMediaObject *, const gchar*, GCancellable*, GAsyncReadyCallback, gpointer)) rygel_media_object_real_find_object;
	((RygelMediaObjectClass *) klass)->find_object_finish = (RygelMediaObject* (*) (RygelMediaObject *, GAsyncResult*, GError**)) 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_PROPERTY, rygel_media_object_properties[RYGEL_MEDIA_OBJECT_ID_PROPERTY] = g_param_spec_string ("id", "id", "id", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), RYGEL_MEDIA_OBJECT_PARENT_PROPERTY, rygel_media_object_properties[RYGEL_MEDIA_OBJECT_PARENT_PROPERTY] = g_param_spec_object ("parent", "parent", "parent", RYGEL_TYPE_MEDIA_CONTAINER, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), RYGEL_MEDIA_OBJECT_TITLE_PROPERTY, rygel_media_object_properties[RYGEL_MEDIA_OBJECT_TITLE_PROPERTY] = g_param_spec_string ("title", "title", "title", NULL, G_PARAM_STATIC_STRINGS | 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_PROPERTY:
		g_value_set_string (value, rygel_media_object_get_id (self));
		break;
		case RYGEL_MEDIA_OBJECT_PARENT_PROPERTY:
		g_value_set_object (value, rygel_media_object_get_parent (self));
		break;
		case RYGEL_MEDIA_OBJECT_TITLE_PROPERTY:
		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_PROPERTY:
		rygel_media_object_set_id (self, g_value_get_string (value));
		break;
		case RYGEL_MEDIA_OBJECT_PARENT_PROPERTY:
		rygel_media_object_set_parent (self, g_value_get_object (value));
		break;
		case RYGEL_MEDIA_OBJECT_TITLE_PROPERTY:
		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_default_init (RygelTrackableContainerIface * iface)
{
}


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) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) rygel_trackable_container_default_init, (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_default_init (RygelTrackableItemIface * iface)
{
}


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) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) rygel_trackable_item_default_init, (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)
{
	RygelMediaItem * self = NULL;
	self = (RygelMediaItem*) rygel_media_object_construct (object_type);
	return self;
}


RygelMediaItem*
rygel_media_item_new (void)
{
	return rygel_media_item_construct (RYGEL_TYPE_MEDIA_ITEM);
}


static void
rygel_media_item_class_init (RygelMediaItemClass * klass)
{
	rygel_media_item_parent_class = g_type_class_peek_parent (klass);
}


static void
rygel_media_item_instance_init (RygelMediaItem * self)
{
}


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;
}


RygelMediaFileItem*
rygel_media_file_item_construct (GType object_type,
                                 const gchar* id,
                                 RygelMediaContainer* parent,
                                 const gchar* title)
{
	RygelMediaFileItem * self = 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 = (RygelMediaFileItem*) rygel_media_item_construct (object_type);
	rygel_media_object_set_id ((RygelMediaObject*) self, id);
	rygel_media_object_set_parent ((RygelMediaObject*) self, parent);
	rygel_media_object_set_title ((RygelMediaObject*) self, title);
	return self;
}


RygelMediaFileItem*
rygel_media_file_item_new (const gchar* id,
                           RygelMediaContainer* parent,
                           const gchar* title)
{
	return rygel_media_file_item_construct (RYGEL_TYPE_MEDIA_FILE_ITEM, id, parent, title);
}


static void
rygel_media_file_item_class_init (RygelMediaFileItemClass * klass)
{
	rygel_media_file_item_parent_class = g_type_class_peek_parent (klass);
	G_OBJECT_CLASS (klass)->finalize = rygel_media_file_item_finalize;
}


static void
rygel_media_file_item_instance_init (RygelMediaFileItem * self)
{
}


static void
rygel_media_file_item_finalize (GObject * obj)
{
	RygelMediaFileItem * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, RYGEL_TYPE_MEDIA_FILE_ITEM, RygelMediaFileItem);
	_g_free0 (self->dlna_profile);
	_g_free0 (self->mime_type);
	_g_free0 (self->date);
	G_OBJECT_CLASS (rygel_media_file_item_parent_class)->finalize (obj);
}


GType
rygel_media_file_item_get_type (void)
{
	static volatile gsize rygel_media_file_item_type_id__volatile = 0;
	if (g_once_init_enter (&rygel_media_file_item_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (RygelMediaFileItemClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) rygel_media_file_item_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (RygelMediaFileItem), 0, (GInstanceInitFunc) rygel_media_file_item_instance_init, NULL };
		GType rygel_media_file_item_type_id;
		rygel_media_file_item_type_id = g_type_register_static (RYGEL_TYPE_MEDIA_ITEM, "RygelMediaFileItem", &g_define_type_info, 0);
		g_once_init_leave (&rygel_media_file_item_type_id__volatile, rygel_media_file_item_type_id);
	}
	return rygel_media_file_item_type_id__volatile;
}


RygelMusicItem*
rygel_music_item_construct (GType object_type,
                            const gchar* id,
                            RygelMediaContainer* parent,
                            const gchar* title)
{
	RygelMusicItem * self = 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 = (RygelMusicItem*) rygel_audio_item_construct (object_type, id, parent, title);
	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;
	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 = (RygelAudioItem*) rygel_media_file_item_construct (object_type, id, parent, title);
	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_FILE_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;
	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 = (RygelImageItem*) rygel_media_file_item_construct (object_type, id, parent, title);
	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_FILE_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;
	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 = (RygelVideoItem*) rygel_media_file_item_construct (object_type, id, parent, title);
	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_FILE_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;
	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 = (RygelPhotoItem*) rygel_media_file_item_construct (object_type, id, parent, title);
	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_FILE_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;
	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 = (RygelPlaylistItem*) rygel_media_file_item_construct (object_type, id, parent, title);
	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_FILE_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_;
	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_;
	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_async_ready_wrapper (GObject *source_object,
                                                            GAsyncResult *res,
                                                            void *user_data)
{
	RygelMediaContainerFindObjectData* _task_data_;
	_task_data_ = g_task_get_task_data (G_TASK (res));
	if (_task_data_->_callback_ != NULL) {
		_task_data_->_callback_ (source_object, res, user_data);
	}
	_task_data_->_task_complete_ = TRUE;
}


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_;
	gchar* _tmp1_;
	GCancellable* _tmp2_;
	self = (RygelMediaContainer*) base;
	_data_ = g_slice_new0 (RygelMediaContainerFindObjectData);
	_data_->_callback_ = _callback_;
	_data_->_async_result = g_task_new (G_OBJECT (self), cancellable, rygel_media_container_real_find_object_async_ready_wrapper, _user_data_);
	if (_callback_ == NULL) {
		_data_->_task_complete_ = TRUE;
	}
	g_task_set_task_data (_data_->_async_result, _data_, rygel_media_container_real_find_object_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = g_strdup (id);
	_g_free0 (_data_->id);
	_data_->id = _tmp1_;
	_tmp2_ = _g_object_ref0 (cancellable);
	_g_object_unref0 (_data_->cancellable);
	_data_->cancellable = _tmp2_;
	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_;
	_data_ = g_task_propagate_pointer (G_TASK (_res_), error);
	if (NULL == _data_) {
		return NULL;
	}
	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_ = _data_->self->found_object;
	_data_->_tmp1_ = _g_object_ref0 (_data_->_tmp0_);
	_data_->result = _data_->_tmp1_;
	block1_data_unref (_data_->_data1_);
	_data_->_data1_ = NULL;
	g_task_return_pointer (_data_->_async_result, _data_, NULL);
	if (_data_->_state_ != 0) {
		while (_data_->_task_complete_ != TRUE) {
			g_main_context_iteration (g_task_get_context (_data_->_async_result), TRUE);
		}
	}
	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_;
	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)
{
	g_return_if_fail (self != NULL);
	if (rygel_media_container_get_child_count (self) != value) {
		self->priv->_child_count = value;
		g_object_notify_by_pspec ((GObject *) self, rygel_media_container_properties[RYGEL_MEDIA_CONTAINER_CHILD_COUNT_PROPERTY]);
	}
}


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));
	((RygelMediaObjectClass *) klass)->find_object = (void (*) (RygelMediaObject *, const gchar*, GCancellable*, GAsyncReadyCallback, gpointer)) rygel_media_container_real_find_object;
	((RygelMediaObjectClass *) klass)->find_object_finish = (RygelMediaObject* (*) (RygelMediaObject *, GAsyncResult*, GError**)) 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_PROPERTY, rygel_media_container_properties[RYGEL_MEDIA_CONTAINER_CHILD_COUNT_PROPERTY] = g_param_spec_int ("child-count", "child-count", "child-count", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	rygel_media_container_signals[RYGEL_MEDIA_CONTAINER_CONTAINER_UPDATED_SIGNAL] = 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_;
	gchar* _tmp1_;
	self->priv = RYGEL_MEDIA_CONTAINER_GET_PRIVATE (self);
	_tmp0_ = gee_array_list_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, (GDestroyNotify) 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_PROPERTY:
		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_PROPERTY:
		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, (GDestroyNotify) 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_;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (upnp_class != NULL, FALSE);
	_tmp0_ = ((RygelMediaContainer*) self)->create_classes;
	result = gee_abstract_collection_contains ((GeeAbstractCollection*) _tmp0_, upnp_class);
	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_);
}


static void
rygel_writable_container_get_writable_async_ready_wrapper (GObject *source_object,
                                                           GAsyncResult *res,
                                                           void *user_data)
{
	RygelWritableContainerGetWritableData* _task_data_;
	_task_data_ = g_task_get_task_data (G_TASK (res));
	if (_task_data_->_callback_ != NULL) {
		_task_data_->_callback_ (source_object, res, user_data);
	}
	_task_data_->_task_complete_ = TRUE;
}


void
rygel_writable_container_get_writable (RygelWritableContainer* self,
                                       GCancellable* cancellable,
                                       GAsyncReadyCallback _callback_,
                                       gpointer _user_data_)
{
	RygelWritableContainerGetWritableData* _data_;
	RygelWritableContainer* _tmp0_;
	GCancellable* _tmp1_;
	_data_ = g_slice_new0 (RygelWritableContainerGetWritableData);
	_data_->_callback_ = _callback_;
	_data_->_async_result = g_task_new (G_OBJECT (self), cancellable, rygel_writable_container_get_writable_async_ready_wrapper, _user_data_);
	if (_callback_ == NULL) {
		_data_->_task_complete_ = TRUE;
	}
	g_task_set_task_data (_data_->_async_result, _data_, rygel_writable_container_get_writable_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = _g_object_ref0 (cancellable);
	_g_object_unref0 (_data_->cancellable);
	_data_->cancellable = _tmp1_;
	rygel_writable_container_get_writable_co (_data_);
}


GFile*
rygel_writable_container_get_writable_finish (RygelWritableContainer* self,
                                              GAsyncResult* _res_)
{
	GFile* result;
	RygelWritableContainerGetWritableData* _data_;
	_data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
	if (NULL == _data_) {
		return NULL;
	}
	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_ = g_file_new_for_commandline_arg ("/tmp");
	_data_->result = _data_->_tmp0_;
	g_task_return_pointer (_data_->_async_result, _data_, NULL);
	if (_data_->_state_ != 0) {
		while (_data_->_task_complete_ != TRUE) {
			g_main_context_iteration (g_task_get_context (_data_->_async_result), TRUE);
		}
	}
	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_);
}


static void
rygel_writable_container_add_item_async_ready_wrapper (GObject *source_object,
                                                       GAsyncResult *res,
                                                       void *user_data)
{
	RygelWritableContainerAddItemData* _task_data_;
	_task_data_ = g_task_get_task_data (G_TASK (res));
	if (_task_data_->_callback_ != NULL) {
		_task_data_->_callback_ (source_object, res, user_data);
	}
	_task_data_->_task_complete_ = TRUE;
}


void
rygel_writable_container_add_item (RygelWritableContainer* self,
                                   RygelMediaItem* item,
                                   GCancellable* cancellable,
                                   GAsyncReadyCallback _callback_,
                                   gpointer _user_data_)
{
	RygelWritableContainerAddItemData* _data_;
	RygelWritableContainer* _tmp0_;
	RygelMediaItem* _tmp1_;
	GCancellable* _tmp2_;
	_data_ = g_slice_new0 (RygelWritableContainerAddItemData);
	_data_->_callback_ = _callback_;
	_data_->_async_result = g_task_new (G_OBJECT (self), cancellable, rygel_writable_container_add_item_async_ready_wrapper, _user_data_);
	if (_callback_ == NULL) {
		_data_->_task_complete_ = TRUE;
	}
	g_task_set_task_data (_data_->_async_result, _data_, rygel_writable_container_add_item_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = _g_object_ref0 (item);
	_g_object_unref0 (_data_->item);
	_data_->item = _tmp1_;
	_tmp2_ = _g_object_ref0 (cancellable);
	_g_object_unref0 (_data_->cancellable);
	_data_->cancellable = _tmp2_;
	rygel_writable_container_add_item_co (_data_);
}


void
rygel_writable_container_add_item_finish (RygelWritableContainer* self,
                                          GAsyncResult* _res_)
{
	RygelWritableContainerAddItemData* _data_;
	_data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
	if (NULL == _data_) {
		return;
	}
}


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:
	g_task_return_pointer (_data_->_async_result, _data_, NULL);
	if (_data_->_state_ != 0) {
		while (_data_->_task_complete_ != TRUE) {
			g_main_context_iteration (g_task_get_context (_data_->_async_result), TRUE);
		}
	}
	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_);
}


static void
rygel_writable_container_add_container_async_ready_wrapper (GObject *source_object,
                                                            GAsyncResult *res,
                                                            void *user_data)
{
	RygelWritableContainerAddContainerData* _task_data_;
	_task_data_ = g_task_get_task_data (G_TASK (res));
	if (_task_data_->_callback_ != NULL) {
		_task_data_->_callback_ (source_object, res, user_data);
	}
	_task_data_->_task_complete_ = TRUE;
}


void
rygel_writable_container_add_container (RygelWritableContainer* self,
                                        RygelMediaContainer* container,
                                        GCancellable* cancellable,
                                        GAsyncReadyCallback _callback_,
                                        gpointer _user_data_)
{
	RygelWritableContainerAddContainerData* _data_;
	RygelWritableContainer* _tmp0_;
	RygelMediaContainer* _tmp1_;
	GCancellable* _tmp2_;
	_data_ = g_slice_new0 (RygelWritableContainerAddContainerData);
	_data_->_callback_ = _callback_;
	_data_->_async_result = g_task_new (G_OBJECT (self), cancellable, rygel_writable_container_add_container_async_ready_wrapper, _user_data_);
	if (_callback_ == NULL) {
		_data_->_task_complete_ = TRUE;
	}
	g_task_set_task_data (_data_->_async_result, _data_, rygel_writable_container_add_container_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = _g_object_ref0 (container);
	_g_object_unref0 (_data_->container);
	_data_->container = _tmp1_;
	_tmp2_ = _g_object_ref0 (cancellable);
	_g_object_unref0 (_data_->cancellable);
	_data_->cancellable = _tmp2_;
	rygel_writable_container_add_container_co (_data_);
}


void
rygel_writable_container_add_container_finish (RygelWritableContainer* self,
                                               GAsyncResult* _res_)
{
	RygelWritableContainerAddContainerData* _data_;
	_data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
	if (NULL == _data_) {
		return;
	}
}


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:
	g_task_return_pointer (_data_->_async_result, _data_, NULL);
	if (_data_->_state_ != 0) {
		while (_data_->_task_complete_ != TRUE) {
			g_main_context_iteration (g_task_get_context (_data_->_async_result), TRUE);
		}
	}
	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 void
rygel_searchable_container_search_async_ready_wrapper (GObject *source_object,
                                                       GAsyncResult *res,
                                                       void *user_data)
{
	RygelSearchableContainerSearchData* _task_data_;
	_task_data_ = g_task_get_task_data (G_TASK (res));
	if (_task_data_->_callback_ != NULL) {
		_task_data_->_callback_ (source_object, res, user_data);
	}
	_task_data_->_task_complete_ = TRUE;
}


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_;
	RygelSearchExpression* _tmp1_;
	gchar* _tmp2_;
	GCancellable* _tmp3_;
	_data_ = g_slice_new0 (RygelSearchableContainerSearchData);
	_data_->_callback_ = _callback_;
	_data_->_async_result = g_task_new (G_OBJECT (self), cancellable, rygel_searchable_container_search_async_ready_wrapper, _user_data_);
	if (_callback_ == NULL) {
		_data_->_task_complete_ = TRUE;
	}
	g_task_set_task_data (_data_->_async_result, _data_, rygel_searchable_container_search_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_tmp1_ = _rygel_search_expression_ref0 (expression);
	_rygel_search_expression_unref0 (_data_->expression);
	_data_->expression = _tmp1_;
	_data_->offset = offset;
	_data_->count = count;
	_tmp2_ = g_strdup (soer_criteria);
	_g_free0 (_data_->soer_criteria);
	_data_->soer_criteria = _tmp2_;
	_tmp3_ = _g_object_ref0 (cancellable);
	_g_object_unref0 (_data_->cancellable);
	_data_->cancellable = _tmp3_;
	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_task_propagate_pointer (G_TASK (_res_), NULL);
	if (NULL == _data_) {
		return NULL;
	}
	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_ = _data_->self->result;
	_data_->_tmp1_ = _g_object_ref0 (_data_->_tmp0_);
	_data_->result = _data_->_tmp1_;
	block2_data_unref (_data_->_data2_);
	_data_->_data2_ = NULL;
	g_task_return_pointer (_data_->_async_result, _data_, NULL);
	if (_data_->_state_ != 0) {
		while (_data_->_task_complete_ != TRUE) {
			g_main_context_iteration (g_task_get_context (_data_->_async_result), TRUE);
		}
	}
	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_;
	_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);
	((RygelTranscoderClass *) 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);
	g_signal_handlers_destroy (self);
}


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)
{
	gboolean _tmp1_ = FALSE;
	gboolean _tmp2_ = FALSE;
	g_return_if_fail (message != NULL);
	if (g_str_has_prefix (message, "Read-only property 'read-only-view' on class")) {
		GLogFunc _tmp0_;
		void* _tmp0__target;
		_tmp0_ = g_log_default_handler;
		_tmp0__target = NULL;
		_tmp0_ (domain, flags, message, _tmp0__target);
		return;
	}
	if ((flags & G_LOG_LEVEL_CRITICAL) == G_LOG_LEVEL_CRITICAL) {
		_tmp2_ = TRUE;
	} else {
		_tmp2_ = (flags & G_LOG_LEVEL_ERROR) == G_LOG_LEVEL_ERROR;
	}
	if (_tmp2_) {
		_tmp1_ = TRUE;
	} else {
		_tmp1_ = (flags & G_LOG_FLAG_FATAL) == G_LOG_FLAG_FATAL;
	}
	if (_tmp1_) {
		const gchar* _tmp3_ = NULL;
		_tmp3_ = domain;
		if (_tmp3_ == NULL) {
			_tmp3_ = "";
		}
		g_print ("======> FAILED: %s: %s\n", _tmp3_, message);
		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_;
	RygelSerializer* serializer = NULL;
	RygelSerializer* _tmp1_;
	GUPnPDIDLLiteItem* _tmp2_;
	GUPnPDIDLLiteItem* _tmp3_;
	GUPnPDIDLLiteContainer* _tmp4_;
	GUPnPDIDLLiteContainer* _tmp5_;
	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 (RYGEL_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)
{
	return rygel_http_object_creator_test_main (argv, argc);
}


RygelHTTPObjectCreatorTest*
rygel_http_object_creator_test_construct (GType object_type)
{
	RygelHTTPObjectCreatorTest * self = NULL;
	GError* _tmp0_;
	GError* _tmp1_;
	GError* _tmp2_;
	GError* _tmp3_;
	GError* _tmp4_;
	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_;
	RygelServiceAction* action = NULL;
	RygelServiceAction* _tmp1_;
	RygelObjectCreator* creator = NULL;
	RygelServiceAction* _tmp2_;
	RygelServiceAction* _tmp3_;
	RygelObjectCreator* _tmp4_;
	RygelObjectCreator* _tmp5_;
	RygelServiceAction* _tmp6_;
	gint _tmp7_;
	GError* _tmp8_;
	gint _tmp9_;
	RygelServiceAction* _tmp10_;
	RygelServiceAction* _tmp11_;
	RygelServiceAction* _tmp12_;
	RygelObjectCreator* _tmp13_;
	RygelObjectCreator* _tmp14_;
	RygelServiceAction* _tmp15_;
	gint _tmp16_;
	GError* _tmp17_;
	gint _tmp18_;
	RygelServiceAction* _tmp19_;
	RygelServiceAction* _tmp20_;
	RygelServiceAction* _tmp21_;
	RygelObjectCreator* _tmp22_;
	RygelObjectCreator* _tmp23_;
	RygelServiceAction* _tmp24_;
	gint _tmp25_;
	GError* _tmp26_;
	gint _tmp27_;
	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;
	gchar* _tmp0_ = NULL;
	RygelServiceAction* action = NULL;
	RygelServiceAction* _tmp1_;
	RygelContentDirectory* content_directory = NULL;
	RygelContentDirectory* _tmp2_;
	RygelObjectCreator* creator = NULL;
	RygelServiceAction* _tmp3_;
	RygelObjectCreator* _tmp4_;
	gint _tmp5_;
	g_return_if_fail (self != NULL);
	xmlDocDumpMemoryEnc (doc, (xmlChar**) (&_tmp0_), NULL, "UTF-8");
	_g_free0 (xml);
	xml = _tmp0_;
	_tmp1_ = rygel_service_action_new ("0", xml);
	action = _tmp1_;
	_tmp2_ = rygel_content_directory_new ();
	content_directory = _tmp2_;
	_tmp3_ = _g_object_ref0 (action);
	_tmp4_ = rygel_object_creator_new (content_directory, _tmp3_);
	creator = _tmp4_;
	rygel_state_machine_run ((RygelStateMachine*) creator, NULL, NULL);
	_tmp5_ = action->error_code;
	_vala_assert (_tmp5_ == expected_code, "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_;
	gint _tmp1_;
	xmlDoc* _tmp2_;
	xmlNode* didl_node = NULL;
	xmlNode* _tmp3_;
	xmlNode* item_node = NULL;
	xmlNode* _tmp4_;
	RygelContentDirectory* content_directory = NULL;
	RygelContentDirectory* _tmp5_;
	RygelServiceAction* action = NULL;
	RygelServiceAction* _tmp6_;
	RygelObjectCreator* creator = NULL;
	RygelServiceAction* _tmp7_;
	RygelObjectCreator* _tmp8_;
	gint _tmp9_;
	GError* _tmp10_;
	gint _tmp11_;
	const gchar* _tmp12_;
	GError* _tmp13_;
	gint _tmp14_;
	xmlNode* tmp = NULL;
	xmlNode* _tmp15_;
	xmlNode* _tmp16_;
	xmlNode* _tmp17_;
	GError* _tmp18_;
	gint _tmp19_;
	xmlNode* _tmp20_;
	GError* _tmp21_;
	gint _tmp22_;
	xmlNode* _tmp23_;
	xmlNode* _tmp24_;
	xmlNode* _tmp25_;
	xmlNode* _tmp26_;
	GError* _tmp27_;
	gint _tmp28_;
	xmlNode* _tmp29_;
	GError* _tmp30_;
	gint _tmp31_;
	xmlNode* _tmp32_;
	xmlNode* _tmp33_;
	xmlNode* title_node = NULL;
	xmlNode* _tmp34_;
	xmlNode* _tmp35_;
	xmlNode* _tmp36_;
	GError* _tmp37_;
	gint _tmp38_;
	xmlNode* _tmp39_;
	xmlNode* _tmp40_;
	xmlNode* class_node = NULL;
	xmlNode* _tmp41_;
	xmlNode* _tmp42_;
	xmlNode* _tmp43_;
	GError* _tmp44_;
	gint _tmp45_;
	GError* _tmp46_;
	gint _tmp47_;
	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_;
	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_;
	rygel_state_machine_run ((RygelStateMachine*) creator, ___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_;
	RygelSearchableContainer* root_container = NULL;
	RygelSearchableContainer* _tmp1_;
	RygelMediaContainer* _tmp2_;
	RygelServiceAction* action = NULL;
	RygelServiceAction* _tmp3_;
	RygelObjectCreator* creator = NULL;
	RygelServiceAction* _tmp4_;
	RygelObjectCreator* _tmp5_;
	gint _tmp6_;
	GError* _tmp7_;
	gint _tmp8_;
	RygelMediaObject* _tmp9_;
	gint _tmp10_;
	GError* _tmp11_;
	gint _tmp12_;
	RygelMediaContainer* _tmp13_;
	gint _tmp14_;
	GError* _tmp15_;
	gint _tmp16_;
	RygelMediaObject* _tmp17_;
	RygelMediaObject* _tmp18_;
	GUPnPOCMFlags _tmp19_;
	gint _tmp20_;
	GError* _tmp21_;
	gint _tmp22_;
	RygelWritableContainer* container = NULL;
	RygelWritableContainer* _tmp23_;
	GeeArrayList* _tmp24_;
	GUPnPOCMFlags _tmp25_;
	RygelMediaObject* _tmp26_;
	gint _tmp27_;
	GError* _tmp28_;
	gint _tmp29_;
	RygelMediaContainer* _tmp30_;
	gchar* _tmp31_;
	gint _tmp32_;
	GError* _tmp33_;
	gint _tmp34_;
	RygelSearchableContainer* _tmp35_;
	gint _tmp36_;
	GError* _tmp37_;
	gint _tmp38_;
	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;
}



