~ricmm/+junk/unity-lens_music-sc

/* musicstore-filter-parser-genre.c generated by valac 0.16.1, the Vala compiler

 * generated from musicstore-filter-parser-genre.vala, do not modify */

 

/*

 * Copyright (C) 2011 Canonical Ltd

 *

 * This program is free software: you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 3 as

 * published by the Free Software Foundation.

 *

 * This program 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program.  If not, see <http://www.gnu.org/licenses/>.

 *

 * Authored by Alex Launi <alex.launi@canonical.com>

 *

 */

 

#include <glib.h>

#include <glib-object.h>

#include <stdlib.h>

#include <string.h>

#include <unity.h>

#include <gee.h>

 

 

#define UNITY_MUSIC_LENS_TYPE_FILTER_PARSER (unity_music_lens_filter_parser_get_type ())

#define UNITY_MUSIC_LENS_FILTER_PARSER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), UNITY_MUSIC_LENS_TYPE_FILTER_PARSER, UnityMusicLensFilterParser))

#define UNITY_MUSIC_LENS_FILTER_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), UNITY_MUSIC_LENS_TYPE_FILTER_PARSER, UnityMusicLensFilterParserClass))

#define UNITY_MUSIC_LENS_IS_FILTER_PARSER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), UNITY_MUSIC_LENS_TYPE_FILTER_PARSER))

#define UNITY_MUSIC_LENS_IS_FILTER_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), UNITY_MUSIC_LENS_TYPE_FILTER_PARSER))

#define UNITY_MUSIC_LENS_FILTER_PARSER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), UNITY_MUSIC_LENS_TYPE_FILTER_PARSER, UnityMusicLensFilterParserClass))

 

typedef struct _UnityMusicLensFilterParser UnityMusicLensFilterParser;

typedef struct _UnityMusicLensFilterParserClass UnityMusicLensFilterParserClass;

typedef struct _UnityMusicLensFilterParserPrivate UnityMusicLensFilterParserPrivate;

 

#define UNITY_MUSIC_LENS_TYPE_GENRE_FILTER_PARSER (unity_music_lens_genre_filter_parser_get_type ())

#define UNITY_MUSIC_LENS_GENRE_FILTER_PARSER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), UNITY_MUSIC_LENS_TYPE_GENRE_FILTER_PARSER, UnityMusicLensGenreFilterParser))

#define UNITY_MUSIC_LENS_GENRE_FILTER_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), UNITY_MUSIC_LENS_TYPE_GENRE_FILTER_PARSER, UnityMusicLensGenreFilterParserClass))

#define UNITY_MUSIC_LENS_IS_GENRE_FILTER_PARSER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), UNITY_MUSIC_LENS_TYPE_GENRE_FILTER_PARSER))

#define UNITY_MUSIC_LENS_IS_GENRE_FILTER_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), UNITY_MUSIC_LENS_TYPE_GENRE_FILTER_PARSER))

#define UNITY_MUSIC_LENS_GENRE_FILTER_PARSER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), UNITY_MUSIC_LENS_TYPE_GENRE_FILTER_PARSER, UnityMusicLensGenreFilterParserClass))

 

typedef struct _UnityMusicLensGenreFilterParser UnityMusicLensGenreFilterParser;

typedef struct _UnityMusicLensGenreFilterParserClass UnityMusicLensGenreFilterParserClass;

typedef struct _UnityMusicLensGenreFilterParserPrivate UnityMusicLensGenreFilterParserPrivate;

 

#define UNITY_MUSIC_LENS_TYPE_MUSIC_STORE_FILTER_PARSER (unity_music_lens_music_store_filter_parser_get_type ())

#define UNITY_MUSIC_LENS_MUSIC_STORE_FILTER_PARSER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), UNITY_MUSIC_LENS_TYPE_MUSIC_STORE_FILTER_PARSER, UnityMusicLensMusicStoreFilterParser))

#define UNITY_MUSIC_LENS_IS_MUSIC_STORE_FILTER_PARSER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), UNITY_MUSIC_LENS_TYPE_MUSIC_STORE_FILTER_PARSER))

#define UNITY_MUSIC_LENS_MUSIC_STORE_FILTER_PARSER_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), UNITY_MUSIC_LENS_TYPE_MUSIC_STORE_FILTER_PARSER, UnityMusicLensMusicStoreFilterParserIface))

 

typedef struct _UnityMusicLensMusicStoreFilterParser UnityMusicLensMusicStoreFilterParser;

typedef struct _UnityMusicLensMusicStoreFilterParserIface UnityMusicLensMusicStoreFilterParserIface;

 

#define UNITY_MUSIC_LENS_TYPE_MUSIC_STORE_GENRE_FILTER_PARSER (unity_music_lens_music_store_genre_filter_parser_get_type ())

#define UNITY_MUSIC_LENS_MUSIC_STORE_GENRE_FILTER_PARSER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), UNITY_MUSIC_LENS_TYPE_MUSIC_STORE_GENRE_FILTER_PARSER, UnityMusicLensMusicStoreGenreFilterParser))

#define UNITY_MUSIC_LENS_MUSIC_STORE_GENRE_FILTER_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), UNITY_MUSIC_LENS_TYPE_MUSIC_STORE_GENRE_FILTER_PARSER, UnityMusicLensMusicStoreGenreFilterParserClass))

#define UNITY_MUSIC_LENS_IS_MUSIC_STORE_GENRE_FILTER_PARSER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), UNITY_MUSIC_LENS_TYPE_MUSIC_STORE_GENRE_FILTER_PARSER))

#define UNITY_MUSIC_LENS_IS_MUSIC_STORE_GENRE_FILTER_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), UNITY_MUSIC_LENS_TYPE_MUSIC_STORE_GENRE_FILTER_PARSER))

#define UNITY_MUSIC_LENS_MUSIC_STORE_GENRE_FILTER_PARSER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), UNITY_MUSIC_LENS_TYPE_MUSIC_STORE_GENRE_FILTER_PARSER, UnityMusicLensMusicStoreGenreFilterParserClass))

 

typedef struct _UnityMusicLensMusicStoreGenreFilterParser UnityMusicLensMusicStoreGenreFilterParser;

typedef struct _UnityMusicLensMusicStoreGenreFilterParserClass UnityMusicLensMusicStoreGenreFilterParserClass;

typedef struct _UnityMusicLensMusicStoreGenreFilterParserPrivate UnityMusicLensMusicStoreGenreFilterParserPrivate;

#define _g_free0(var) (var = (g_free (var), NULL))

#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))

 

#define UNITY_MUSIC_LENS_TYPE_GENRE (unity_music_lens_genre_get_type ())

#define UNITY_MUSIC_LENS_GENRE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), UNITY_MUSIC_LENS_TYPE_GENRE, UnityMusicLensGenre))

#define UNITY_MUSIC_LENS_GENRE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), UNITY_MUSIC_LENS_TYPE_GENRE, UnityMusicLensGenreClass))

#define UNITY_MUSIC_LENS_IS_GENRE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), UNITY_MUSIC_LENS_TYPE_GENRE))

#define UNITY_MUSIC_LENS_IS_GENRE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), UNITY_MUSIC_LENS_TYPE_GENRE))

#define UNITY_MUSIC_LENS_GENRE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), UNITY_MUSIC_LENS_TYPE_GENRE, UnityMusicLensGenreClass))

 

typedef struct _UnityMusicLensGenre UnityMusicLensGenre;

typedef struct _UnityMusicLensGenreClass UnityMusicLensGenreClass;

#define __g_list_free__g_object_unref0_0(var) ((var == NULL) ? NULL : (var = (_g_list_free__g_object_unref0_ (var), NULL)))

#define _g_string_free0(var) ((var == NULL) ? NULL : (var = (g_string_free (var, TRUE), NULL)))

 

struct _UnityMusicLensFilterParser {

        GObject parent_instance;

        UnityMusicLensFilterParserPrivate * priv;

};

 

struct _UnityMusicLensFilterParserClass {

        GObjectClass parent_class;

        gchar* (*parse) (UnityMusicLensFilterParser* self);

        const gchar* (*get_id) (UnityMusicLensFilterParser* self);

};

 

struct _UnityMusicLensGenreFilterParser {

        UnityMusicLensFilterParser parent_instance;

        UnityMusicLensGenreFilterParserPrivate * priv;

};

 

struct _UnityMusicLensGenreFilterParserClass {

        UnityMusicLensFilterParserClass parent_class;

};

 

struct _UnityMusicLensMusicStoreFilterParserIface {

        GTypeInterface parent_iface;

};

 

struct _UnityMusicLensMusicStoreGenreFilterParser {

        UnityMusicLensGenreFilterParser parent_instance;

        UnityMusicLensMusicStoreGenreFilterParserPrivate * priv;

};

 

struct _UnityMusicLensMusicStoreGenreFilterParserClass {

        UnityMusicLensGenreFilterParserClass parent_class;

};

 

 

static gpointer unity_music_lens_music_store_genre_filter_parser_parent_class = NULL;

static UnityMusicLensMusicStoreFilterParserIface* unity_music_lens_music_store_genre_filter_parser_unity_music_lens_music_store_filter_parser_parent_iface = NULL;

 

GType unity_music_lens_filter_parser_get_type (void) G_GNUC_CONST;

GType unity_music_lens_genre_filter_parser_get_type (void) G_GNUC_CONST;

GType unity_music_lens_music_store_filter_parser_get_type (void) G_GNUC_CONST;

GType unity_music_lens_music_store_genre_filter_parser_get_type (void) G_GNUC_CONST;

enum  {

        UNITY_MUSIC_LENS_MUSIC_STORE_GENRE_FILTER_PARSER_DUMMY_PROPERTY

};

UnityMusicLensMusicStoreGenreFilterParser* unity_music_lens_music_store_genre_filter_parser_new (UnityMusicLensGenreFilterParser* parser);

UnityMusicLensMusicStoreGenreFilterParser* unity_music_lens_music_store_genre_filter_parser_construct (GType object_type, UnityMusicLensGenreFilterParser* parser);

UnityFilter* unity_music_lens_filter_parser_get_filter (UnityMusicLensFilterParser* self);

UnityMusicLensGenreFilterParser* unity_music_lens_genre_filter_parser_new (UnityCheckOptionFilterCompact* filter);

UnityMusicLensGenreFilterParser* unity_music_lens_genre_filter_parser_construct (GType object_type, UnityCheckOptionFilterCompact* filter);

static gchar* unity_music_lens_music_store_genre_filter_parser_real_parse (UnityMusicLensFilterParser* base);

GList* unity_music_lens_genre_filter_parser_get_all_selected_genres (UnityMusicLensGenreFilterParser* self);

GType unity_music_lens_genre_get_type (void) G_GNUC_CONST;

UnityMusicLensGenre* unity_music_lens_genre_filter_parser_get_map (UnityMusicLensGenreFilterParser* self);

GeeCollection* unity_music_lens_genre_get_genre_synonyms (UnityMusicLensGenre* self, const gchar* genre_id);

static void _g_object_unref0_ (gpointer var);

static void _g_list_free__g_object_unref0_ (GList* self);

 

 

UnityMusicLensMusicStoreGenreFilterParser* unity_music_lens_music_store_genre_filter_parser_construct (GType object_type, UnityMusicLensGenreFilterParser* parser) {

        UnityMusicLensMusicStoreGenreFilterParser * self = NULL;

        UnityMusicLensGenreFilterParser* _tmp0_;

        UnityFilter* _tmp1_;

        UnityFilter* _tmp2_;

        g_return_val_if_fail (parser != NULL, NULL);

        _tmp0_ = parser;

        _tmp1_ = unity_music_lens_filter_parser_get_filter ((UnityMusicLensFilterParser*) _tmp0_);

        _tmp2_ = _tmp1_;

        self = (UnityMusicLensMusicStoreGenreFilterParser*) unity_music_lens_genre_filter_parser_construct (object_type, UNITY_IS_CHECK_OPTION_FILTER_COMPACT (_tmp2_) ? ((UnityCheckOptionFilterCompact*) _tmp2_) : NULL);

        return self;

}

 

 

UnityMusicLensMusicStoreGenreFilterParser* unity_music_lens_music_store_genre_filter_parser_new (UnityMusicLensGenreFilterParser* parser) {

        return unity_music_lens_music_store_genre_filter_parser_construct (UNITY_MUSIC_LENS_TYPE_MUSIC_STORE_GENRE_FILTER_PARSER, parser);

}

 

 

static gpointer _g_object_ref0 (gpointer self) {

        return self ? g_object_ref (self) : NULL;

}

 

 

static void _g_object_unref0_ (gpointer var) {

        (var == NULL) ? NULL : (var = (g_object_unref (var), NULL));

}

 

 

static void _g_list_free__g_object_unref0_ (GList* self) {

        g_list_foreach (self, (GFunc) _g_object_unref0_, NULL);

        g_list_free (self);

}

 

 

static gchar* unity_music_lens_music_store_genre_filter_parser_real_parse (UnityMusicLensFilterParser* base) {

        UnityMusicLensMusicStoreGenreFilterParser * self;

        gchar* result = NULL;

        GString* _tmp0_;

        GString* builder;

        GList* _tmp1_ = NULL;

        GString* _tmp23_;

        GString* _tmp24_;

        gssize _tmp25_;

        GString* _tmp26_;

        const gchar* _tmp27_;

        gchar* _tmp28_;

        self = (UnityMusicLensMusicStoreGenreFilterParser*) base;

        _tmp0_ = g_string_new ("&genres=");

        builder = _tmp0_;

        _tmp1_ = unity_music_lens_genre_filter_parser_get_all_selected_genres ((UnityMusicLensGenreFilterParser*) self);

        {

                GList* genre_collection = NULL;

                GList* genre_it = NULL;

                genre_collection = _tmp1_;

                for (genre_it = genre_collection; genre_it != NULL; genre_it = genre_it->next) {

                        UnityFilterOption* _tmp2_;

                        UnityFilterOption* genre = NULL;

                        _tmp2_ = _g_object_ref0 ((UnityFilterOption*) genre_it->data);

                        genre = _tmp2_;

                        {

                                UnityFilterOption* _tmp3_;

                                const gchar* _tmp4_;

                                const gchar* _tmp5_;

                                gchar* _tmp6_;

                                gchar* id;

                                UnityFilterOption* _tmp7_;

                                const gchar* _tmp8_;

                                const gchar* _tmp9_;

                                _tmp3_ = genre;

                                _tmp4_ = unity_filter_option_get_id (_tmp3_);

                                _tmp5_ = _tmp4_;

                                _tmp6_ = g_strdup (_tmp5_);

                                id = _tmp6_;

                                _tmp7_ = genre;

                                _tmp8_ = unity_filter_option_get_id (_tmp7_);

                                _tmp9_ = _tmp8_;

                                if (_tmp9_ == NULL) {

                                        _g_free0 (id);

                                        _g_object_unref0 (genre);

                                        continue;

                                }

                                {

                                        UnityMusicLensGenre* _tmp10_;

                                        UnityMusicLensGenre* _tmp11_;

                                        const gchar* _tmp12_;

                                        GeeCollection* _tmp13_ = NULL;

                                        GeeCollection* _tmp14_;

                                        GeeIterator* _tmp15_ = NULL;

                                        GeeIterator* _tmp16_;

                                        GeeIterator* _alt_it;

                                        _tmp10_ = unity_music_lens_genre_filter_parser_get_map ((UnityMusicLensGenreFilterParser*) self);

                                        _tmp11_ = _tmp10_;

                                        _tmp12_ = id;

                                        _tmp13_ = unity_music_lens_genre_get_genre_synonyms (_tmp11_, _tmp12_);

                                        _tmp14_ = _tmp13_;

                                        _tmp15_ = gee_iterable_iterator ((GeeIterable*) _tmp14_);

                                        _tmp16_ = _tmp15_;

                                        _g_object_unref0 (_tmp14_);

                                        _alt_it = _tmp16_;

                                        while (TRUE) {

                                                GeeIterator* _tmp17_;

                                                gboolean _tmp18_ = FALSE;

                                                GeeIterator* _tmp19_;

                                                gpointer _tmp20_ = NULL;

                                                gchar* alt;

                                                GString* _tmp21_;

                                                const gchar* _tmp22_;

                                                _tmp17_ = _alt_it;

                                                _tmp18_ = gee_iterator_next (_tmp17_);

                                                if (!_tmp18_) {

                                                        break;

                                                }

                                                _tmp19_ = _alt_it;

                                                _tmp20_ = gee_iterator_get (_tmp19_);

                                                alt = (gchar*) _tmp20_;

                                                _tmp21_ = builder;

                                                _tmp22_ = alt;

                                                g_string_append_printf (_tmp21_, "%s,", _tmp22_);

                                                _g_free0 (alt);

                                        }

                                        _g_object_unref0 (_alt_it);

                                }

                                _g_free0 (id);

                                _g_object_unref0 (genre);

                        }

                }

                __g_list_free__g_object_unref0_0 (genre_collection);

        }

        _tmp23_ = builder;

        _tmp24_ = builder;

        _tmp25_ = _tmp24_->len;

        g_string_truncate (_tmp23_, (gsize) (_tmp25_ - 1));

        _tmp26_ = builder;

        _tmp27_ = _tmp26_->str;

        _tmp28_ = g_strdup (_tmp27_);

        result = _tmp28_;

        _g_string_free0 (builder);

        return result;

}

 

 

static void unity_music_lens_music_store_genre_filter_parser_class_init (UnityMusicLensMusicStoreGenreFilterParserClass * klass) {

        unity_music_lens_music_store_genre_filter_parser_parent_class = g_type_class_peek_parent (klass);

        UNITY_MUSIC_LENS_FILTER_PARSER_CLASS (klass)->parse = unity_music_lens_music_store_genre_filter_parser_real_parse;

}

 

 

static void unity_music_lens_music_store_genre_filter_parser_unity_music_lens_music_store_filter_parser_interface_init (UnityMusicLensMusicStoreFilterParserIface * iface) {

        unity_music_lens_music_store_genre_filter_parser_unity_music_lens_music_store_filter_parser_parent_iface = g_type_interface_peek_parent (iface);

}

 

 

static void unity_music_lens_music_store_genre_filter_parser_instance_init (UnityMusicLensMusicStoreGenreFilterParser * self) {

}

 

 

GType unity_music_lens_music_store_genre_filter_parser_get_type (void) {

        static volatile gsize unity_music_lens_music_store_genre_filter_parser_type_id__volatile = 0;

        if (g_once_init_enter (&unity_music_lens_music_store_genre_filter_parser_type_id__volatile)) {

                static const GTypeInfo g_define_type_info = { sizeof (UnityMusicLensMusicStoreGenreFilterParserClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) unity_music_lens_music_store_genre_filter_parser_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (UnityMusicLensMusicStoreGenreFilterParser), 0, (GInstanceInitFunc) unity_music_lens_music_store_genre_filter_parser_instance_init, NULL };

                static const GInterfaceInfo unity_music_lens_music_store_filter_parser_info = { (GInterfaceInitFunc) unity_music_lens_music_store_genre_filter_parser_unity_music_lens_music_store_filter_parser_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};

                GType unity_music_lens_music_store_genre_filter_parser_type_id;

                unity_music_lens_music_store_genre_filter_parser_type_id = g_type_register_static (UNITY_MUSIC_LENS_TYPE_GENRE_FILTER_PARSER, "UnityMusicLensMusicStoreGenreFilterParser", &g_define_type_info, 0);

                g_type_add_interface_static (unity_music_lens_music_store_genre_filter_parser_type_id, UNITY_MUSIC_LENS_TYPE_MUSIC_STORE_FILTER_PARSER, &unity_music_lens_music_store_filter_parser_info);

                g_once_init_leave (&unity_music_lens_music_store_genre_filter_parser_type_id__volatile, unity_music_lens_music_store_genre_filter_parser_type_id);

        }

        return unity_music_lens_music_store_genre_filter_parser_type_id__volatile;

}