git.maemo.org Git - jamendo/blob - src/data_structs.c

   1 /*
   2  * data_structs.c
   3  *
   4  *  Created on: 2009-10-05
   5  *      Author: marcin
   6  */
   7
   8 #include <glib.h>
   9 #include <glib-object.h>
  10
  11 #include "data_structs.h"
  12
  13 int G_TYPE_ALBUM = 0;
  14 int G_TYPE_RADIO = 0;
  15
  16 void data_structs_type_register() {
  17         if(!G_TYPE_ALBUM) {
  18                 G_TYPE_ALBUM = g_boxed_type_register_static("Album", (GBoxedCopyFunc)album_copy, (GBoxedFreeFunc)album_free);
  19         }
  20         if(!G_TYPE_RADIO) {
  21                 G_TYPE_RADIO = g_boxed_type_register_static("Radio", (GBoxedCopyFunc)radio_copy, (GBoxedFreeFunc)radio_free);
  22         }
  23 }
  24
  25 Album* album_new() {
  26         return g_new0(Album, 1);
  27 }
  28
  29 Album* album_copy(Album* album) {
  30         Album* newAlbum =  g_new0(Album, 1);
  31         album_set_id(newAlbum,album->id);
  32         album_set_image(newAlbum,album->image);
  33         album_set_name(newAlbum,album->name);
  34         album_set_rating(newAlbum,album->rating);
  35         album_set_artist_name(newAlbum,album->artist_name);
  36         return newAlbum;
  37 }
  38
  39 void album_set_id(Album* album, const gint id) {
  40         album->id = id;
  41 }
  42
  43 void album_set_image(Album* album, const gchar* image) {
  44         album->image = g_strdup(image);
  45 }
  46
  47 gchar* album_get_image(Album* album, gint size) {
  48         return g_strdup_printf("http://api.jamendo.com/get2/image/album/redirect/?id=%d&imagesize=%d",album->id,size);
  49 }
  50
  51 void album_set_name(Album* album, const gchar* name) {
  52         album->name = g_strdup(name);
  53 }
  54
  55 void album_set_rating(Album* album, const gdouble rating) {
  56         album->rating = rating;
  57 }
  58
  59 void album_set_artist_name(Album* album, const gchar* artist_name) {
  60         album->artist_name = g_strdup(artist_name);
  61 }
  62
  63
  64 void album_free(Album* album) {
  65         g_free(album->image);
  66         g_free(album->name);
  67         g_free(album->artist_name);
  68         g_free(album);
  69 }
  70
  71 void album_dump(Album* album) {
  72         g_debug("id: %d", album->id);
  73         g_debug("image: %s", album->image);
  74         g_debug("name: %s", album->name);
  75         g_debug("rating: %g", album->rating);
  76         g_debug("artist name: %s", album->artist_name);
  77 }
  78
  79 Album* album_new_from_xml(xmlNode* album_node) {
  80         Album* album = NULL;
  81         if (album_node->type == XML_ELEMENT_NODE && g_strcmp0((gchar*) album_node->name, "album") == 0) {
  82                 xmlNode* cur_node;
  83                 album = album_new();
  84                 for (cur_node = album_node->children; cur_node; cur_node = cur_node->next) {
  85                         if (!(cur_node->type == XML_ELEMENT_NODE && cur_node->children))
  86                                 continue;
  87                         if (g_strcmp0((gchar*) cur_node->name, "id") == 0) {
  88                                 album_set_id(album, g_ascii_strtoll((gchar*) cur_node->children->content, NULL, 10));
  89                         } else if (g_strcmp0((gchar*) cur_node->name, "name") == 0) {
  90                                 album_set_name(album, (gchar*) cur_node->children->content);
  91                                 /*album_set_name(album, (gchar*)xmlNodeGetContent(cur_node));*/
  92                         } else if (g_strcmp0((gchar*) cur_node->name, "image") == 0) {
  93                                 album_set_image(album, (gchar*) cur_node->children->content);
  94                         } else if (g_strcmp0((gchar*) cur_node->name, "rating") == 0) {
  95                                 album_set_rating(album, g_ascii_strtod((gchar*) cur_node->children->content, NULL));
  96                         } else if (g_strcmp0((gchar*) cur_node->name, "artist_name") == 0) {
  97                                 album_set_artist_name(album, (gchar*) cur_node->children->content);
  98                         }
  99                 }
 100         }
 101
 102         if(album) {
 103                 g_free(album->image);
 104                 album->image=g_strdup_printf("http://api.jamendo.com/get2/image/album/redirect/?id=%d&imagesize=100",album->id);
 105         }
 106         return album;
 107 }
 108
 109 static void album_list_free_item(Album* album, gpointer data) {
 110         album_free(album);
 111 }
 112
 113 void album_list_free(GList* album_list) {
 114         if (album_list) {
 115                 g_debug("album_list_free length: %d", g_list_length(album_list));
 116                 g_list_foreach(album_list, (GFunc) album_list_free_item, NULL);
 117                 g_list_free(album_list);
 118         }
 119 }
 120
 121 /***
 122  * TRACK
 123  */
 124
 125 Track* track_new() {
 126         return g_new0(Track, 1);
 127 }
 128
 129 Track* track_new_from_xml(xmlNode* track_node) {
 130         Track* track = NULL;
 131
 132         if (track_node->type == XML_ELEMENT_NODE && g_strcmp0((gchar*) track_node->name, "track") == 0) {
 133                 xmlNode* cur_node;
 134                 track = track_new();
 135                 for (cur_node = track_node->children; cur_node; cur_node = cur_node->next) {
 136                         if (!(cur_node->type == XML_ELEMENT_NODE && cur_node->children))
 137                                 continue;
 138                         if (g_strcmp0((gchar*) cur_node->name, "id") == 0) {
 139                                 track_set_id(track, g_ascii_strtoll((gchar*) cur_node->children->content, NULL, 10));
 140                         } else if (g_strcmp0((gchar*) cur_node->name, "name") == 0) {
 141                                 track_set_name(track, (gchar*) cur_node->children->content);
 142                                 /*track_set_name(track, (gchar*)xmlNodeGetContent(cur_node));*/
 143                         } else if (g_strcmp0((gchar*) cur_node->name, "duration") == 0) {
 144                                 track_set_duration(track, g_ascii_strtoll((gchar*) cur_node->children->content, NULL, 10));
 145                         } else if (g_strcmp0((gchar*) cur_node->name, "stream") == 0) {
 146                                 track_set_stream(track, (gchar*) cur_node->children->content);
 147                         } else if (g_strcmp0((gchar*) cur_node->name, "rating") == 0) {
 148                                 track_set_rating(track, g_ascii_strtod((gchar*) cur_node->children->content, NULL));
 149                         } else if (g_strcmp0((gchar*) cur_node->name, "artist_id") == 0) {
 150                                 track_set_artist_id(track, g_ascii_strtoll((gchar*) cur_node->children->content, NULL, 10));
 151                         } else if (g_strcmp0((gchar*) cur_node->name, "artist_name") == 0) {
 152                                 track_set_artist_name(track, (gchar*) cur_node->children->content);
 153                         } else if (g_strcmp0((gchar*) cur_node->name, "album_id") == 0) {
 154                                 track_set_album_id(track, g_ascii_strtoll((gchar*) cur_node->children->content, NULL, 10));
 155                         } else if (g_strcmp0((gchar*) cur_node->name, "album_name") == 0) {
 156                                 track_set_album_name(track, (gchar*) cur_node->children->content);
 157                         }
 158                 }
 159         }
 160
 161         return track;
 162 }
 163
 164 void track_free(Track* track) {
 165         g_free(track->name);
 166         g_free(track->stream);
 167         g_free(track->album_name);
 168         g_free(track->artist_name);
 169         g_free(track);
 170 }
 171
 172
 173 void track_set_id(Track* track, const gint id) {
 174         track->id = id;
 175 }
 176
 177 void track_set_name(Track* track, const gchar* name) {
 178         track->name = g_strdup(name);
 179 }
 180
 181 void track_set_duration(Track* track, const gint duration) {
 182         track->duration = duration;
 183 }
 184
 185 void track_set_stream(Track* track, const gchar* stream) {
 186         track->stream = g_strdup(stream);
 187 }
 188
 189 void track_set_rating(Track* track, const gdouble rating) {
 190         track->rating = rating;
 191 }
 192
 193 void track_set_artist_id(Track* track, const gint artist_id) {
 194         track->artist_id = artist_id;
 195 }
 196
 197 void track_set_artist_name(Track* track, const gchar* artist_name) {
 198         track->artist_name = g_strdup(artist_name);
 199 }
 200
 201 void track_set_album_id(Track* track, const gint album_id) {
 202         track->album_id = album_id;
 203 }
 204
 205 void track_set_album_name(Track* track, const gchar* album_name) {
 206         track->album_name = g_strdup(album_name);
 207 }
 208
 209 static void track_list_free_item(Track* track, gpointer data) {
 210         track_free(track);
 211 }
 212
 213 void track_list_free(GList* track_list)
 214 {
 215         if (track_list) {
 216                 g_debug("track_list_free length: %d", g_list_length(track_list));
 217                 g_list_foreach(track_list, (GFunc) track_list_free_item, NULL);
 218                 g_list_free(track_list);
 219         }
 220 }
 221
 222 /***
 223  * RADIO
 224  */
 225
 226 Radio* radio_new() {
 227         return g_new0(Radio, 1);
 228 }
 229
 230 Radio* radio_copy(Radio* radio) {
 231         Radio* newRadio =  g_new0(Radio, 1);
 232         radio_set_id(newRadio,radio->id);
 233         radio_set_image(newRadio,radio->image);
 234         radio_set_name(newRadio,radio->name);
 235         return newRadio;
 236 }
 237
 238 Radio* radio_new_from_xml(xmlNode* radio_node) {
 239         Radio* radio = NULL;
 240         if (radio_node->type == XML_ELEMENT_NODE && g_strcmp0((gchar*) radio_node->name, "radio") == 0) {
 241                 xmlNode* cur_node;
 242                 radio = radio_new();
 243                 for (cur_node = radio_node->children; cur_node; cur_node = cur_node->next) {
 244                         if (!(cur_node->type == XML_ELEMENT_NODE && cur_node->children))
 245                                 continue;
 246                         if (g_strcmp0((gchar*) cur_node->name, "id") == 0) {
 247                                 radio_set_id(radio, g_ascii_strtoll((gchar*) cur_node->children->content, NULL, 10));
 248                         } else if (g_strcmp0((gchar*) cur_node->name, "idstr") == 0) {
 249                                 radio_set_name(radio, (gchar*) cur_node->children->content);
 250                                 /*radio_set_name(radio, (gchar*)xmlNodeGetContent(cur_node));*/
 251                         } else if (g_strcmp0((gchar*) cur_node->name, "image") == 0) {
 252                                 radio_set_image(radio, (gchar*) cur_node->children->content);
 253                         }
 254                 }
 255         }
 256
 257         return radio;
 258 }
 259
 260 void radio_free(Radio* radio) {
 261         g_free(radio->image);
 262         g_free(radio->name);
 263         g_free(radio);
 264 }
 265
 266 void radio_set_id(Radio* radio, const gint id) {
 267         radio->id = id;
 268 }
 269
 270 void radio_set_name(Radio* radio, const gchar* name) {
 271         radio->name = g_strdup(name);
 272 }
 273
 274 void radio_set_image(Radio* radio, const gchar* image) {
 275         radio->image = g_strdup(image);
 276 }
 277
 278 static void radio_list_free_item(Radio* radio, gpointer data) {
 279         radio_free(radio);
 280 }
 281 void radio_list_free(GList* radio_list) {
 282         if (radio_list) {
 283                 g_debug("radio_list_free length: %d", g_list_length(radio_list));
 284                 g_list_foreach(radio_list, (GFunc) radio_list_free_item, NULL);
 285                 g_list_free(radio_list);
 286         }
 287 }