[libgrss] Warning: massive API break! Moved all object and function names in "grss" namespace
- From: Roberto Guido <rguido src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [libgrss] Warning: massive API break! Moved all object and function names in "grss" namespace
- Date: Tue, 23 Nov 2010 19:42:51 +0000 (UTC)
commit dd0c7b0c141b3dac5ed0a80844e43d6985e66118
Author: Roberto Guido <bob4mail gmail com>
Date: Tue Nov 23 20:41:28 2010 +0100
Warning: massive API break!
Moved all object and function names in "grss" namespace
NEWS | 1 +
src/feed-atom-handler.c | 130 +++++++++---------
src/feed-channel.c | 312 ++++++++++++++++++++--------------------
src/feed-channel.h | 96 ++++++------
src/feed-enclosure.c | 66 +++++-----
src/feed-enclosure.h | 32 ++--
src/feed-handler.c | 4 +-
src/feed-handler.h | 4 +-
src/feed-item.c | 230 +++++++++++++++---------------
src/feed-item.h | 80 +++++-----
src/feed-parser.c | 58 ++++----
src/feed-parser.h | 24 ++--
src/feed-pie-handler.c | 62 ++++----
src/feed-rss-handler.c | 88 ++++++------
src/feeds-group-handler.c | 38 +++---
src/feeds-group-handler.h | 26 ++--
src/feeds-group.c | 68 +++++-----
src/feeds-group.h | 26 ++--
src/feeds-opml-group-handler.c | 28 ++--
src/feeds-pool.c | 168 +++++++++++-----------
src/feeds-pool.h | 36 +++---
src/feeds-publisher.c | 180 ++++++++++++------------
src/feeds-publisher.h | 36 +++---
src/feeds-store.c | 78 +++++-----
src/feeds-store.h | 38 +++---
src/feeds-subscriber.c | 204 +++++++++++++-------------
src/feeds-subscriber.h | 34 +++---
src/feeds-xbel-group-handler.c | 22 ++--
src/feeds-xoxo-group-handler.c | 22 ++--
src/ns-handler.c | 114 ++++++++--------
src/ns-handler.h | 4 +-
31 files changed, 1155 insertions(+), 1154 deletions(-)
---
diff --git a/NEWS b/NEWS
index 05f897b..50df4f0 100644
--- a/NEWS
+++ b/NEWS
@@ -1,5 +1,6 @@
libgrss 0.5 (UNRELEASED)
==============================================================================
+- Complete API break: all object and function names moved to "grss" namespace
- Added XOXO files parser
- Added XBEL files parser
- Added FeedsPublisher to expose feeds contents as files or by local server
diff --git a/src/feed-atom-handler.c b/src/feed-atom-handler.c
index b58b8a4..e932802 100644
--- a/src/feed-atom-handler.c
+++ b/src/feed-atom-handler.c
@@ -43,8 +43,8 @@
#define FEED_ATOM_HANDLER_ERROR feed_atom_handler_error_quark()
#define ATOM10_NS BAD_CAST"http://www.w3.org/2005/Atom";
-typedef void (*AtomChannelParserFunc) (xmlNodePtr cur, FeedChannel *feed);
-typedef void (*AtomItemParserFunc) (xmlNodePtr cur, FeedItem *item, FeedChannel *feed);
+typedef void (*AtomChannelParserFunc) (xmlNodePtr cur, GrssFeedChannel *feed);
+typedef void (*AtomItemParserFunc) (xmlNodePtr cur, GrssFeedItem *item, GrssFeedChannel *feed);
struct FeedAtomHandlerPrivate {
NSHandler *handler;
@@ -344,7 +344,7 @@ atom10_parse_person_construct (xmlNodePtr cur)
/* Note: this function is called for both item and feed context */
static gchar *
-atom10_parse_link (xmlNodePtr cur, FeedChannel *feed, FeedItem *item)
+atom10_parse_link (xmlNodePtr cur, GrssFeedChannel *feed, GrssFeedItem *item)
{
gchar *href;
const gchar *home;
@@ -356,7 +356,7 @@ atom10_parse_link (xmlNodePtr cur, FeedChannel *feed, FeedItem *item)
xmlChar *baseURL = xmlNodeGetBase (cur->doc, cur);
gchar *url, *relation, *type, *escTitle = NULL, *title;
- home = feed_channel_get_homepage (feed);
+ home = grss_feed_channel_get_homepage (feed);
if (!baseURL && home && strstr (home, "://"))
baseURL = xmlStrdup (BAD_CAST home);
@@ -375,7 +375,7 @@ atom10_parse_link (xmlNodePtr cur, FeedChannel *feed, FeedItem *item)
else if (g_str_equal (relation, "replies")) {
if (item != NULL && (!type || g_str_equal (type, BAD_CAST"application/atom+xml"))) {
gchar *commentUri = (gchar*) common_build_url ((gchar*) url, home);
- feed_item_set_comments_url (item, commentUri);
+ grss_feed_item_set_comments_url (item, commentUri);
g_free (commentUri);
}
}
@@ -383,34 +383,34 @@ atom10_parse_link (xmlNodePtr cur, FeedChannel *feed, FeedItem *item)
if (item != NULL) {
gsize length = 0;
gchar *lengthStr = (gchar*) xmlGetNsProp (cur, BAD_CAST"length", NULL);
- FeedEnclosure *enclosure;
+ GrssFeedEnclosure *enclosure;
if (lengthStr)
length = atol (lengthStr);
g_free (lengthStr);
- enclosure = feed_enclosure_new (url);
- feed_enclosure_set_format (enclosure, type);
- feed_enclosure_set_length (enclosure, length);
- feed_item_add_enclosure (item, enclosure);
+ enclosure = grss_feed_enclosure_new (url);
+ grss_feed_enclosure_set_format (enclosure, type);
+ grss_feed_enclosure_set_length (enclosure, length);
+ grss_feed_item_add_enclosure (item, enclosure);
}
}
else if (g_str_equal (relation, "related")) {
if (item != NULL)
- feed_item_set_related (item, url);
+ grss_feed_item_set_related (item, url);
}
else if (g_str_equal (relation, "via")) {
/*
- FIXME How to handle "via" relation? With feed_item_set_source() ?
+ FIXME How to handle "via" relation? With grss_feed_item_set_source() ?
*/
}
else if (g_str_equal (relation, "hub")) {
if (feed != NULL)
- feed_channel_set_pubsubhub (feed, url, NULL);
+ grss_feed_channel_set_pubsubhub (feed, url, NULL);
}
else if (g_str_equal (relation, "self")) {
if (feed != NULL)
- feed_channel_set_pubsubhub (feed, NULL, url);
+ grss_feed_channel_set_pubsubhub (feed, NULL, url);
}
xmlFree (title);
@@ -429,19 +429,19 @@ atom10_parse_link (xmlNodePtr cur, FeedChannel *feed, FeedItem *item)
}
static void
-atom10_parse_entry_author (xmlNodePtr cur, FeedItem *item, FeedChannel *feed)
+atom10_parse_entry_author (xmlNodePtr cur, GrssFeedItem *item, GrssFeedChannel *feed)
{
gchar *author;
author = atom10_parse_person_construct (cur);
if (author) {
- feed_item_set_author (item, author);
+ grss_feed_item_set_author (item, author);
g_free (author);
}
}
static void
-atom10_parse_entry_category (xmlNodePtr cur, FeedItem *item, FeedChannel *feed)
+atom10_parse_entry_category (xmlNodePtr cur, GrssFeedItem *item, GrssFeedChannel *feed)
{
gchar *category = NULL;
@@ -451,69 +451,69 @@ atom10_parse_entry_category (xmlNodePtr cur, FeedItem *item, FeedChannel *feed)
if (category) {
gchar *escaped = g_markup_escape_text (category, -1);
- feed_item_add_category (item, escaped);
+ grss_feed_item_add_category (item, escaped);
g_free (escaped);
xmlFree (category);
}
}
static void
-atom10_parse_entry_content (xmlNodePtr cur, FeedItem *item, FeedChannel *feed)
+atom10_parse_entry_content (xmlNodePtr cur, GrssFeedItem *item, GrssFeedChannel *feed)
{
gchar *content;
content = atom10_parse_content_construct (cur);
if (content) {
- feed_item_set_description (item, content);
+ grss_feed_item_set_description (item, content);
g_free (content);
}
}
static void
-atom10_parse_entry_contributor (xmlNodePtr cur, FeedItem *item, FeedChannel *feed)
+atom10_parse_entry_contributor (xmlNodePtr cur, GrssFeedItem *item, GrssFeedChannel *feed)
{
gchar *contributor;
contributor = atom10_parse_person_construct (cur);
if (contributor) {
- feed_item_add_contributor (item, contributor);
+ grss_feed_item_add_contributor (item, contributor);
g_free (contributor);
}
}
static void
-atom10_parse_entry_id (xmlNodePtr cur, FeedItem *item, FeedChannel *feed)
+atom10_parse_entry_id (xmlNodePtr cur, GrssFeedItem *item, GrssFeedChannel *feed)
{
gchar *id;
id = (gchar*) xmlNodeListGetString (cur->doc, cur->xmlChildrenNode, 1);
if (id) {
if (strlen (id) > 0)
- feed_item_set_id (item, id);
+ grss_feed_item_set_id (item, id);
g_free (id);
}
}
static void
-atom10_parse_entry_link (xmlNodePtr cur, FeedItem *item, FeedChannel *feed)
+atom10_parse_entry_link (xmlNodePtr cur, GrssFeedItem *item, GrssFeedChannel *feed)
{
gchar *href;
href = atom10_parse_link (cur, feed, item);
if (href) {
- feed_item_set_source (item, href);
+ grss_feed_item_set_source (item, href);
g_free (href);
}
}
static void
-atom10_parse_entry_rights (xmlNodePtr cur, FeedItem *item, FeedChannel *feed)
+atom10_parse_entry_rights (xmlNodePtr cur, GrssFeedItem *item, GrssFeedChannel *feed)
{
gchar *rights;
rights = atom10_parse_text_construct (cur, FALSE);
if (rights) {
- feed_item_set_copyright (item, rights);
+ grss_feed_item_set_copyright (item, rights);
g_free (rights);
}
}
@@ -521,13 +521,13 @@ atom10_parse_entry_rights (xmlNodePtr cur, FeedItem *item, FeedChannel *feed)
/* <summary> can be used for short text descriptions, if there is no
<content> description we show the <summary> content */
static void
-atom10_parse_entry_summary (xmlNodePtr cur, FeedItem *item, FeedChannel *feed)
+atom10_parse_entry_summary (xmlNodePtr cur, GrssFeedItem *item, GrssFeedChannel *feed)
{
gchar *summary;
summary = atom10_parse_text_construct (cur, TRUE);
if (summary) {
- feed_item_set_description (item, summary);
+ grss_feed_item_set_description (item, summary);
g_free (summary);
}
@@ -535,19 +535,19 @@ atom10_parse_entry_summary (xmlNodePtr cur, FeedItem *item, FeedChannel *feed)
}
static void
-atom10_parse_entry_title (xmlNodePtr cur, FeedItem *item, FeedChannel *feed)
+atom10_parse_entry_title (xmlNodePtr cur, GrssFeedItem *item, GrssFeedChannel *feed)
{
gchar *title;
title = atom10_parse_text_construct (cur, FALSE);
if (title) {
- feed_item_set_title (item, title);
+ grss_feed_item_set_title (item, title);
g_free (title);
}
}
static void
-atom10_parse_entry_published (xmlNodePtr cur, FeedItem *item, FeedChannel *feed)
+atom10_parse_entry_published (xmlNodePtr cur, GrssFeedItem *item, GrssFeedChannel *feed)
{
gchar *datestr;
time_t t;
@@ -555,9 +555,9 @@ atom10_parse_entry_published (xmlNodePtr cur, FeedItem *item, FeedChannel *feed)
datestr = (gchar *)xmlNodeListGetString (cur->doc, cur->xmlChildrenNode, 1);
/* if pubDate is already set, don't overwrite it */
- if (datestr && feed_item_get_publish_time (item) == 0) {
+ if (datestr && grss_feed_item_get_publish_time (item) == 0) {
t = date_parse_ISO8601 (datestr);
- feed_item_set_publish_time (item, t);
+ grss_feed_item_set_publish_time (item, t);
}
g_free (datestr);
@@ -565,14 +565,14 @@ atom10_parse_entry_published (xmlNodePtr cur, FeedItem *item, FeedChannel *feed)
/* <content> tag support, FIXME: base64 not supported */
/* method to parse standard tags for each item element */
-static FeedItem*
-atom10_parse_entry (FeedHandler *self, FeedChannel *feed, xmlNodePtr cur)
+static GrssFeedItem*
+atom10_parse_entry (FeedHandler *self, GrssFeedChannel *feed, xmlNodePtr cur)
{
AtomItemParserFunc func;
FeedAtomHandler *parser;
- FeedItem *item;
+ GrssFeedItem *item;
- item = feed_item_new (feed);
+ item = grss_feed_item_new (feed);
parser = FEED_ATOM_HANDLER (self);
cur = cur->xmlChildrenNode;
@@ -615,19 +615,19 @@ atom10_parse_entry (FeedHandler *self, FeedChannel *feed, xmlNodePtr cur)
}
static void
-atom10_parse_feed_author (xmlNodePtr cur, FeedChannel *feed)
+atom10_parse_feed_author (xmlNodePtr cur, GrssFeedChannel *feed)
{
gchar *author;
author = atom10_parse_person_construct (cur);
if (author) {
- feed_channel_set_editor (feed, author);
+ grss_feed_channel_set_editor (feed, author);
g_free (author);
}
}
static void
-atom10_parse_feed_category (xmlNodePtr cur, FeedChannel *feed)
+atom10_parse_feed_category (xmlNodePtr cur, GrssFeedChannel *feed)
{
gchar *label = NULL;
@@ -637,27 +637,27 @@ atom10_parse_feed_category (xmlNodePtr cur, FeedChannel *feed)
if (label) {
gchar *escaped = g_markup_escape_text (label, -1);
- feed_channel_set_category (feed, escaped);
+ grss_feed_channel_set_category (feed, escaped);
g_free (escaped);
xmlFree (label);
}
}
static void
-atom10_parse_feed_contributor (xmlNodePtr cur, FeedChannel *feed)
+atom10_parse_feed_contributor (xmlNodePtr cur, GrssFeedChannel *feed)
{
/* parse feed contributors */
gchar *contributer;
contributer = atom10_parse_person_construct (cur);
if (contributer) {
- feed_channel_add_contributor (feed, contributer);
+ grss_feed_channel_add_contributor (feed, contributer);
g_free (contributer);
}
}
static void
-atom10_parse_feed_generator (xmlNodePtr cur, FeedChannel *feed)
+atom10_parse_feed_generator (xmlNodePtr cur, GrssFeedChannel *feed)
{
gchar *ret;
gchar *version;
@@ -682,33 +682,33 @@ atom10_parse_feed_generator (xmlNodePtr cur, FeedChannel *feed)
ret = tmp;
}
- feed_channel_set_generator (feed, tmp);
+ grss_feed_channel_set_generator (feed, tmp);
}
g_free (ret);
}
static void
-atom10_parse_feed_icon (xmlNodePtr cur, FeedChannel *feed)
+atom10_parse_feed_icon (xmlNodePtr cur, GrssFeedChannel *feed)
{
gchar *icon_uri;
icon_uri = (gchar *)xmlNodeListGetString (cur->doc, cur->xmlChildrenNode, 1);
if (icon_uri) {
- feed_channel_set_icon (feed, icon_uri);
+ grss_feed_channel_set_icon (feed, icon_uri);
g_free (icon_uri);
}
}
static void
-atom10_parse_feed_link (xmlNodePtr cur, FeedChannel *feed)
+atom10_parse_feed_link (xmlNodePtr cur, GrssFeedChannel *feed)
{
gchar *href;
href = atom10_parse_link (cur, feed, NULL);
if (href) {
xmlChar *baseURL = xmlNodeGetBase (cur->doc, xmlDocGetRootElement (cur->doc));
- feed_channel_set_homepage (feed, href);
+ grss_feed_channel_set_homepage (feed, href);
/* Set the default base to the feed's HTML URL if not set yet */
if (baseURL == NULL)
@@ -721,55 +721,55 @@ atom10_parse_feed_link (xmlNodePtr cur, FeedChannel *feed)
}
static void
-atom10_parse_feed_logo (xmlNodePtr cur, FeedChannel *feed)
+atom10_parse_feed_logo (xmlNodePtr cur, GrssFeedChannel *feed)
{
gchar *logo;
logo = atom10_parse_text_construct (cur, FALSE);
if (logo) {
- feed_channel_set_image (feed, logo);
+ grss_feed_channel_set_image (feed, logo);
g_free (logo);
}
}
static void
-atom10_parse_feed_rights (xmlNodePtr cur, FeedChannel *feed)
+atom10_parse_feed_rights (xmlNodePtr cur, GrssFeedChannel *feed)
{
gchar *rights;
rights = atom10_parse_text_construct (cur, FALSE);
if (rights) {
- feed_channel_set_copyright (feed, rights);
+ grss_feed_channel_set_copyright (feed, rights);
g_free (rights);
}
}
static void
-atom10_parse_feed_subtitle (xmlNodePtr cur, FeedChannel *feed)
+atom10_parse_feed_subtitle (xmlNodePtr cur, GrssFeedChannel *feed)
{
gchar *subtitle;
subtitle = atom10_parse_text_construct (cur, TRUE);
if (subtitle) {
- feed_channel_set_description (feed, subtitle);
+ grss_feed_channel_set_description (feed, subtitle);
g_free (subtitle);
}
}
static void
-atom10_parse_feed_title (xmlNodePtr cur, FeedChannel *feed)
+atom10_parse_feed_title (xmlNodePtr cur, GrssFeedChannel *feed)
{
gchar *title;
title = atom10_parse_text_construct (cur, FALSE);
if (title) {
- feed_channel_set_title (feed, title);
+ grss_feed_channel_set_title (feed, title);
g_free (title);
}
}
static void
-atom10_parse_feed_updated (xmlNodePtr cur, FeedChannel *feed)
+atom10_parse_feed_updated (xmlNodePtr cur, GrssFeedChannel *feed)
{
gchar *timestamp;
time_t t;
@@ -777,20 +777,20 @@ atom10_parse_feed_updated (xmlNodePtr cur, FeedChannel *feed)
timestamp = (gchar *)xmlNodeListGetString (cur->doc, cur->xmlChildrenNode, 1);
if (timestamp) {
t = date_parse_ISO8601 (timestamp);
- feed_channel_set_update_time (feed, t);
+ grss_feed_channel_set_update_time (feed, t);
g_free (timestamp);
}
}
static GList*
-feed_atom_handler_parse (FeedHandler *self, FeedChannel *feed, xmlDocPtr doc, GError **error)
+feed_atom_handler_parse (FeedHandler *self, GrssFeedChannel *feed, xmlDocPtr doc, GError **error)
{
time_t now;
xmlNodePtr cur;
GList *items;
AtomChannelParserFunc func;
FeedAtomHandler *parser;
- FeedItem *item;
+ GrssFeedItem *item;
items = NULL;
@@ -842,8 +842,8 @@ feed_atom_handler_parse (FeedHandler *self, FeedChannel *feed, xmlDocPtr doc, GE
else if (xmlStrEqual (cur->name, BAD_CAST"entry")) {
item = atom10_parse_entry (self, feed, cur);
if (item) {
- if (feed_item_get_publish_time (item) == 0)
- feed_item_set_publish_time (item, now);
+ if (grss_feed_item_get_publish_time (item) == 0)
+ grss_feed_item_set_publish_time (item, now);
items = g_list_append (items, item);
}
}
diff --git a/src/feed-channel.c b/src/feed-channel.c
index a6b3b72..40b5082 100644
--- a/src/feed-channel.c
+++ b/src/feed-channel.c
@@ -22,13 +22,13 @@
#include "feed-channel.h"
#include "feed-parser.h"
-#define FEED_CHANNEL_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), FEED_CHANNEL_TYPE, FeedChannelPrivate))
+#define FEED_CHANNEL_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), FEED_CHANNEL_TYPE, GrssFeedChannelPrivate))
/**
* SECTION: feed-channel
* @short_description: a feed
*
- * #FeedChannel rappresents a single feed which may be fetched and parsed
+ * #GrssFeedChannel rappresents a single feed which may be fetched and parsed
*/
#define FEEDS_CHANNEL_ERROR feeds_channel_error_quark()
@@ -38,7 +38,7 @@ typedef struct {
gchar *self;
} PubSub;
-struct _FeedChannelPrivate {
+struct _GrssFeedChannelPrivate {
gchar *source;
gchar *title;
@@ -65,7 +65,7 @@ enum {
FEEDS_CHANNEL_FETCH_ERROR,
};
-G_DEFINE_TYPE (FeedChannel, feed_channel, G_TYPE_OBJECT);
+G_DEFINE_TYPE (GrssFeedChannel, grss_feed_channel, G_TYPE_OBJECT);
static GQuark
feeds_channel_error_quark ()
@@ -74,10 +74,10 @@ feeds_channel_error_quark ()
}
static void
-feed_channel_finalize (GObject *obj)
+grss_feed_channel_finalize (GObject *obj)
{
GList *iter;
- FeedChannel *chan;
+ GrssFeedChannel *chan;
chan = FEED_CHANNEL (obj);
FREE_STRING (chan->priv->title);
@@ -102,60 +102,60 @@ feed_channel_finalize (GObject *obj)
}
static void
-feed_channel_class_init (FeedChannelClass *klass)
+grss_feed_channel_class_init (GrssFeedChannelClass *klass)
{
GObjectClass *gobject_class;
- g_type_class_add_private (klass, sizeof (FeedChannelPrivate));
+ g_type_class_add_private (klass, sizeof (GrssFeedChannelPrivate));
gobject_class = G_OBJECT_CLASS (klass);
- gobject_class->finalize = feed_channel_finalize;
+ gobject_class->finalize = grss_feed_channel_finalize;
}
static void
-feed_channel_init (FeedChannel *node)
+grss_feed_channel_init (GrssFeedChannel *node)
{
node->priv = FEED_CHANNEL_GET_PRIVATE (node);
- memset (node->priv, 0, sizeof (FeedChannelPrivate));
+ memset (node->priv, 0, sizeof (GrssFeedChannelPrivate));
}
/**
- * feed_channel_new:
+ * grss_feed_channel_new:
*
- * Allocates a new #FeedChannel
+ * Allocates a new #GrssFeedChannel
*
- * Return value: a #FeedChannel
+ * Return value: a #GrssFeedChannel
*/
-FeedChannel*
-feed_channel_new ()
+GrssFeedChannel*
+grss_feed_channel_new ()
{
return g_object_new (FEED_CHANNEL_TYPE, NULL);
}
/**
- * feed_channel_new_from_file:
+ * grss_feed_channel_new_from_file:
* @path: path of the file to parse
*
- * Allocates a new #FeedChannel and init it with contents found in specified
+ * Allocates a new #GrssFeedChannel and init it with contents found in specified
* file
*
- * Return value: a #FeedChannel, or NULL if the file in @path is not a valid
+ * Return value: a #GrssFeedChannel, or NULL if the file in @path is not a valid
* document
*/
-FeedChannel*
-feed_channel_new_from_file (const gchar *path)
+GrssFeedChannel*
+grss_feed_channel_new_from_file (const gchar *path)
{
GList *items;
GList *iter;
xmlDocPtr doc;
- FeedParser *parser;
- FeedChannel *ret;
+ GrssFeedParser *parser;
+ GrssFeedChannel *ret;
/*
TODO This function is quite inefficent because parses all
- the feed with a FeedParser and then trash obtained
- FeedItems. Perhaps a more aimed function in
- FeedParser would help...
+ the feed with a GrssFeedParser and then trash obtained
+ GrssFeedItems. Perhaps a more aimed function in
+ GrssFeedParser would help...
*/
ret = NULL;
@@ -163,8 +163,8 @@ feed_channel_new_from_file (const gchar *path)
if (doc != NULL) {
ret = g_object_new (FEED_CHANNEL_TYPE, NULL);
- parser = feed_parser_new ();
- items = feed_parser_parse (parser, ret, doc, NULL);
+ parser = grss_feed_parser_new ();
+ items = grss_feed_parser_parse (parser, ret, doc, NULL);
if (items != NULL) {
for (iter = items; iter; iter = g_list_next (iter))
@@ -180,162 +180,162 @@ feed_channel_new_from_file (const gchar *path)
}
/**
- * feed_channel_set_source:
- * @channel: a #FeedChannel
+ * grss_feed_channel_set_source:
+ * @channel: a #GrssFeedChannel
* @source: URL of the feed
*
* To assign the URL where to fetch the feed
*/
void
-feed_channel_set_source (FeedChannel *channel, gchar *source)
+grss_feed_channel_set_source (GrssFeedChannel *channel, gchar *source)
{
FREE_STRING (channel->priv->source);
channel->priv->source = g_strdup (source);
}
/**
- * feed_channel_get_source:
- * @channel: a #FeedChannel
+ * grss_feed_channel_get_source:
+ * @channel: a #GrssFeedChannel
*
* Retrieves URL where to fetch the @channel
*
* Return value: URL of the channel
*/
const gchar*
-feed_channel_get_source (FeedChannel *channel)
+grss_feed_channel_get_source (GrssFeedChannel *channel)
{
return (const gchar*) channel->priv->source;
}
/**
- * feed_channel_set_title:
- * @channel: a #FeedChannel
+ * grss_feed_channel_set_title:
+ * @channel: a #GrssFeedChannel
* @title: title of the feed
*
* To set a title to the @channel
*/
void
-feed_channel_set_title (FeedChannel *channel, gchar *title)
+grss_feed_channel_set_title (GrssFeedChannel *channel, gchar *title)
{
FREE_STRING (channel->priv->title);
channel->priv->title = g_strdup (title);
}
/**
- * feed_channel_get_title:
- * @channel: a #FeedChannel
+ * grss_feed_channel_get_title:
+ * @channel: a #GrssFeedChannel
*
* Retrieves title of the @channel
*
* Return value: title of the feed, or NULL
*/
const gchar*
-feed_channel_get_title (FeedChannel *channel)
+grss_feed_channel_get_title (GrssFeedChannel *channel)
{
return (const gchar*) channel->priv->title;
}
/**
- * feed_channel_set_homepage:
- * @channel: a #FeedChannel
+ * grss_feed_channel_set_homepage:
+ * @channel: a #GrssFeedChannel
* @homepage: homepage for the main website
*
* To set the homepage of the site the @channel belongs
*/
void
-feed_channel_set_homepage (FeedChannel *channel, gchar *homepage)
+grss_feed_channel_set_homepage (GrssFeedChannel *channel, gchar *homepage)
{
FREE_STRING (channel->priv->homepage);
channel->priv->homepage = g_strdup (homepage);
}
/**
- * feed_channel_get_homepage:
- * @channel: a #FeedChannel
+ * grss_feed_channel_get_homepage:
+ * @channel: a #GrssFeedChannel
*
* Retrieves the homepage of the site for which @channel is the feed
*
* Return value: reference homepage of the feed, or NULL
*/
const gchar*
-feed_channel_get_homepage (FeedChannel *channel)
+grss_feed_channel_get_homepage (GrssFeedChannel *channel)
{
return (const gchar*) channel->priv->homepage;
}
/**
- * feed_channel_set_description:
- * @channel: a #FeedChannel
+ * grss_feed_channel_set_description:
+ * @channel: a #GrssFeedChannel
* @description: description of the feed
*
* To set the description of @channel
*/
void
-feed_channel_set_description (FeedChannel *channel, gchar *description)
+grss_feed_channel_set_description (GrssFeedChannel *channel, gchar *description)
{
FREE_STRING (channel->priv->description);
channel->priv->description = g_strdup (description);
}
/**
- * feed_channel_get_description:
- * @channel: a #FeedChannel
+ * grss_feed_channel_get_description:
+ * @channel: a #GrssFeedChannel
*
* Retrieves the description of @channel
*
* Return value: description of the feed, or NULL
*/
const gchar*
-feed_channel_get_description (FeedChannel *channel)
+grss_feed_channel_get_description (GrssFeedChannel *channel)
{
return (const gchar*) channel->priv->description;
}
/**
- * feed_channel_set_image:
- * @channel: a #FeedChannel
+ * grss_feed_channel_set_image:
+ * @channel: a #GrssFeedChannel
* @image: URL of the image
*
* To set a rappresentative image to @channel
*/
void
-feed_channel_set_image (FeedChannel *channel, gchar *image)
+grss_feed_channel_set_image (GrssFeedChannel *channel, gchar *image)
{
FREE_STRING (channel->priv->image);
channel->priv->image = g_strdup (image);
}
/**
- * feed_channel_get_image:
- * @channel: a #FeedChannel
+ * grss_feed_channel_get_image:
+ * @channel: a #GrssFeedChannel
*
* Retrieves the URL of the image assigned to the channel
*
* Return value: URL of the image, or NULL
*/
const gchar*
-feed_channel_get_image (FeedChannel *channel)
+grss_feed_channel_get_image (GrssFeedChannel *channel)
{
return (const gchar*) channel->priv->image;
}
/**
- * feed_channel_set_icon:
- * @channel: a #FeedChannel
+ * grss_feed_channel_set_icon:
+ * @channel: a #GrssFeedChannel
* @icon: URL where to retrieve the favicon
*
* To set the URL of the icon rappresenting @channel
*/
void
-feed_channel_set_icon (FeedChannel *channel, gchar *icon)
+grss_feed_channel_set_icon (GrssFeedChannel *channel, gchar *icon)
{
FREE_STRING (channel->priv->icon);
channel->priv->icon = g_strdup (icon);
}
/**
- * feed_channel_get_icon:
- * @channel: a #FeedChannel
+ * grss_feed_channel_get_icon:
+ * @channel: a #GrssFeedChannel
*
* Retrieves URL of the favicon of the channel (and/or the website for which
* this is the feed)
@@ -343,81 +343,81 @@ feed_channel_set_icon (FeedChannel *channel, gchar *icon)
* Return value: URL of the favicon, or NULL
*/
const gchar*
-feed_channel_get_icon (FeedChannel *channel)
+grss_feed_channel_get_icon (GrssFeedChannel *channel)
{
return (const gchar*) channel->priv->icon;
}
/**
- * feed_channel_set_language:
- * @channel: a #FeedChannel
+ * grss_feed_channel_set_language:
+ * @channel: a #GrssFeedChannel
* @language: string holding the language of the feed
*
* To set the language of @channel
*/
void
-feed_channel_set_language (FeedChannel *channel, gchar *language)
+grss_feed_channel_set_language (GrssFeedChannel *channel, gchar *language)
{
FREE_STRING (channel->priv->language);
channel->priv->language = g_strdup (language);
}
/**
- * feed_channel_get_language:
- * @channel: a #FeedChannel
+ * grss_feed_channel_get_language:
+ * @channel: a #GrssFeedChannel
*
* Retrieves the language of the @channel
*
* Return value: string rappresenting the language of channel
*/
const gchar*
-feed_channel_get_language (FeedChannel *channel)
+grss_feed_channel_get_language (GrssFeedChannel *channel)
{
return (const gchar*) channel->priv->language;
}
/**
- * feed_channel_set_category:
- * @channel: a #FeedChannel
+ * grss_feed_channel_set_category:
+ * @channel: a #GrssFeedChannel
* @category: category of the feed
*
* To set the category of the @channel
*/
void
-feed_channel_set_category (FeedChannel *channel, gchar *category)
+grss_feed_channel_set_category (GrssFeedChannel *channel, gchar *category)
{
FREE_STRING (channel->priv->category);
channel->priv->category = g_strdup (category);
}
/**
- * feed_channel_get_category:
- * @channel: a #FeedChannel
+ * grss_feed_channel_get_category:
+ * @channel: a #GrssFeedChannel
*
* Retrieves category of the @channel
*
* Return value: category of the feed, or NULL
*/
const gchar*
-feed_channel_get_category (FeedChannel *channel)
+grss_feed_channel_get_category (GrssFeedChannel *channel)
{
return (const gchar*) channel->priv->category;
}
/**
- * feed_channel_set_pubsubhub:
- * @channel: a #FeedChannel
+ * grss_feed_channel_set_pubsubhub:
+ * @channel: a #GrssFeedChannel
* @hub: hub for the feed, or NULL
* @self: target referencing the feed, or NULL
*
* To set information about PubSubHubbub for the channel. Options can be set
* alternatively, only with hub != %NULL or self != %NULL, and are saved
* internally to the object: the hub is considered valid
- * (feed_channel_get_pubsubhub() returns %TRUE) only when both parameters has
+ * (grss_feed_channel_get_pubsubhub() returns %TRUE) only when both parameters has
* been set. To unset the hub, pass %NULL for both parameters
*/
void
-feed_channel_set_pubsubhub (FeedChannel *channel, gchar *hub, gchar *self)
+grss_feed_channel_set_pubsubhub (GrssFeedChannel *channel, gchar *hub, gchar *self)
{
if (hub == NULL && self == NULL) {
FREE_STRING (channel->priv->pubsub.hub);
@@ -436,8 +436,8 @@ feed_channel_set_pubsubhub (FeedChannel *channel, gchar *hub, gchar *self)
}
/**
- * feed_channel_get_pubsubhub:
- * @channel: a #FeedChannel
+ * grss_feed_channel_get_pubsubhub:
+ * @channel: a #GrssFeedChannel
* @hub: location for the hub string, or NULL
* @self: location for the reference to the feed, or NULL
*
@@ -447,7 +447,7 @@ feed_channel_set_pubsubhub (FeedChannel *channel, gchar *hub, gchar *self)
* @channel, %FALSE otherwise
*/
gboolean
-feed_channel_get_pubsubhub (FeedChannel *channel, gchar **hub, gchar **self)
+grss_feed_channel_get_pubsubhub (GrssFeedChannel *channel, gchar **hub, gchar **self)
{
if (hub != NULL)
*hub = channel->priv->pubsub.hub;
@@ -458,70 +458,70 @@ feed_channel_get_pubsubhub (FeedChannel *channel, gchar **hub, gchar **self)
}
/**
- * feed_channel_set_copyright:
- * @channel: a #FeedChannel
+ * grss_feed_channel_set_copyright:
+ * @channel: a #GrssFeedChannel
* @copyright: copyright of the channel
*
* To set the copyright of the feed
*/
void
-feed_channel_set_copyright (FeedChannel *channel, gchar *copyright)
+grss_feed_channel_set_copyright (GrssFeedChannel *channel, gchar *copyright)
{
FREE_STRING (channel->priv->copyright);
channel->priv->copyright = g_strdup (copyright);
}
/**
- * feed_channel_get_copyright:
- * @channel: a #FeedChannel
+ * grss_feed_channel_get_copyright:
+ * @channel: a #GrssFeedChannel
*
* Retrieves indications about the copyright
*
* Return value: copyright of the @channel, or NULL
*/
const gchar*
-feed_channel_get_copyright (FeedChannel *channel)
+grss_feed_channel_get_copyright (GrssFeedChannel *channel)
{
return (const gchar*) channel->priv->copyright;
}
/**
- * feed_channel_set_editor:
- * @channel: a #FeedChannel
+ * grss_feed_channel_set_editor:
+ * @channel: a #GrssFeedChannel
* @editor: editor of the feed
*
* To set the editor of the @channel
*/
void
-feed_channel_set_editor (FeedChannel *channel, gchar *editor)
+grss_feed_channel_set_editor (GrssFeedChannel *channel, gchar *editor)
{
FREE_STRING (channel->priv->editor);
channel->priv->editor = g_strdup (editor);
}
/**
- * feed_channel_get_editor:
- * @channel: a #FeedChannel
+ * grss_feed_channel_get_editor:
+ * @channel: a #GrssFeedChannel
*
* Retrieves reference to the editor or the @channel
*
* Return value: editor of the feed, or NULL
*/
const gchar*
-feed_channel_get_editor (FeedChannel *channel)
+grss_feed_channel_get_editor (GrssFeedChannel *channel)
{
return (const gchar*) channel->priv->editor;
}
/**
- * feed_channel_add_contributor:
- * @channel: a #FeedChannel
+ * grss_feed_channel_add_contributor:
+ * @channel: a #GrssFeedChannel
* @contributor: contributor of the feed
*
* To add a contributor to the @channel
*/
void
-feed_channel_add_contributor (FeedChannel *channel, gchar *contributor)
+grss_feed_channel_add_contributor (GrssFeedChannel *channel, gchar *contributor)
{
gchar *con;
@@ -534,181 +534,181 @@ feed_channel_add_contributor (FeedChannel *channel, gchar *contributor)
}
/**
- * feed_channel_get_contributors:
- * @channel: a #FeedChannel
+ * grss_feed_channel_get_contributors:
+ * @channel: a #GrssFeedChannel
*
* Retrieves reference to the contributors of the @channel
*
* Return value: list of contributors to the channel, or NULL
*/
const GList*
-feed_channel_get_contributor (FeedChannel *channel)
+grss_feed_channel_get_contributor (GrssFeedChannel *channel)
{
return (const GList*) channel->priv->contributors;
}
/**
- * feed_channel_set_webmaster:
- * @channel: a #FeedChannel
+ * grss_feed_channel_set_webmaster:
+ * @channel: a #GrssFeedChannel
* @webmaster: webmaster of the feed
*
* To assign a webmaster to the @channel
*/
void
-feed_channel_set_webmaster (FeedChannel *channel, gchar *webmaster)
+grss_feed_channel_set_webmaster (GrssFeedChannel *channel, gchar *webmaster)
{
FREE_STRING (channel->priv->webmaster);
channel->priv->webmaster = g_strdup (webmaster);
}
/**
- * feed_channel_get_webmaster:
- * @channel: a #FeedChannel
+ * grss_feed_channel_get_webmaster:
+ * @channel: a #GrssFeedChannel
*
* Retrieves reference to the webmaster of the feed
*
* Return value: webmaster of @channel, or NULL
*/
const gchar*
-feed_channel_get_webmaster (FeedChannel *channel)
+grss_feed_channel_get_webmaster (GrssFeedChannel *channel)
{
return (const gchar*) channel->priv->webmaster;
}
/**
- * feed_channel_set_generator:
- * @channel: a #FeedChannel
+ * grss_feed_channel_set_generator:
+ * @channel: a #GrssFeedChannel
* @generator: software generator of the feed
*
* To set information about the software generator of @channel
*/
void
-feed_channel_set_generator (FeedChannel *channel, gchar *generator)
+grss_feed_channel_set_generator (GrssFeedChannel *channel, gchar *generator)
{
FREE_STRING (channel->priv->generator);
channel->priv->generator = g_strdup (generator);
}
/**
- * feed_channel_get_generator:
- * @channel: a #FeedChannel
+ * grss_feed_channel_get_generator:
+ * @channel: a #GrssFeedChannel
*
* Retrieves information about the feed's software generator
*
* Return value: generator of @channel, or NULL
*/
const gchar*
-feed_channel_get_generator (FeedChannel *channel)
+grss_feed_channel_get_generator (GrssFeedChannel *channel)
{
return (const gchar*) channel->priv->generator;
}
/**
- * feed_channel_set_publish_time:
- * @channel: a #FeedChannel
+ * grss_feed_channel_set_publish_time:
+ * @channel: a #GrssFeedChannel
* @publish: timestamp of publishing
*
* To set the time of publishing for the feed
*/
void
-feed_channel_set_publish_time (FeedChannel *channel, time_t publish)
+grss_feed_channel_set_publish_time (GrssFeedChannel *channel, time_t publish)
{
channel->priv->pub_time = publish;
}
/**
- * feed_channel_get_publish_time:
- * @channel: a #FeedChannel
+ * grss_feed_channel_get_publish_time:
+ * @channel: a #GrssFeedChannel
*
* Retrieves the publishing time of @channel
*
* Return value: time of feed's publish
*/
time_t
-feed_channel_get_publish_time (FeedChannel *channel)
+grss_feed_channel_get_publish_time (GrssFeedChannel *channel)
{
return channel->priv->pub_time;
}
/**
- * feed_channel_set_update_time:
- * @channel: a #FeedChannel
+ * grss_feed_channel_set_update_time:
+ * @channel: a #GrssFeedChannel
* @update: update time of the feed
*
* To set the latest update time of @channel
*/
void
-feed_channel_set_update_time (FeedChannel *channel, time_t update)
+grss_feed_channel_set_update_time (GrssFeedChannel *channel, time_t update)
{
channel->priv->update_time = update;
}
/**
- * feed_channel_get_update_time:
- * @channel: a #FeedChannel
+ * grss_feed_channel_get_update_time:
+ * @channel: a #GrssFeedChannel
*
* Retrieves the update time of @channel
*
* Return value: time of the feed's latest update. If this value was not set
- * (with feed_channel_set_update_time()) returns
- * feed_channel_get_publish_time()
+ * (with grss_feed_channel_set_update_time()) returns
+ * grss_feed_channel_get_publish_time()
*/
time_t
-feed_channel_get_update_time (FeedChannel *channel)
+grss_feed_channel_get_update_time (GrssFeedChannel *channel)
{
return channel->priv->update_time;
}
/**
- * feed_channel_set_update_interval:
- * @channel: a #FeedChannel
+ * grss_feed_channel_set_update_interval:
+ * @channel: a #GrssFeedChannel
* @minutes: update interval, in minutes
*
* To set the update interval for @channel
*/
void
-feed_channel_set_update_interval (FeedChannel *channel, int minutes)
+grss_feed_channel_set_update_interval (GrssFeedChannel *channel, int minutes)
{
channel->priv->update_interval = minutes;
}
/**
- * feed_channel_get_update_interval:
- * @channel: a #FeedChannel
+ * grss_feed_channel_get_update_interval:
+ * @channel: a #GrssFeedChannel
*
* Retrieves the update interval for the feed. Pay attention to the fact the
* value can be unset, and the function returns 0: in this case the caller
* must manually set a default update interval with
- * feed_channel_set_update_interval()
+ * grss_feed_channel_set_update_interval()
*
* Return value: update interval for the @channel, in minutes
*/
int
-feed_channel_get_update_interval (FeedChannel *channel)
+grss_feed_channel_get_update_interval (GrssFeedChannel *channel)
{
return channel->priv->update_interval;
}
static gboolean
-quick_and_dirty_parse (FeedChannel *channel, SoupMessage *msg)
+quick_and_dirty_parse (GrssFeedChannel *channel, SoupMessage *msg)
{
GList *items;
GList *iter;
xmlDocPtr doc;
- FeedParser *parser;
+ GrssFeedParser *parser;
/*
TODO This function is quite inefficent because parses all
- the feed with a FeedParser and them waste obtained
- FeedItems. Perhaps a more aimed function in
- FeedParser would help...
+ the feed with a GrssFeedParser and them waste obtained
+ GrssFeedItems. Perhaps a more aimed function in
+ GrssFeedParser would help...
*/
doc = content_to_xml (msg->response_body->data, msg->response_body->length);
if (doc != NULL) {
- parser = feed_parser_new ();
- items = feed_parser_parse (parser, channel, doc, NULL);
+ parser = grss_feed_parser_new ();
+ items = grss_feed_parser_parse (parser, channel, doc, NULL);
if (items != NULL) {
for (iter = items; iter; iter = g_list_next (iter))
@@ -726,19 +726,19 @@ quick_and_dirty_parse (FeedChannel *channel, SoupMessage *msg)
}
/**
- * feed_channel_fetch:
- * @channel: a #FeedChannel
+ * grss_feed_channel_fetch:
+ * @channel: a #GrssFeedChannel
*
- * Utility to fetch and populate a #FeedChannel for the first time, and init
+ * Utility to fetch and populate a #GrssFeedChannel for the first time, and init
* all his internal values. Only the source URL has to be set in @channel
- * (with feed_channel_set_source()). Be aware this function is sync, do not
+ * (with grss_feed_channel_set_source()). Be aware this function is sync, do not
* returns until the feed isn't downloaded and parsed
*
* Return value: %TRUE if the feed is correctly fetched and parsed, %FALSE
* otherwise
*/
gboolean
-feed_channel_fetch (FeedChannel *channel)
+grss_feed_channel_fetch (GrssFeedChannel *channel)
{
gboolean ret;
guint status;
@@ -746,14 +746,14 @@ feed_channel_fetch (FeedChannel *channel)
SoupSession *session;
session = soup_session_sync_new ();
- msg = soup_message_new ("GET", feed_channel_get_source (channel));
+ msg = soup_message_new ("GET", grss_feed_channel_get_source (channel));
status = soup_session_send_message (session, msg);
if (status >= 200 && status <= 299) {
ret = quick_and_dirty_parse (channel, msg);
}
else {
- g_warning ("Unable to fetch feed from %s: %s", feed_channel_get_source (channel), soup_status_get_phrase (status));
+ g_warning ("Unable to fetch feed from %s: %s", grss_feed_channel_get_source (channel), soup_status_get_phrase (status));
ret = FALSE;
}
@@ -766,7 +766,7 @@ static void
feed_downloaded (SoupSession *session, SoupMessage *msg, gpointer user_data) {
guint status;
GSimpleAsyncResult *result;
- FeedChannel *channel;
+ GrssFeedChannel *channel;
result = user_data;
channel = FEED_CHANNEL (g_async_result_get_source_object (G_ASYNC_RESULT (result)));
@@ -777,7 +777,7 @@ feed_downloaded (SoupSession *session, SoupMessage *msg, gpointer user_data) {
}
else {
g_simple_async_result_set_error (result, FEEDS_CHANNEL_ERROR, FEEDS_CHANNEL_FETCH_ERROR,
- "Unable to download from %s", feed_channel_get_source (channel));
+ "Unable to download from %s", grss_feed_channel_get_source (channel));
}
g_simple_async_result_complete_in_idle (result);
@@ -785,23 +785,23 @@ feed_downloaded (SoupSession *session, SoupMessage *msg, gpointer user_data) {
}
/**
- * feed_channel_fetch_async:
- * @channel: a #FeedChannel
+ * grss_feed_channel_fetch_async:
+ * @channel: a #GrssFeedChannel
* @callback: function to invoke at the end of the download
* @user_data: data passed to the callback
*
- * Similar to feed_channel_fetch(), but asyncronous
+ * Similar to grss_feed_channel_fetch(), but asyncronous
*/
void
-feed_channel_fetch_async (FeedChannel *channel, GAsyncReadyCallback callback, gpointer user_data)
+grss_feed_channel_fetch_async (GrssFeedChannel *channel, GAsyncReadyCallback callback, gpointer user_data)
{
GSimpleAsyncResult *result;
SoupMessage *msg;
SoupSession *session;
- result = g_simple_async_result_new (G_OBJECT (channel), callback, user_data, feed_channel_fetch_async);
+ result = g_simple_async_result_new (G_OBJECT (channel), callback, user_data, grss_feed_channel_fetch_async);
session = soup_session_async_new ();
- msg = soup_message_new ("GET", feed_channel_get_source (channel));
+ msg = soup_message_new ("GET", grss_feed_channel_get_source (channel));
soup_session_queue_message (session, msg, feed_downloaded, result);
}
diff --git a/src/feed-channel.h b/src/feed-channel.h
index 6f15462..411eb37 100644
--- a/src/feed-channel.h
+++ b/src/feed-channel.h
@@ -23,68 +23,68 @@
#include "libgrss.h"
-#define FEED_CHANNEL_TYPE (feed_channel_get_type())
-#define FEED_CHANNEL(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FEED_CHANNEL_TYPE, FeedChannel))
-#define FEED_CHANNEL_CLASS(c) (G_TYPE_CHECK_CLASS_CAST ((c), FEED_CHANNEL_TYPE, FeedChannelClass))
+#define FEED_CHANNEL_TYPE (grss_feed_channel_get_type())
+#define FEED_CHANNEL(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FEED_CHANNEL_TYPE, GrssFeedChannel))
+#define FEED_CHANNEL_CLASS(c) (G_TYPE_CHECK_CLASS_CAST ((c), FEED_CHANNEL_TYPE, GrssFeedChannelClass))
#define IS_FEED_CHANNEL(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FEED_CHANNEL_TYPE))
#define IS_FEED_CHANNEL_CLASS(c) (G_TYPE_CHECK_CLASS_TYPE ((c), FEED_CHANNEL_TYPE))
-#define FEED_CHANNEL_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FEED_CHANNEL_TYPE, FeedChannelClass))
+#define FEED_CHANNEL_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FEED_CHANNEL_TYPE, GrssFeedChannelClass))
-typedef struct _FeedChannel FeedChannel;
-typedef struct _FeedChannelPrivate FeedChannelPrivate;
+typedef struct _GrssFeedChannel GrssFeedChannel;
+typedef struct _GrssFeedChannelPrivate GrssFeedChannelPrivate;
-struct _FeedChannel {
+struct _GrssFeedChannel {
GObject parent;
- FeedChannelPrivate *priv;
+ GrssFeedChannelPrivate *priv;
};
typedef struct {
GObjectClass parent;
-} FeedChannelClass;
+} GrssFeedChannelClass;
-GType feed_channel_get_type (void) G_GNUC_CONST;
+GType grss_feed_channel_get_type (void) G_GNUC_CONST;
-FeedChannel* feed_channel_new ();
-FeedChannel* feed_channel_new_from_file (const gchar *path);
+GrssFeedChannel* grss_feed_channel_new ();
+GrssFeedChannel* grss_feed_channel_new_from_file (const gchar *path);
-void feed_channel_set_source (FeedChannel *channel, gchar *source);
-const gchar* feed_channel_get_source (FeedChannel *channel);
-void feed_channel_set_title (FeedChannel *channel, gchar *title);
-const gchar* feed_channel_get_title (FeedChannel *channel);
-void feed_channel_set_homepage (FeedChannel *channel, gchar *homepage);
-const gchar* feed_channel_get_homepage (FeedChannel *channel);
-void feed_channel_set_description (FeedChannel *channel, gchar *description);
-const gchar* feed_channel_get_description (FeedChannel *channel);
-void feed_channel_set_image (FeedChannel *channel, gchar *image);
-const gchar* feed_channel_get_image (FeedChannel *channel);
-void feed_channel_set_icon (FeedChannel *channel, gchar *icon);
-const gchar* feed_channel_get_icon (FeedChannel *channel);
-void feed_channel_set_language (FeedChannel *channel, gchar *language);
-const gchar* feed_channel_get_language (FeedChannel *channel);
-void feed_channel_set_category (FeedChannel *channel, gchar *category);
-const gchar* feed_channel_get_category (FeedChannel *channel);
-void feed_channel_set_pubsubhub (FeedChannel *channel, gchar *hub, gchar *self);
-gboolean feed_channel_get_pubsubhub (FeedChannel *channel, gchar **hub, gchar **self);
+void grss_feed_channel_set_source (GrssFeedChannel *channel, gchar *source);
+const gchar* grss_feed_channel_get_source (GrssFeedChannel *channel);
+void grss_feed_channel_set_title (GrssFeedChannel *channel, gchar *title);
+const gchar* grss_feed_channel_get_title (GrssFeedChannel *channel);
+void grss_feed_channel_set_homepage (GrssFeedChannel *channel, gchar *homepage);
+const gchar* grss_feed_channel_get_homepage (GrssFeedChannel *channel);
+void grss_feed_channel_set_description (GrssFeedChannel *channel, gchar *description);
+const gchar* grss_feed_channel_get_description (GrssFeedChannel *channel);
+void grss_feed_channel_set_image (GrssFeedChannel *channel, gchar *image);
+const gchar* grss_feed_channel_get_image (GrssFeedChannel *channel);
+void grss_feed_channel_set_icon (GrssFeedChannel *channel, gchar *icon);
+const gchar* grss_feed_channel_get_icon (GrssFeedChannel *channel);
+void grss_feed_channel_set_language (GrssFeedChannel *channel, gchar *language);
+const gchar* grss_feed_channel_get_language (GrssFeedChannel *channel);
+void grss_feed_channel_set_category (GrssFeedChannel *channel, gchar *category);
+const gchar* grss_feed_channel_get_category (GrssFeedChannel *channel);
+void grss_feed_channel_set_pubsubhub (GrssFeedChannel *channel, gchar *hub, gchar *self);
+gboolean grss_feed_channel_get_pubsubhub (GrssFeedChannel *channel, gchar **hub, gchar **self);
-void feed_channel_set_copyright (FeedChannel *channel, gchar *copyright);
-const gchar* feed_channel_get_copyright (FeedChannel *channel);
-void feed_channel_set_editor (FeedChannel *channel, gchar *editor);
-const gchar* feed_channel_get_editor (FeedChannel *channel);
-void feed_channel_add_contributor (FeedChannel *channel, gchar *contributor);
-const GList* feed_channel_get_contributors (FeedChannel *channel);
-void feed_channel_set_webmaster (FeedChannel *channel, gchar *webmaster);
-const gchar* feed_channel_get_webmaster (FeedChannel *channel);
-void feed_channel_set_generator (FeedChannel *channel, gchar *generator);
-const gchar* feed_channel_get_generator (FeedChannel *channel);
+void grss_feed_channel_set_copyright (GrssFeedChannel *channel, gchar *copyright);
+const gchar* grss_feed_channel_get_copyright (GrssFeedChannel *channel);
+void grss_feed_channel_set_editor (GrssFeedChannel *channel, gchar *editor);
+const gchar* grss_feed_channel_get_editor (GrssFeedChannel *channel);
+void grss_feed_channel_add_contributor (GrssFeedChannel *channel, gchar *contributor);
+const GList* grss_feed_channel_get_contributors (GrssFeedChannel *channel);
+void grss_feed_channel_set_webmaster (GrssFeedChannel *channel, gchar *webmaster);
+const gchar* grss_feed_channel_get_webmaster (GrssFeedChannel *channel);
+void grss_feed_channel_set_generator (GrssFeedChannel *channel, gchar *generator);
+const gchar* grss_feed_channel_get_generator (GrssFeedChannel *channel);
-void feed_channel_set_publish_time (FeedChannel *channel, time_t publish);
-time_t feed_channel_get_publish_time (FeedChannel *channel);
-void feed_channel_set_update_time (FeedChannel *channel, time_t update);
-time_t feed_channel_get_update_time (FeedChannel *channel);
-void feed_channel_set_update_interval (FeedChannel *channel, int minutes);
-int feed_channel_get_update_interval (FeedChannel *channel);
+void grss_feed_channel_set_publish_time (GrssFeedChannel *channel, time_t publish);
+time_t grss_feed_channel_get_publish_time (GrssFeedChannel *channel);
+void grss_feed_channel_set_update_time (GrssFeedChannel *channel, time_t update);
+time_t grss_feed_channel_get_update_time (GrssFeedChannel *channel);
+void grss_feed_channel_set_update_interval (GrssFeedChannel *channel, int minutes);
+int grss_feed_channel_get_update_interval (GrssFeedChannel *channel);
-gboolean feed_channel_fetch (FeedChannel *channel);
-void feed_channel_fetch_async (FeedChannel *channel, GAsyncReadyCallback callback, gpointer user_data);
+gboolean grss_feed_channel_fetch (GrssFeedChannel *channel);
+void grss_feed_channel_fetch_async (GrssFeedChannel *channel, GAsyncReadyCallback callback, gpointer user_data);
#endif /* __FEED_CHANNEL_H__ */
diff --git a/src/feed-enclosure.c b/src/feed-enclosure.c
index 02d3891..c666cea 100644
--- a/src/feed-enclosure.c
+++ b/src/feed-enclosure.c
@@ -21,61 +21,61 @@
#include "utils.h"
#include "feed-enclosure.h"
-#define FEED_ENCLOSURE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), FEED_ENCLOSURE_TYPE, FeedEnclosurePrivate))
+#define FEED_ENCLOSURE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), FEED_ENCLOSURE_TYPE, GrssFeedEnclosurePrivate))
/**
* SECTION: feed-enclosure
* @short_description: a component attached to an item
*
- * #FeedEnclosure describes an external element embedded into a #FeedItem: it
+ * #GrssFeedEnclosure describes an external element embedded into a #GrssFeedItem: it
* may be an image, a video of other kind of file to be presented with the
* parent item
*/
-struct _FeedEnclosurePrivate {
+struct _GrssFeedEnclosurePrivate {
gchar *url;
gchar *type;
gsize length;
};
-G_DEFINE_TYPE (FeedEnclosure, feed_enclosure, G_TYPE_OBJECT);
+G_DEFINE_TYPE (GrssFeedEnclosure, grss_feed_enclosure, G_TYPE_OBJECT);
-static void feed_enclosure_finalize (GObject *obj)
+static void grss_feed_enclosure_finalize (GObject *obj)
{
- FeedEnclosure *enclosure;
+ GrssFeedEnclosure *enclosure;
enclosure = FEED_ENCLOSURE (obj);
FREE_STRING (enclosure->priv->url);
FREE_STRING (enclosure->priv->type);
}
-static void feed_enclosure_class_init (FeedEnclosureClass *klass)
+static void grss_feed_enclosure_class_init (GrssFeedEnclosureClass *klass)
{
GObjectClass *gobject_class;
- g_type_class_add_private (klass, sizeof (FeedEnclosurePrivate));
+ g_type_class_add_private (klass, sizeof (GrssFeedEnclosurePrivate));
gobject_class = G_OBJECT_CLASS (klass);
- gobject_class->finalize = feed_enclosure_finalize;
+ gobject_class->finalize = grss_feed_enclosure_finalize;
}
-static void feed_enclosure_init (FeedEnclosure *node)
+static void grss_feed_enclosure_init (GrssFeedEnclosure *node)
{
node->priv = FEED_ENCLOSURE_GET_PRIVATE (node);
- memset (node->priv, 0, sizeof (FeedEnclosurePrivate));
+ memset (node->priv, 0, sizeof (GrssFeedEnclosurePrivate));
}
/**
- * feed_enclosure_new:
+ * grss_feed_enclosure_new:
* @url: URL of the external element
*
- * Allocates a new #FeedEnclosure, to be downloaded separately
+ * Allocates a new #GrssFeedEnclosure, to be downloaded separately
*
- * Return value: a new #FeedEnclosure
+ * Return value: a new #GrssFeedEnclosure
*/
-FeedEnclosure* feed_enclosure_new (gchar *url)
+GrssFeedEnclosure* grss_feed_enclosure_new (gchar *url)
{
- FeedEnclosure *ret;
+ GrssFeedEnclosure *ret;
ret = g_object_new (FEED_ENCLOSURE_TYPE, NULL);
ret->priv->url = g_strdup (url);
@@ -83,65 +83,65 @@ FeedEnclosure* feed_enclosure_new (gchar *url)
}
/**
- * feed_enclosure_get_url:
- * @enclosure: a #FeedEnclosure
+ * grss_feed_enclosure_get_url:
+ * @enclosure: a #GrssFeedEnclosure
*
* Retrieves the URL of the @enclosure
*
* Return value: the URL where the enclosure may be found
*/
-const gchar* feed_enclosure_get_url (FeedEnclosure *enclosure)
+const gchar* grss_feed_enclosure_get_url (GrssFeedEnclosure *enclosure)
{
return (const gchar*) enclosure->priv->url;
}
/**
- * feed_enclosure_set_format:
- * @enclosure: a #FeedEnclosure
+ * grss_feed_enclosure_set_format:
+ * @enclosure: a #GrssFeedEnclosure
* @type: type of content
*
* To set the type of the external file
*/
-void feed_enclosure_set_format (FeedEnclosure *enclosure, gchar *type)
+void grss_feed_enclosure_set_format (GrssFeedEnclosure *enclosure, gchar *type)
{
FREE_STRING (enclosure->priv->type);
enclosure->priv->type = g_strdup (type);
}
/**
- * feed_enclosure_get_format:
- * @enclosure: a #FeedEnclosure
+ * grss_feed_enclosure_get_format:
+ * @enclosure: a #GrssFeedEnclosure
*
* Retrieves the format of the enclosed file
*
* Return value: type of @enclosure
*/
-const gchar* feed_enclosure_get_format (FeedEnclosure *enclosure)
+const gchar* grss_feed_enclosure_get_format (GrssFeedEnclosure *enclosure)
{
return (const gchar*) enclosure->priv->type;
}
/**
- * feed_enclosure_set_length:
- * @enclosure: a #FeedEnclosure
- * @length: size of the enclosure
+ * grss_feed_enclosure_set_length:
+ * @enclosure: a #GrssFeedEnclosure
+ * @length: size of the enclosure, in bytes
*
* To set the size of the embedded @enclosure
*/
-void feed_enclosure_set_length (FeedEnclosure *enclosure, gsize length)
+void grss_feed_enclosure_set_length (GrssFeedEnclosure *enclosure, gsize length)
{
enclosure->priv->length = length;
}
/**
- * feed_enclosure_get_length:
- * @enclosure: a #FeedEnclosure
+ * grss_feed_enclosure_get_length:
+ * @enclosure: a #GrssFeedEnclosure
*
* Retrieves the size of the embedded file
*
- * Return value: size of the @enclosure
+ * Return value: size of the @enclosure, in bytes
*/
-gsize feed_enclosure_get_length (FeedEnclosure *enclosure)
+gsize grss_feed_enclosure_get_length (GrssFeedEnclosure *enclosure)
{
return enclosure->priv->length;
}
diff --git a/src/feed-enclosure.h b/src/feed-enclosure.h
index 990143d..d928259 100644
--- a/src/feed-enclosure.h
+++ b/src/feed-enclosure.h
@@ -23,33 +23,33 @@
#include "libgrss.h"
-#define FEED_ENCLOSURE_TYPE (feed_enclosure_get_type())
-#define FEED_ENCLOSURE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FEED_ENCLOSURE_TYPE, FeedEnclosure))
-#define FEED_ENCLOSURE_CLASS(c) (G_TYPE_CHECK_CLASS_CAST ((c), FEED_ENCLOSURE_TYPE, FeedEnclosureClass))
+#define FEED_ENCLOSURE_TYPE (grss_feed_enclosure_get_type())
+#define FEED_ENCLOSURE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FEED_ENCLOSURE_TYPE, GrssFeedEnclosure))
+#define FEED_ENCLOSURE_CLASS(c) (G_TYPE_CHECK_CLASS_CAST ((c), FEED_ENCLOSURE_TYPE, GrssFeedEnclosureClass))
#define IS_FEED_ENCLOSURE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FEED_ENCLOSURE_TYPE))
#define IS_FEED_ENCLOSURE_CLASS(c) (G_TYPE_CHECK_CLASS_TYPE ((c), FEED_ENCLOSURE_TYPE))
-#define FEED_ENCLOSURE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FEED_ENCLOSURE_TYPE, FeedEnclosureClass))
+#define FEED_ENCLOSURE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FEED_ENCLOSURE_TYPE, GrssFeedEnclosureClass))
-typedef struct _FeedEnclosure FeedEnclosure;
-typedef struct _FeedEnclosurePrivate FeedEnclosurePrivate;
+typedef struct _GrssFeedEnclosure GrssFeedEnclosure;
+typedef struct _GrssFeedEnclosurePrivate GrssFeedEnclosurePrivate;
-struct _FeedEnclosure {
+struct _GrssFeedEnclosure {
GObject parent;
- FeedEnclosurePrivate *priv;
+ GrssFeedEnclosurePrivate *priv;
};
typedef struct {
GObjectClass parent;
-} FeedEnclosureClass;
+} GrssFeedEnclosureClass;
-GType feed_enclosure_get_type (void) G_GNUC_CONST;
+GType grss_feed_enclosure_get_type (void) G_GNUC_CONST;
-FeedEnclosure* feed_enclosure_new (gchar *url);
+GrssFeedEnclosure* grss_feed_enclosure_new (gchar *url);
-const gchar* feed_enclosure_get_url (FeedEnclosure *enclosure);
-void feed_enclosure_set_format (FeedEnclosure *enclosure, gchar *type);
-const gchar* feed_enclosure_get_format (FeedEnclosure *enclosure);
-void feed_enclosure_set_length (FeedEnclosure *enclosure, gsize length);
-gsize feed_enclosure_get_length (FeedEnclosure *enclosure);
+const gchar* grss_feed_enclosure_get_url (GrssFeedEnclosure *enclosure);
+void grss_feed_enclosure_set_format (GrssFeedEnclosure *enclosure, gchar *type);
+const gchar* grss_feed_enclosure_get_format (GrssFeedEnclosure *enclosure);
+void grss_feed_enclosure_set_length (GrssFeedEnclosure *enclosure, gsize length);
+gsize grss_feed_enclosure_get_length (GrssFeedEnclosure *enclosure);
#endif /* __FEED_ENCLOSURE_H__ */
diff --git a/src/feed-handler.c b/src/feed-handler.c
index 2772b12..6b8c5a3 100644
--- a/src/feed-handler.c
+++ b/src/feed-handler.c
@@ -99,11 +99,11 @@ feed_handler_check_format (FeedHandler *self, xmlDocPtr doc, xmlNodePtr cur)
* Parses the given @doc (obtained fetching @feed) and extracts a list of
* items
*
- * Return value: a list of #FeedItem, to be freed when no longer in use, or
+ * Return value: a list of #GrssFeedItem, to be freed when no longer in use, or
* %NULL if an error occours (and @error is set accordly)
*/
GList*
-feed_handler_parse (FeedHandler *self, FeedChannel *feed, xmlDocPtr doc, GError **error)
+feed_handler_parse (FeedHandler *self, GrssFeedChannel *feed, xmlDocPtr doc, GError **error)
{
if (IS_FEED_HANDLER (self) == FALSE)
return FALSE;
diff --git a/src/feed-handler.h b/src/feed-handler.h
index 173d86b..0f9708e 100644
--- a/src/feed-handler.h
+++ b/src/feed-handler.h
@@ -37,13 +37,13 @@ struct _FeedHandlerInterface {
void (*set_ns_handler) (FeedHandler *self, NSHandler *handler);
gboolean (*check_format) (FeedHandler *self, xmlDocPtr doc, xmlNodePtr cur);
- GList* (*parse) (FeedHandler *self, FeedChannel *feed, xmlDocPtr doc, GError **error);
+ GList* (*parse) (FeedHandler *self, GrssFeedChannel *feed, xmlDocPtr doc, GError **error);
};
GType feed_handler_get_type ();
void feed_handler_set_ns_handler (FeedHandler *self, NSHandler *handler);
gboolean feed_handler_check_format (FeedHandler *self, xmlDocPtr doc, xmlNodePtr cur);
-GList* feed_handler_parse (FeedHandler *self, FeedChannel *feed, xmlDocPtr doc, GError **error);
+GList* feed_handler_parse (FeedHandler *self, GrssFeedChannel *feed, xmlDocPtr doc, GError **error);
#endif /* __FEED_HANDLER_H__ */
diff --git a/src/feed-item.c b/src/feed-item.c
index c3aa1b7..59e3c6d 100644
--- a/src/feed-item.c
+++ b/src/feed-item.c
@@ -22,13 +22,13 @@
#include "feed-item.h"
#include "feed-channel.h"
-#define FEED_ITEM_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), FEED_ITEM_TYPE, FeedItemPrivate))
+#define FEED_ITEM_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), FEED_ITEM_TYPE, GrssFeedItemPrivate))
/**
* SECTION: feed-item
* @short_description: a feed item
*
- * #FeedItem is an abstraction for an item, collects all information about a
+ * #GrssFeedItem is an abstraction for an item, collects all information about a
* single element found into a feed
*/
@@ -41,8 +41,8 @@ typedef struct {
double lon;
} GeoInfo;
-struct _FeedItemPrivate {
- FeedChannel *parent;
+struct _GrssFeedItemPrivate {
+ GrssFeedChannel *parent;
gchar *id;
gchar *title;
@@ -64,13 +64,13 @@ struct _FeedItemPrivate {
GList *enclosures;
};
-G_DEFINE_TYPE (FeedItem, feed_item, G_TYPE_OBJECT);
+G_DEFINE_TYPE (GrssFeedItem, grss_feed_item, G_TYPE_OBJECT);
static void
-feed_item_finalize (GObject *obj)
+grss_feed_item_finalize (GObject *obj)
{
GList *iter;
- FeedItem *item;
+ GrssFeedItem *item;
item = FEED_ITEM (obj);
FREE_STRING (item->priv->id);
@@ -104,35 +104,35 @@ feed_item_finalize (GObject *obj)
}
static void
-feed_item_class_init (FeedItemClass *klass)
+grss_feed_item_class_init (GrssFeedItemClass *klass)
{
GObjectClass *gobject_class;
- g_type_class_add_private (klass, sizeof (FeedItemPrivate));
+ g_type_class_add_private (klass, sizeof (GrssFeedItemPrivate));
gobject_class = G_OBJECT_CLASS (klass);
- gobject_class->finalize = feed_item_finalize;
+ gobject_class->finalize = grss_feed_item_finalize;
}
static void
-feed_item_init (FeedItem *node)
+grss_feed_item_init (GrssFeedItem *node)
{
node->priv = FEED_ITEM_GET_PRIVATE (node);
- memset (node->priv, 0, sizeof (FeedItemPrivate));
+ memset (node->priv, 0, sizeof (GrssFeedItemPrivate));
}
/**
- * feed_item_new:
+ * grss_feed_item_new:
* @parent: the feed from which the new item belongs
*
- * To allocate a new empty #FeedItem
+ * To allocate a new empty #GrssFeedItem
*
- * Return value: a new #FeedItem
+ * Return value: a new #GrssFeedItem
*/
-FeedItem*
-feed_item_new (FeedChannel *parent)
+GrssFeedItem*
+grss_feed_item_new (GrssFeedChannel *parent)
{
- FeedItem *item;
+ GrssFeedItem *item;
item = FEED_ITEM (g_object_new (FEED_ITEM_TYPE, NULL));
item->priv->parent = parent;
@@ -141,29 +141,29 @@ feed_item_new (FeedChannel *parent)
}
/**
- * feed_item_get_parent:
- * @item: a #FeedItem
+ * grss_feed_item_get_parent:
+ * @item: a #GrssFeedItem
*
* Retrieves the feed from which the item belongs
*
- * Return value: the parent feed, as set in feed_item_new()
+ * Return value: the parent feed, as set in grss_feed_item_new()
*/
-FeedChannel*
-feed_item_get_parent (FeedItem *item)
+GrssFeedChannel*
+grss_feed_item_get_parent (GrssFeedItem *item)
{
return item->priv->parent;
}
/**
- * feed_item_set_id:
- * @item: a #FeedItem
+ * grss_feed_item_set_id:
+ * @item: a #GrssFeedItem
* @id: the new ID to set
*
* To set the ID of the @item. This parameter has not a particular format: it
* is just a string used to identify in unique way the item
*/
void
-feed_item_set_id (FeedItem *item, gchar *id)
+grss_feed_item_set_id (GrssFeedItem *item, gchar *id)
{
gchar *iter;
@@ -180,91 +180,91 @@ feed_item_set_id (FeedItem *item, gchar *id)
}
/**
- * feed_item_get_id:
- * @item: #FeedItem from which retrieve the ID
+ * grss_feed_item_get_id:
+ * @item: #GrssFeedItem from which retrieve the ID
*
* Retrieves the ID assigned to the @item. If no ID was set with
- * feed_item_set_id() this returns the same of feed_item_get_source().
+ * grss_feed_item_set_id() this returns the same of grss_feed_item_get_source().
* Pay attention to the fact this library do not check uniqueness of assigned
* IDs
*
* Return value: ID of the item
*/
const gchar*
-feed_item_get_id (FeedItem *item)
+grss_feed_item_get_id (GrssFeedItem *item)
{
if (item->priv->id != NULL)
return (const gchar*) item->priv->id;
else
- return feed_item_get_source (item);
+ return grss_feed_item_get_source (item);
}
/**
- * feed_item_set_title:
- * @item: a #FeedItem
+ * grss_feed_item_set_title:
+ * @item: a #GrssFeedItem
* @title: title of the item
*
* To set a title to the @item
*/
void
-feed_item_set_title (FeedItem *item, gchar *title)
+grss_feed_item_set_title (GrssFeedItem *item, gchar *title)
{
FREE_STRING (item->priv->title);
item->priv->title = g_strdup (title);
}
/**
- * feed_item_get_title:
- * @item: a #FeedItem
+ * grss_feed_item_get_title:
+ * @item: a #GrssFeedItem
*
* Retrieves the title assigned to @item
*
* Return value: title of the element
*/
const gchar*
-feed_item_get_title (FeedItem *item)
+grss_feed_item_get_title (GrssFeedItem *item)
{
return (const gchar*) item->priv->title;
}
/**
- * feed_item_set_description:
- * @item: a #FeedItem
+ * grss_feed_item_set_description:
+ * @item: a #GrssFeedItem
* @description: content of the item
*
* To set the description of @item. Usually "description" means his content
*/
void
-feed_item_set_description (FeedItem *item, gchar *description)
+grss_feed_item_set_description (GrssFeedItem *item, gchar *description)
{
FREE_STRING (item->priv->description);
item->priv->description = g_strdup (description);
}
/**
- * feed_item_get_description:
- * @item: a #FeedItem
+ * grss_feed_item_get_description:
+ * @item: a #GrssFeedItem
*
* Retrieves the description of the @item
*
* Return value: description of @item
*/
const gchar*
-feed_item_get_description (FeedItem *item)
+grss_feed_item_get_description (GrssFeedItem *item)
{
return (const gchar*) item->priv->description;
}
/**
- * feed_item_add_category:
- * @item: a #FeedItem
+ * grss_feed_item_add_category:
+ * @item: a #GrssFeedItem
* @category: a new category to assign to the item
*
* Adds a category to the @item. The complete list can be obtained with
- * feed_item_get_categories()
+ * grss_feed_item_get_categories()
*/
void
-feed_item_add_category (FeedItem *item, gchar *category)
+grss_feed_item_add_category (GrssFeedItem *item, gchar *category)
{
gchar *cat;
@@ -277,8 +277,8 @@ feed_item_add_category (FeedItem *item, gchar *category)
}
/**
- * feed_item_get_categories:
- * @item: a #FeedItem
+ * grss_feed_item_get_categories:
+ * @item: a #GrssFeedItem
*
* Retrieves list of categories assigned to the @item
*
@@ -286,42 +286,42 @@ feed_item_add_category (FeedItem *item, gchar *category)
* modify this list
*/
const GList*
-feed_item_get_categories (FeedItem *item)
+grss_feed_item_get_categories (GrssFeedItem *item)
{
return (const GList*) item->priv->categories;
}
/**
- * feed_item_set_source:
- * @item: a #FeedItem
+ * grss_feed_item_set_source:
+ * @item: a #GrssFeedItem
* @source: URL of the item
*
* To set the source of the @item
*/
void
-feed_item_set_source (FeedItem *item, gchar *source)
+grss_feed_item_set_source (GrssFeedItem *item, gchar *source)
{
FREE_STRING (item->priv->source);
item->priv->source = g_strdup (source);
}
/**
- * feed_item_get_source:
- * @item: a #FeedItem
+ * grss_feed_item_get_source:
+ * @item: a #GrssFeedItem
*
* Retrieves the URL where the @item can be found
*
* Return value: URL of the item, or NULL
*/
const gchar*
-feed_item_get_source (FeedItem *item)
+grss_feed_item_get_source (GrssFeedItem *item)
{
return (const gchar*) item->priv->source;
}
/**
- * feed_item_set_real_source:
- * @item: a #FeedItem
+ * grss_feed_item_set_real_source:
+ * @item: a #GrssFeedItem
* @realsource: URL of the real source for the item
* @title: title of the real source
*
@@ -329,7 +329,7 @@ feed_item_get_source (FeedItem *item)
* aggregators to explicit the origin of a content reproduced in them
*/
void
-feed_item_set_real_source (FeedItem *item, gchar *realsource, gchar *title)
+grss_feed_item_set_real_source (GrssFeedItem *item, gchar *realsource, gchar *title)
{
FREE_STRING (item->priv->real_source_url);
item->priv->real_source_url = g_strdup (realsource);
@@ -338,15 +338,15 @@ feed_item_set_real_source (FeedItem *item, gchar *realsource, gchar *title)
}
/**
- * feed_item_get_real_source:
- * @item: a #FeedItem
+ * grss_feed_item_get_real_source:
+ * @item: a #GrssFeedItem
* @realsource: will be assigned to the URL of the real source, or NULL
* @title: will be assigned to the title of the real source, or NULL
*
* Retrieves references to the real source of @item
*/
void
-feed_item_get_real_source (FeedItem *item, const gchar **realsource, const gchar **title)
+grss_feed_item_get_real_source (GrssFeedItem *item, const gchar **realsource, const gchar **title)
{
if (realsource != NULL)
*realsource = item->priv->real_source_url;
@@ -355,98 +355,98 @@ feed_item_get_real_source (FeedItem *item, const gchar **realsource, const gchar
}
/**
- * feed_item_set_related:
- * @item: a #FeedItem
+ * grss_feed_item_set_related:
+ * @item: a #GrssFeedItem
* @related: reference to a related post
*
* To set reference to a post related to @item
*/
void
-feed_item_set_related (FeedItem *item, gchar *related)
+grss_feed_item_set_related (GrssFeedItem *item, gchar *related)
{
FREE_STRING (item->priv->related);
item->priv->related = g_strdup (related);
}
/**
- * feed_item_get_related:
- * @item: a #FeedItem
+ * grss_feed_item_get_related:
+ * @item: a #GrssFeedItem
*
* Retrieves indication about posts related to @item
*
* Return value: related posts, or NULL
*/
const gchar*
-feed_item_get_related (FeedItem *item)
+grss_feed_item_get_related (GrssFeedItem *item)
{
return (const gchar*) item->priv->related;
}
/**
- * feed_item_set_copyright:
- * @item: a #FeedItem
+ * grss_feed_item_set_copyright:
+ * @item: a #GrssFeedItem
* @copyright: copyright declaration for the item
*
* To set a copyright reference to @item
*/
void
-feed_item_set_copyright (FeedItem *item, gchar *copyright)
+grss_feed_item_set_copyright (GrssFeedItem *item, gchar *copyright)
{
FREE_STRING (item->priv->copyright);
item->priv->copyright = g_strdup (copyright);
}
/**
- * feed_item_get_copyright:
- * @item: a #FeedItem
+ * grss_feed_item_get_copyright:
+ * @item: a #GrssFeedItem
*
* Retrieves copyright reference for the @item
*
* Return value: copyright mark, or NULL
*/
const gchar*
-feed_item_get_copyright (FeedItem *item)
+grss_feed_item_get_copyright (GrssFeedItem *item)
{
return (const gchar*) item->priv->copyright;
}
/**
- * feed_item_set_author:
- * @item: a #FeedItem
+ * grss_feed_item_set_author:
+ * @item: a #GrssFeedItem
* @author: name of the author
*
* To assign an author to the @item
*/
void
-feed_item_set_author (FeedItem *item, gchar *author)
+grss_feed_item_set_author (GrssFeedItem *item, gchar *author)
{
FREE_STRING (item->priv->author);
item->priv->author = g_strdup (author);
}
/**
- * feed_item_get_author:
- * @item: a #FeedItem
+ * grss_feed_item_get_author:
+ * @item: a #GrssFeedItem
*
* Retrieves the author of @item
*
* Return value: author of the item, or NULL
*/
const gchar*
-feed_item_get_author (FeedItem *item)
+grss_feed_item_get_author (GrssFeedItem *item)
{
return (const gchar*) item->priv->author;
}
/**
- * feed_item_add_contributor:
- * @item: a #FeedItem
+ * grss_feed_item_add_contributor:
+ * @item: a #GrssFeedItem
* @contributor: name of the contributor for the item
*
* To add a contributor to the @item
*/
void
-feed_item_add_contributor (FeedItem *item, gchar *contributor)
+grss_feed_item_add_contributor (GrssFeedItem *item, gchar *contributor)
{
gchar *con;
@@ -459,50 +459,50 @@ feed_item_add_contributor (FeedItem *item, gchar *contributor)
}
/**
- * feed_item_get_contributors:
- * @item: a #FeedItem
+ * grss_feed_item_get_contributors:
+ * @item: a #GrssFeedItem
*
* Retrieves contributors for @item
*
* Return value: list of contributors to the item
*/
const GList*
-feed_item_get_contributors (FeedItem *item)
+grss_feed_item_get_contributors (GrssFeedItem *item)
{
return (const GList*) item->priv->contributors;
}
/**
- * feed_item_set_comments_url:
- * @item: a #FeedItem
+ * grss_feed_item_set_comments_url:
+ * @item: a #GrssFeedItem
* @url: URL where to retrieve comments to the item
*
* To assign the URL where to fetch comments for the item
*/
void
-feed_item_set_comments_url (FeedItem *item, gchar *url)
+grss_feed_item_set_comments_url (GrssFeedItem *item, gchar *url)
{
FREE_STRING (item->priv->comments_url);
item->priv->comments_url = g_strdup (url);
}
/**
- * feed_item_get_comments_url:
- * @item: a #FeedItem
+ * grss_feed_item_get_comments_url:
+ * @item: a #GrssFeedItem
*
* Retrieves the URL where to catch comments to the @item
*
* Return value: URL to parse to read comments for @item, or NULL
*/
const gchar*
-feed_item_get_comments_url (FeedItem *item)
+grss_feed_item_get_comments_url (GrssFeedItem *item)
{
return (const gchar*) item->priv->comments_url;
}
/**
- * feed_item_set_geo_point:
- * @item: a #FeedItem
+ * grss_feed_item_set_geo_point:
+ * @item: a #GrssFeedItem
* @latitude: latitude of the point, or -1 to leave the previous one
* @longitude: longitude of the point, or -1 to leave the previous one
*
@@ -512,7 +512,7 @@ feed_item_get_comments_url (FeedItem *item)
* single step. If both are -1, nothing happens
*/
void
-feed_item_set_geo_point (FeedItem *item, double latitude, double longitude)
+grss_feed_item_set_geo_point (GrssFeedItem *item, double latitude, double longitude)
{
if (latitude == -1 && longitude == -1)
return;
@@ -527,8 +527,8 @@ feed_item_set_geo_point (FeedItem *item, double latitude, double longitude)
}
/**
- * feed_item_get_geo_point:
- * @item: a #FeedItem
+ * grss_feed_item_get_geo_point:
+ * @item: a #GrssFeedItem
* @latitude: will be assigned to the latitude of the point, or NULL
* @longitude: will be assigned to the longitude of the point, or NULL
*
@@ -539,7 +539,7 @@ feed_item_set_geo_point (FeedItem *item, double latitude, double longitude)
* reference
*/
gboolean
-feed_item_get_geo_point (FeedItem *item, double *latitude, double *longitude)
+grss_feed_item_get_geo_point (GrssFeedItem *item, double *latitude, double *longitude)
{
if (latitude)
*latitude = item->priv->geo.lat;
@@ -550,45 +550,45 @@ feed_item_get_geo_point (FeedItem *item, double *latitude, double *longitude)
}
/**
- * feed_item_set_publish_time:
- * @item: a #FeedItem
+ * grss_feed_item_set_publish_time:
+ * @item: a #GrssFeedItem
* @publish: publishing timestamp of the item
*
* To set the publish time of the item
*/
void
-feed_item_set_publish_time (FeedItem *item, time_t publish)
+grss_feed_item_set_publish_time (GrssFeedItem *item, time_t publish)
{
item->priv->pub_time = publish;
}
/**
- * feed_item_get_publish_time:
- * @item: a #FeedItem
+ * grss_feed_item_get_publish_time:
+ * @item: a #GrssFeedItem
*
* Retrieves the publish time of the item. By default this value is the
- * current timestamp assigned when creating the #FeedItem, and may be changed
- * with feed_item_set_publish_time()
+ * current timestamp assigned when creating the #GrssFeedItem, and may be changed
+ * with grss_feed_item_set_publish_time()
*
* Return value: publish time of @item
*/
time_t
-feed_item_get_publish_time (FeedItem *item)
+grss_feed_item_get_publish_time (GrssFeedItem *item)
{
return item->priv->pub_time;
}
/**
- * feed_item_add_enclosure:
- * @item: a #FeedItem
- * @enclosure: a #FeedEnclosure to add to the item
+ * grss_feed_item_add_enclosure:
+ * @item: a #GrssFeedItem
+ * @enclosure: a #GrssFeedEnclosure to add to the item
*
* Adds an enclosure to the @item. That external elements may be references
* to images, videos, or other contents (usually multimedial) embedded in the
* element
*/
void
-feed_item_add_enclosure (FeedItem *item, FeedEnclosure *enclosure)
+grss_feed_item_add_enclosure (GrssFeedItem *item, GrssFeedEnclosure *enclosure)
{
if (item->priv->enclosures == NULL)
item->priv->enclosures = g_list_prepend (item->priv->enclosures, enclosure);
@@ -597,16 +597,16 @@ feed_item_add_enclosure (FeedItem *item, FeedEnclosure *enclosure)
}
/**
- * feed_item_get_enclosures:
- * @item: a #FeedItem
+ * grss_feed_item_get_enclosures:
+ * @item: a #GrssFeedItem
*
- * Retrieves the list of enclosures added with feed_item_add_enclosure()
+ * Retrieves the list of enclosures added with grss_feed_item_add_enclosure()
*
- * Return value: a list of #FeedEnclosure. This is a direct reference to the
+ * Return value: a list of #GrssFeedEnclosure. This is a direct reference to the
* internal list, do not free or modify it
*/
const GList*
-feed_item_get_enclosures (FeedItem *item)
+grss_feed_item_get_enclosures (GrssFeedItem *item)
{
return item->priv->enclosures;
}
diff --git a/src/feed-item.h b/src/feed-item.h
index 298b853..7a4e06d 100644
--- a/src/feed-item.h
+++ b/src/feed-item.h
@@ -23,61 +23,61 @@
#include "libgrss.h"
-#define FEED_ITEM_TYPE (feed_item_get_type())
-#define FEED_ITEM(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FEED_ITEM_TYPE, FeedItem))
-#define FEED_ITEM_CLASS(c) (G_TYPE_CHECK_CLASS_CAST ((c), FEED_ITEM_TYPE, FeedItemClass))
+#define FEED_ITEM_TYPE (grss_feed_item_get_type())
+#define FEED_ITEM(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FEED_ITEM_TYPE, GrssFeedItem))
+#define FEED_ITEM_CLASS(c) (G_TYPE_CHECK_CLASS_CAST ((c), FEED_ITEM_TYPE, GrssFeedItemClass))
#define IS_FEED_ITEM(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FEED_ITEM_TYPE))
#define IS_FEED_ITEM_CLASS(c) (G_TYPE_CHECK_CLASS_TYPE ((c), FEED_ITEM_TYPE))
-#define FEED_ITEM_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FEED_ITEM_TYPE, FeedItemClass))
+#define FEED_ITEM_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FEED_ITEM_TYPE, GrssFeedItemClass))
-typedef struct _FeedItem FeedItem;
-typedef struct _FeedItemPrivate FeedItemPrivate;
+typedef struct _GrssFeedItem GrssFeedItem;
+typedef struct _GrssFeedItemPrivate GrssFeedItemPrivate;
-struct _FeedItem {
+struct _GrssFeedItem {
GObject parent;
- FeedItemPrivate *priv;
+ GrssFeedItemPrivate *priv;
};
typedef struct {
GObjectClass parent;
-} FeedItemClass;
+} GrssFeedItemClass;
-GType feed_item_get_type () G_GNUC_CONST;
+GType grss_feed_item_get_type () G_GNUC_CONST;
-FeedItem* feed_item_new (FeedChannel *parent);
+GrssFeedItem* grss_feed_item_new (GrssFeedChannel *parent);
-FeedChannel* feed_item_get_parent (FeedItem *item);
+GrssFeedChannel* grss_feed_item_get_parent (GrssFeedItem *item);
-void feed_item_set_id (FeedItem *item, gchar *id);
-const gchar* feed_item_get_id (FeedItem *item);
-void feed_item_set_title (FeedItem *item, gchar *title);
-const gchar* feed_item_get_title (FeedItem *item);
-void feed_item_set_description (FeedItem *item, gchar *description);
-const gchar* feed_item_get_description (FeedItem *item);
-void feed_item_add_category (FeedItem *item, gchar *category);
-const GList* feed_item_get_categories (FeedItem *item);
-void feed_item_set_source (FeedItem *item, gchar *source);
-const gchar* feed_item_get_source (FeedItem *item);
-void feed_item_set_real_source (FeedItem *item, gchar *realsource, gchar *title);
-void feed_item_get_real_source (FeedItem *item, const gchar **realsource, const gchar **title);
-void feed_item_set_related (FeedItem *item, gchar *related);
-const gchar* feed_item_get_related (FeedItem *item);
+void grss_feed_item_set_id (GrssFeedItem *item, gchar *id);
+const gchar* grss_feed_item_get_id (GrssFeedItem *item);
+void grss_feed_item_set_title (GrssFeedItem *item, gchar *title);
+const gchar* grss_feed_item_get_title (GrssFeedItem *item);
+void grss_feed_item_set_description (GrssFeedItem *item, gchar *description);
+const gchar* grss_feed_item_get_description (GrssFeedItem *item);
+void grss_feed_item_add_category (GrssFeedItem *item, gchar *category);
+const GList* grss_feed_item_get_categories (GrssFeedItem *item);
+void grss_feed_item_set_source (GrssFeedItem *item, gchar *source);
+const gchar* grss_feed_item_get_source (GrssFeedItem *item);
+void grss_feed_item_set_real_source (GrssFeedItem *item, gchar *realsource, gchar *title);
+void grss_feed_item_get_real_source (GrssFeedItem *item, const gchar **realsource, const gchar **title);
+void grss_feed_item_set_related (GrssFeedItem *item, gchar *related);
+const gchar* grss_feed_item_get_related (GrssFeedItem *item);
-void feed_item_set_copyright (FeedItem *item, gchar *copyright);
-const gchar* feed_item_get_copyright (FeedItem *item);
-void feed_item_set_author (FeedItem *item, gchar *author);
-const gchar* feed_item_get_author (FeedItem *item);
-void feed_item_add_contributor (FeedItem *item, gchar *contributor);
-const GList* feed_item_get_contributors (FeedItem *item);
-void feed_item_set_comments_url (FeedItem *item, gchar *url);
-const gchar* feed_item_get_comments_url (FeedItem *item);
+void grss_feed_item_set_copyright (GrssFeedItem *item, gchar *copyright);
+const gchar* grss_feed_item_get_copyright (GrssFeedItem *item);
+void grss_feed_item_set_author (GrssFeedItem *item, gchar *author);
+const gchar* grss_feed_item_get_author (GrssFeedItem *item);
+void grss_feed_item_add_contributor (GrssFeedItem *item, gchar *contributor);
+const GList* grss_feed_item_get_contributors (GrssFeedItem *item);
+void grss_feed_item_set_comments_url (GrssFeedItem *item, gchar *url);
+const gchar* grss_feed_item_get_comments_url (GrssFeedItem *item);
-void feed_item_set_geo_point (FeedItem *item, double latitude, double longitude);
-gboolean feed_item_get_geo_point (FeedItem *item, double *latitude, double *longitude);
-void feed_item_set_publish_time (FeedItem *item, time_t publish);
-time_t feed_item_get_publish_time (FeedItem *item);
+void grss_feed_item_set_geo_point (GrssFeedItem *item, double latitude, double longitude);
+gboolean grss_feed_item_get_geo_point (GrssFeedItem *item, double *latitude, double *longitude);
+void grss_feed_item_set_publish_time (GrssFeedItem *item, time_t publish);
+time_t grss_feed_item_get_publish_time (GrssFeedItem *item);
-void feed_item_add_enclosure (FeedItem *item, FeedEnclosure *enclosure);
-const GList* feed_item_get_enclosures (FeedItem *item);
+void grss_feed_item_add_enclosure (GrssFeedItem *item, GrssFeedEnclosure *enclosure);
+const GList* grss_feed_item_get_enclosures (GrssFeedItem *item);
#endif /* __FEED_ITEM_H__ */
diff --git a/src/feed-parser.c b/src/feed-parser.c
index bb692dd..d6a908b 100644
--- a/src/feed-parser.c
+++ b/src/feed-parser.c
@@ -33,19 +33,19 @@
#include "feed-atom-handler.h"
#include "feed-pie-handler.h"
-#define FEED_PARSER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), FEED_PARSER_TYPE, FeedParserPrivate))
+#define FEED_PARSER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), FEED_PARSER_TYPE, GrssFeedParserPrivate))
/**
* SECTION: feed-parser
* @short_description: feed parser
*
- * The #FeedParser is a wrapper to the many handlers available: given a
- * #FeedChannel provides to identify his type and invoke the correct parser.
+ * The #GrssFeedParser is a wrapper to the many handlers available: given a
+ * #GrssFeedChannel provides to identify his type and invoke the correct parser.
*/
-#define FEED_PARSER_ERROR feed_parser_error_quark()
+#define FEED_PARSER_ERROR grss_feed_parser_error_quark()
-struct _FeedParserPrivate {
+struct _GrssFeedParserPrivate {
GSList *handlers;
};
@@ -54,40 +54,40 @@ enum {
FEED_PARSER_FORMAT_ERROR
};
-G_DEFINE_TYPE (FeedParser, feed_parser, G_TYPE_OBJECT)
+G_DEFINE_TYPE (GrssFeedParser, grss_feed_parser, G_TYPE_OBJECT)
static GQuark
-feed_parser_error_quark ()
+grss_feed_parser_error_quark ()
{
- return g_quark_from_static_string ("feed_parser_error");
+ return g_quark_from_static_string ("grss_feed_parser_error");
}
static void
-feed_parser_finalize (GObject *object)
+grss_feed_parser_finalize (GObject *object)
{
- FeedParser *parser;
+ GrssFeedParser *parser;
parser = FEED_PARSER (object);
- G_OBJECT_CLASS (feed_parser_parent_class)->finalize (object);
+ G_OBJECT_CLASS (grss_feed_parser_parent_class)->finalize (object);
}
static void
-feed_parser_class_init (FeedParserClass *klass)
+grss_feed_parser_class_init (GrssFeedParserClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
- g_type_class_add_private (object_class, sizeof (FeedParserPrivate));
- object_class->finalize = feed_parser_finalize;
+ g_type_class_add_private (object_class, sizeof (GrssFeedParserPrivate));
+ object_class->finalize = grss_feed_parser_finalize;
}
static void
-feed_parser_init (FeedParser *object)
+grss_feed_parser_init (GrssFeedParser *object)
{
object->priv = FEED_PARSER_GET_PRIVATE (object);
}
static GSList*
-feed_parsers_get_list (FeedParser *parser)
+feed_parsers_get_list (GrssFeedParser *parser)
{
FeedHandler *feed;
NSHandler *ns;
@@ -116,23 +116,23 @@ feed_parsers_get_list (FeedParser *parser)
}
/**
- * feed_parser_new:
+ * grss_feed_parser_new:
*
- * Allocates a new #FeedParser
+ * Allocates a new #GrssFeedParser
*
- * Return value: a new #FeedParser
+ * Return value: a new #GrssFeedParser
*/
-FeedParser*
-feed_parser_new ()
+GrssFeedParser*
+grss_feed_parser_new ()
{
- FeedParser *parser;
+ GrssFeedParser *parser;
parser = g_object_new (FEED_PARSER_TYPE, NULL);
return parser;
}
static FeedHandler*
-retrieve_feed_handler (FeedParser *parser, xmlDocPtr doc, xmlNodePtr cur)
+retrieve_feed_handler (GrssFeedParser *parser, xmlDocPtr doc, xmlNodePtr cur)
{
GSList *iter;
FeedHandler *handler;
@@ -152,21 +152,21 @@ retrieve_feed_handler (FeedParser *parser, xmlDocPtr doc, xmlNodePtr cur)
}
/**
- * feed_parser_parse:
- * @parser: a #FeedParser
- * @feed: a #FeedChannel to be parsed
+ * grss_feed_parser_parse:
+ * @parser: a #GrssFeedParser
+ * @feed: a #GrssFeedChannel to be parsed
* @doc: XML document extracted from the contents of the feed, which must
* already been fetched
* @error: location for eventual errors
*
* Parses the given XML @doc, belonging to the given @feed, to obtain a list
- * of #FeedItem
+ * of #GrssFeedItem
*
- * Return value: a list of #FeedItem, to be freed when no longer in use, or
+ * Return value: a list of #GrssFeedItem, to be freed when no longer in use, or
* NULL if an error occours and @error is set
*/
GList*
-feed_parser_parse (FeedParser *parser, FeedChannel *feed, xmlDocPtr doc, GError **error)
+grss_feed_parser_parse (GrssFeedParser *parser, GrssFeedChannel *feed, xmlDocPtr doc, GError **error)
{
xmlNodePtr cur;
GList *items;
diff --git a/src/feed-parser.h b/src/feed-parser.h
index d03b81a..eb1dea2 100644
--- a/src/feed-parser.h
+++ b/src/feed-parser.h
@@ -23,29 +23,29 @@
#include "libgrss.h"
-#define FEED_PARSER_TYPE (feed_parser_get_type())
-#define FEED_PARSER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FEED_PARSER_TYPE, FeedParser))
-#define FEED_PARSER_CLASS(c) (G_TYPE_CHECK_CLASS_CAST ((c), FEED_PARSER_TYPE, FeedParserClass))
+#define FEED_PARSER_TYPE (grss_feed_parser_get_type())
+#define FEED_PARSER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FEED_PARSER_TYPE, GrssFeedParser))
+#define FEED_PARSER_CLASS(c) (G_TYPE_CHECK_CLASS_CAST ((c), FEED_PARSER_TYPE, GrssFeedParserClass))
#define IS_FEED_PARSER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FEED_PARSER_TYPE))
#define IS_FEED_PARSER_CLASS(c) (G_TYPE_CHECK_CLASS_TYPE ((c), FEED_PARSER_TYPE))
-#define FEED_PARSER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FEED_PARSER_TYPE, FeedParserClass))
+#define FEED_PARSER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FEED_PARSER_TYPE, GrssFeedParserClass))
-typedef struct _FeedParser FeedParser;
-typedef struct _FeedParserPrivate FeedParserPrivate;
+typedef struct _GrssFeedParser GrssFeedParser;
+typedef struct _GrssFeedParserPrivate GrssFeedParserPrivate;
-struct _FeedParser {
+struct _GrssFeedParser {
GObject parent;
- FeedParserPrivate *priv;
+ GrssFeedParserPrivate *priv;
};
typedef struct {
GObjectClass parent;
-} FeedParserClass;
+} GrssFeedParserClass;
-GType feed_parser_get_type () G_GNUC_CONST;
+GType grss_feed_parser_get_type () G_GNUC_CONST;
-FeedParser* feed_parser_new ();
+GrssFeedParser* grss_feed_parser_new ();
-GList* feed_parser_parse (FeedParser *parser, FeedChannel *feed, xmlDocPtr doc, GError **error);
+GList* grss_feed_parser_parse (GrssFeedParser *parser, GrssFeedChannel *feed, xmlDocPtr doc, GError **error);
#endif /* __FEED_PARSER_H__ */
diff --git a/src/feed-pie-handler.c b/src/feed-pie-handler.c
index c8ebe9d..824f8f4 100644
--- a/src/feed-pie-handler.c
+++ b/src/feed-pie-handler.c
@@ -45,8 +45,8 @@
#define FEED_PIE_HANDLER_ERROR feed_pie_handler_error_quark()
-typedef void (*PieChannelParserFunc) (xmlNodePtr cur, FeedChannel *feed);
-typedef void (*PieItemParserFunc) (xmlNodePtr cur, FeedItem *item, FeedChannel *feed);
+typedef void (*PieChannelParserFunc) (xmlNodePtr cur, GrssFeedChannel *feed);
+typedef void (*PieItemParserFunc) (xmlNodePtr cur, GrssFeedItem *item, GrssFeedChannel *feed);
struct FeedPieHandlerPrivate {
NSHandler *handler;
@@ -203,15 +203,15 @@ parseAuthor (xmlNodePtr cur) {
return tmp;
}
-FeedItem*
-parse_entry (FeedPieHandler *parser, FeedChannel *feed, xmlDocPtr doc, xmlNodePtr cur) {
+GrssFeedItem*
+parse_entry (FeedPieHandler *parser, GrssFeedChannel *feed, xmlDocPtr doc, xmlNodePtr cur) {
xmlChar *xtmp;
gchar *tmp2;
gchar *tmp;
- FeedItem *item;
+ GrssFeedItem *item;
g_assert (NULL != cur);
- item = feed_item_new (feed);
+ item = grss_feed_item_new (feed);
cur = cur->xmlChildrenNode;
@@ -231,7 +231,7 @@ parse_entry (FeedPieHandler *parser, FeedChannel *feed, xmlDocPtr doc, xmlNodePt
if (!xmlStrcmp (cur->name, BAD_CAST"title")) {
if (NULL != (tmp = unhtmlize (pie_parse_content_construct (cur)))) {
- feed_item_set_title (item, tmp);
+ grss_feed_item_set_title (item, tmp);
g_free (tmp);
}
}
@@ -241,7 +241,7 @@ parse_entry (FeedPieHandler *parser, FeedChannel *feed, xmlDocPtr doc, xmlNodePt
xtmp = xmlGetProp (cur, BAD_CAST"rel");
if (xtmp != NULL && !xmlStrcmp (xtmp, BAD_CAST"alternate"))
- feed_item_set_source(item, tmp2);
+ grss_feed_item_set_source(item, tmp2);
/* else
FIXME: Maybe do something with other links? */
@@ -251,7 +251,7 @@ parse_entry (FeedPieHandler *parser, FeedChannel *feed, xmlDocPtr doc, xmlNodePt
else {
/* 0.2 link : element content is the link, or non-alternate link in 0.3 */
if (NULL != (tmp = (gchar*) xmlNodeListGetString (doc, cur->xmlChildrenNode, 1))) {
- feed_item_set_source (item, tmp);
+ grss_feed_item_set_source (item, tmp);
g_free (tmp);
}
}
@@ -259,48 +259,48 @@ parse_entry (FeedPieHandler *parser, FeedChannel *feed, xmlDocPtr doc, xmlNodePt
else if (!xmlStrcmp (cur->name, BAD_CAST"author")) {
/* parse feed author */
tmp = parseAuthor (cur);
- feed_item_set_author (item, tmp);
+ grss_feed_item_set_author (item, tmp);
g_free (tmp);
}
else if (!xmlStrcmp (cur->name, BAD_CAST"contributor")) {
/* parse feed contributors */
tmp = parseAuthor (cur);
- feed_item_add_contributor (item, tmp);
+ grss_feed_item_add_contributor (item, tmp);
g_free (tmp);
}
else if (!xmlStrcmp (cur->name, BAD_CAST"id")) {
if (NULL != (tmp = (gchar*) xmlNodeListGetString (doc, cur->xmlChildrenNode, 1))) {
- feed_item_set_id (item, tmp);
+ grss_feed_item_set_id (item, tmp);
g_free (tmp);
}
}
else if (!xmlStrcmp (cur->name, BAD_CAST"issued")) {
/* FIXME: is <modified> or <issued> or <created> the time tag we want to display? */
if (NULL != (tmp = (gchar*) xmlNodeListGetString (doc, cur->xmlChildrenNode, 1))) {
- feed_item_set_publish_time (item, date_parse_ISO8601 (tmp));
+ grss_feed_item_set_publish_time (item, date_parse_ISO8601 (tmp));
g_free (tmp);
}
}
else if (!xmlStrcmp(cur->name, BAD_CAST"content")) {
/* <content> support */
if (NULL != (tmp = pie_parse_content_construct (cur))) {
- feed_item_set_description (item, tmp);
+ grss_feed_item_set_description (item, tmp);
g_free (tmp);
}
}
else if (!xmlStrcmp (cur->name, BAD_CAST"summary")) {
/* <summary> can be used for short text descriptions, if there is no
<content> description we show the <summary> content */
- if (!feed_item_get_description (item)) {
+ if (!grss_feed_item_get_description (item)) {
if (NULL != (tmp = pie_parse_content_construct (cur))) {
- feed_item_set_description (item, tmp);
+ grss_feed_item_set_description (item, tmp);
g_free (tmp);
}
}
}
else if (!xmlStrcmp (cur->name, BAD_CAST"copyright")) {
if (NULL != (tmp = (gchar*) xmlNodeListGetString (doc, cur->xmlChildrenNode, 1))) {
- feed_item_set_copyright (item, tmp);
+ grss_feed_item_set_copyright (item, tmp);
g_free (tmp);
}
}
@@ -312,7 +312,7 @@ parse_entry (FeedPieHandler *parser, FeedChannel *feed, xmlDocPtr doc, xmlNodePt
}
static GList*
-feed_pie_handler_parse (FeedHandler *self, FeedChannel *feed, xmlDocPtr doc, GError **error)
+feed_pie_handler_parse (FeedHandler *self, GrssFeedChannel *feed, xmlDocPtr doc, GError **error)
{
gchar *tmp2;
gchar *tmp = NULL;
@@ -321,7 +321,7 @@ feed_pie_handler_parse (FeedHandler *self, FeedChannel *feed, xmlDocPtr doc, GEr
time_t now;
xmlNodePtr cur;
GList *items;
- FeedItem *item;
+ GrssFeedItem *item;
FeedPieHandler *parser;
items = NULL;
@@ -356,7 +356,7 @@ feed_pie_handler_parse (FeedHandler *self, FeedChannel *feed, xmlDocPtr doc, GEr
if (!xmlStrcmp(cur->name, BAD_CAST"title")) {
tmp = unhtmlize (pie_parse_content_construct (cur));
if (tmp)
- feed_channel_set_title (feed, tmp);
+ grss_feed_channel_set_title (feed, tmp);
}
else if (!xmlStrcmp (cur->name, BAD_CAST"link")) {
tmp = (gchar*) xmlGetNsProp (cur, BAD_CAST"href", NULL);
@@ -366,7 +366,7 @@ feed_pie_handler_parse (FeedHandler *self, FeedChannel *feed, xmlDocPtr doc, GEr
tmp2 = (gchar*) xmlGetNsProp (cur, BAD_CAST"rel", NULL);
if (tmp2 && g_str_equal (tmp2, "alternate"))
- feed_channel_set_homepage (feed, tmp);
+ grss_feed_channel_set_homepage (feed, tmp);
/* else
FIXME: Maybe do something with other links? */
@@ -377,7 +377,7 @@ feed_pie_handler_parse (FeedHandler *self, FeedChannel *feed, xmlDocPtr doc, GEr
/* 0.2 link : element content is the link, or non-alternate link in 0.3 */
tmp = (gchar*) xmlNodeListGetString (doc, cur->xmlChildrenNode, 1);
if (tmp) {
- feed_channel_set_homepage (feed, tmp);
+ grss_feed_channel_set_homepage (feed, tmp);
g_free (tmp);
}
}
@@ -387,14 +387,14 @@ feed_pie_handler_parse (FeedHandler *self, FeedChannel *feed, xmlDocPtr doc, GEr
/* parse feed author */
tmp = parseAuthor (cur);
if (tmp) {
- feed_channel_set_editor (feed, tmp);
+ grss_feed_channel_set_editor (feed, tmp);
g_free (tmp);
}
}
else if (!xmlStrcmp (cur->name, BAD_CAST"tagline")) {
tmp = pie_parse_content_construct (cur);
if (tmp) {
- feed_channel_set_description (feed, tmp);
+ grss_feed_channel_set_description (feed, tmp);
g_free (tmp);
}
}
@@ -417,7 +417,7 @@ feed_pie_handler_parse (FeedHandler *self, FeedChannel *feed, xmlDocPtr doc, GEr
tmp = tmp3;
}
- feed_channel_set_generator (feed, tmp);
+ grss_feed_channel_set_generator (feed, tmp);
}
g_free (tmp);
@@ -425,7 +425,7 @@ feed_pie_handler_parse (FeedHandler *self, FeedChannel *feed, xmlDocPtr doc, GEr
else if (!xmlStrcmp (cur->name, BAD_CAST"copyright")) {
tmp = pie_parse_content_construct (cur);
if (tmp) {
- feed_channel_set_copyright (feed, tmp);
+ grss_feed_channel_set_copyright (feed, tmp);
g_free (tmp);
}
}
@@ -433,7 +433,7 @@ feed_pie_handler_parse (FeedHandler *self, FeedChannel *feed, xmlDocPtr doc, GEr
tmp = (gchar*) xmlNodeListGetString (doc, cur->xmlChildrenNode, 1);
if (tmp) {
t = date_parse_ISO8601 (tmp);
- feed_channel_set_update_time (feed, t);
+ grss_feed_channel_set_update_time (feed, t);
g_free (tmp);
}
}
@@ -441,22 +441,22 @@ feed_pie_handler_parse (FeedHandler *self, FeedChannel *feed, xmlDocPtr doc, GEr
tmp = (gchar*) xmlNodeListGetString (doc, cur->xmlChildrenNode, 1);
if (tmp) {
t = date_parse_ISO8601 (tmp);
- feed_channel_set_update_time (feed, t);
+ grss_feed_channel_set_update_time (feed, t);
g_free(tmp);
}
}
else if (!xmlStrcmp (cur->name, BAD_CAST"contributor")) {
tmp = parseAuthor (cur);
if (tmp) {
- feed_channel_add_contributor (feed, tmp);
+ grss_feed_channel_add_contributor (feed, tmp);
g_free (tmp);
}
}
else if ((!xmlStrcmp (cur->name, BAD_CAST"entry"))) {
item = parse_entry (parser, feed, doc, cur);
if (item) {
- if (feed_item_get_publish_time (item) == 0)
- feed_item_set_publish_time (item, now);
+ if (grss_feed_item_get_publish_time (item) == 0)
+ grss_feed_item_set_publish_time (item, now);
items = g_list_prepend (items, item);
}
}
diff --git a/src/feed-rss-handler.c b/src/feed-rss-handler.c
index 84c2941..7183919 100644
--- a/src/feed-rss-handler.c
+++ b/src/feed-rss-handler.c
@@ -118,7 +118,7 @@ feed_rss_handler_check_format (FeedHandler *self, xmlDocPtr doc, xmlNodePtr cur)
}
static void
-parse_channel (FeedRssHandler *parser, FeedChannel *feed, xmlDocPtr doc, xmlNodePtr cur) {
+parse_channel (FeedRssHandler *parser, GrssFeedChannel *feed, xmlDocPtr doc, xmlNodePtr cur) {
gchar *tmp;
time_t t;
@@ -142,28 +142,28 @@ parse_channel (FeedRssHandler *parser, FeedChannel *feed, xmlDocPtr doc, xmlNode
if (!xmlStrcmp (cur->name, BAD_CAST"copyright")) {
tmp = (gchar*) xmlNodeListGetString (doc, cur->xmlChildrenNode, 1);
if (tmp) {
- feed_channel_set_copyright (feed, tmp);
+ grss_feed_channel_set_copyright (feed, tmp);
g_free (tmp);
}
}
else if (!xmlStrcmp (cur->name, BAD_CAST"webMaster") || !xmlStrcmp (cur->name, BAD_CAST"publisher")) {
tmp = (gchar*) xmlNodeListGetString (doc, cur->xmlChildrenNode, 1);
if (tmp) {
- feed_channel_set_webmaster (feed, tmp);
+ grss_feed_channel_set_webmaster (feed, tmp);
g_free (tmp);
}
}
else if (!xmlStrcmp (cur->name, BAD_CAST"language")) {
tmp = (gchar*) xmlNodeListGetString (doc, cur->xmlChildrenNode, 1);
if (tmp) {
- feed_channel_set_language (feed, tmp);
+ grss_feed_channel_set_language (feed, tmp);
g_free (tmp);
}
}
else if (!xmlStrcmp (cur->name, BAD_CAST"managingEditor")) {
tmp = (gchar*) xmlNodeListGetString (doc, cur->xmlChildrenNode, 1);
if (tmp) {
- feed_channel_set_editor (feed, tmp);
+ grss_feed_channel_set_editor (feed, tmp);
g_free (tmp);
}
}
@@ -171,33 +171,33 @@ parse_channel (FeedRssHandler *parser, FeedChannel *feed, xmlDocPtr doc, xmlNode
tmp = (gchar*) xmlNodeListGetString (doc, cur->xmlChildrenNode, 1);
if (tmp) {
t = date_parse_RFC822 (tmp);
- feed_channel_set_update_time (feed, t);
+ grss_feed_channel_set_update_time (feed, t);
g_free (tmp);
}
}
else if (!xmlStrcmp (cur->name, BAD_CAST"generator")) {
tmp = (gchar*) xmlNodeListGetString (doc, cur->xmlChildrenNode, 1);
if (tmp) {
- feed_channel_set_generator (feed, tmp);
+ grss_feed_channel_set_generator (feed, tmp);
g_free (tmp);
}
}
else if (!xmlStrcmp (cur->name, BAD_CAST"pubDate")) {
if (NULL != (tmp = (gchar*) xmlNodeListGetString (doc, cur->xmlChildrenNode, 1))) {
t = date_parse_RFC822 (tmp);
- feed_channel_set_publish_time (feed, t);
+ grss_feed_channel_set_publish_time (feed, t);
g_free (tmp);
}
}
else if (!xmlStrcmp (cur->name, BAD_CAST"ttl")) {
if (NULL != (tmp = (gchar*) xmlNodeListGetString (doc, cur->xmlChildrenNode, TRUE))) {
- feed_channel_set_update_interval (feed, atoi (tmp));
+ grss_feed_channel_set_update_interval (feed, atoi (tmp));
g_free (tmp);
}
}
else if (!xmlStrcmp (cur->name, BAD_CAST"title")) {
if (NULL != (tmp = unhtmlize ((gchar*) xmlNodeListGetString (doc, cur->xmlChildrenNode, TRUE)))) {
- feed_channel_set_title (feed, tmp);
+ grss_feed_channel_set_title (feed, tmp);
g_free (tmp);
}
}
@@ -206,14 +206,14 @@ parse_channel (FeedRssHandler *parser, FeedChannel *feed, xmlDocPtr doc, xmlNode
*/
else if (!xmlStrcmp (cur->name, BAD_CAST"link") || !xmlStrcmp (cur->name, BAD_CAST"alink")) {
if (NULL != (tmp = unhtmlize ((gchar*) xmlNodeListGetString (doc, cur->xmlChildrenNode, TRUE)))) {
- feed_channel_set_homepage (feed, tmp);
+ grss_feed_channel_set_homepage (feed, tmp);
g_free (tmp);
}
}
else if (!xmlStrcmp (cur->name, BAD_CAST"description")) {
tmp = xhtml_extract (cur, 0, NULL);
if (tmp) {
- feed_channel_set_description (feed, tmp);
+ grss_feed_channel_set_description (feed, tmp);
g_free (tmp);
}
}
@@ -222,24 +222,24 @@ parse_channel (FeedRssHandler *parser, FeedChannel *feed, xmlDocPtr doc, xmlNode
}
}
-static FeedItem*
-parse_rss_item (FeedRssHandler *parser, FeedChannel *feed, xmlDocPtr doc, xmlNodePtr cur)
+static GrssFeedItem*
+parse_rss_item (FeedRssHandler *parser, GrssFeedChannel *feed, xmlDocPtr doc, xmlNodePtr cur)
{
gchar *tmp;
gchar *tmp2;
gchar *tmp3;
time_t t;
- FeedItem *item;
+ GrssFeedItem *item;
g_assert (cur != NULL);
- item = feed_item_new (feed);
+ item = grss_feed_item_new (feed);
/* try to get an item about id */
tmp = (gchar*) xmlGetProp (cur, BAD_CAST"about");
if (tmp) {
- feed_item_set_id (item, tmp);
- feed_item_set_source (item, tmp);
+ grss_feed_item_set_id (item, tmp);
+ grss_feed_item_set_source (item, tmp);
g_free (tmp);
}
@@ -262,21 +262,21 @@ parse_rss_item (FeedRssHandler *parser, FeedChannel *feed, xmlDocPtr doc, xmlNod
if (!xmlStrcmp (cur->name, BAD_CAST"category")) {
tmp = (gchar*) xmlNodeListGetString (doc, cur->xmlChildrenNode, 1);
if (tmp) {
- feed_item_add_category (item, tmp);
+ grss_feed_item_add_category (item, tmp);
g_free (tmp);
}
}
else if (!xmlStrcmp (cur->name, BAD_CAST"author")) {
tmp = (gchar*) xmlNodeListGetString (doc, cur->xmlChildrenNode, 1);
if (tmp) {
- feed_item_set_author (item, tmp);
+ grss_feed_item_set_author (item, tmp);
g_free (tmp);
}
}
else if (!xmlStrcmp (cur->name, BAD_CAST"comments")) {
tmp = (gchar*) xmlNodeListGetString (doc, cur->xmlChildrenNode, 1);
if (tmp) {
- feed_item_set_comments_url (item, tmp);
+ grss_feed_item_set_comments_url (item, tmp);
g_free (tmp);
}
}
@@ -284,7 +284,7 @@ parse_rss_item (FeedRssHandler *parser, FeedChannel *feed, xmlDocPtr doc, xmlNod
tmp = (gchar*) xmlNodeListGetString (doc, cur->xmlChildrenNode, 1);
if (tmp) {
t = date_parse_RFC822 (tmp);
- feed_item_set_publish_time (item, t);
+ grss_feed_item_set_publish_time (item, t);
g_free (tmp);
}
}
@@ -295,7 +295,7 @@ parse_rss_item (FeedRssHandler *parser, FeedChannel *feed, xmlDocPtr doc, xmlNod
if (tmp) {
gchar *type = (gchar*) xmlGetProp (cur, BAD_CAST"type");
gssize length = 0;
- FeedEnclosure *enclosure;
+ GrssFeedEnclosure *enclosure;
tmp2 = (gchar*) xmlGetProp (cur, BAD_CAST"length");
if (tmp2) {
@@ -303,7 +303,7 @@ parse_rss_item (FeedRssHandler *parser, FeedChannel *feed, xmlDocPtr doc, xmlNod
xmlFree (tmp2);
}
- tmp3 = (gchar*) feed_channel_get_homepage (feed);
+ tmp3 = (gchar*) grss_feed_channel_get_homepage (feed);
if ((strstr (tmp, "://") == NULL) &&
(tmp3 != NULL) &&
@@ -314,25 +314,25 @@ parse_rss_item (FeedRssHandler *parser, FeedChannel *feed, xmlDocPtr doc, xmlNod
tmp = tmp2;
}
- enclosure = feed_enclosure_new (tmp);
- feed_enclosure_set_format (enclosure, type);
- feed_enclosure_set_length (enclosure, length);
- feed_item_add_enclosure (item, enclosure);
+ enclosure = grss_feed_enclosure_new (tmp);
+ grss_feed_enclosure_set_format (enclosure, type);
+ grss_feed_enclosure_set_length (enclosure, length);
+ grss_feed_item_add_enclosure (item, enclosure);
xmlFree (tmp);
xmlFree (type);
}
}
else if (!xmlStrcmp (cur->name, BAD_CAST"guid")) {
- if (!feed_item_get_id (item)) {
+ if (!grss_feed_item_get_id (item)) {
tmp = (gchar*) xmlNodeListGetString (doc, cur->xmlChildrenNode, 1);
if (tmp) {
if (strlen (tmp) > 0) {
- feed_item_set_id (item, tmp);
+ grss_feed_item_set_id (item, tmp);
tmp2 = (gchar*) xmlGetProp (cur, BAD_CAST"isPermaLink");
- if (!feed_item_get_source (item) && (tmp2 == NULL || g_str_equal (tmp2, "true")))
- feed_item_set_source (item, tmp); /* Per the RSS 2.0 spec. */
+ if (!grss_feed_item_get_source (item) && (tmp2 == NULL || g_str_equal (tmp2, "true")))
+ grss_feed_item_set_source (item, tmp); /* Per the RSS 2.0 spec. */
if (tmp2)
xmlFree (tmp2);
}
@@ -344,14 +344,14 @@ parse_rss_item (FeedRssHandler *parser, FeedChannel *feed, xmlDocPtr doc, xmlNod
else if (!xmlStrcmp (cur->name, BAD_CAST"title")) {
tmp = unhtmlize ((gchar*) xmlNodeListGetString (doc, cur->xmlChildrenNode, TRUE));
if (tmp) {
- feed_item_set_title (item, tmp);
+ grss_feed_item_set_title (item, tmp);
g_free (tmp);
}
}
else if (!xmlStrcmp (cur->name, BAD_CAST"link")) {
tmp = unhtmlize ((gchar*) xmlNodeListGetString (doc, cur->xmlChildrenNode, TRUE));
if (tmp) {
- feed_item_set_source (item, tmp);
+ grss_feed_item_set_source (item, tmp);
g_free (tmp);
}
}
@@ -359,8 +359,8 @@ parse_rss_item (FeedRssHandler *parser, FeedChannel *feed, xmlDocPtr doc, xmlNod
tmp = xhtml_extract (cur, 0, NULL);
if (tmp) {
/* don't overwrite content:encoded descriptions... */
- if (!feed_item_get_description (item))
- feed_item_set_description (item, tmp);
+ if (!grss_feed_item_get_description (item))
+ grss_feed_item_set_description (item, tmp);
g_free (tmp);
}
}
@@ -369,7 +369,7 @@ parse_rss_item (FeedRssHandler *parser, FeedChannel *feed, xmlDocPtr doc, xmlNod
tmp2 = unhtmlize ((gchar*) xmlNodeListGetString (doc, cur->xmlChildrenNode, 1));
if (tmp) {
- feed_item_set_real_source (item, g_strchomp (tmp), tmp2 ? g_strchomp (tmp2) : NULL);
+ grss_feed_item_set_real_source (item, g_strchomp (tmp), tmp2 ? g_strchomp (tmp2) : NULL);
g_free (tmp);
}
@@ -406,14 +406,14 @@ parse_image (xmlNodePtr cur) {
}
static GList*
-feed_rss_handler_parse (FeedHandler *self, FeedChannel *feed, xmlDocPtr doc, GError **error)
+feed_rss_handler_parse (FeedHandler *self, GrssFeedChannel *feed, xmlDocPtr doc, GError **error)
{
gchar *tmp;
gboolean rdf;
time_t now;
GList *items;
xmlNodePtr cur;
- FeedItem *item;
+ GrssFeedItem *item;
FeedRssHandler *parser;
items = NULL;
@@ -477,7 +477,7 @@ feed_rss_handler_parse (FeedHandler *self, FeedChannel *feed, xmlDocPtr doc, GEr
/* save link to channel image */
if ((!xmlStrcmp (cur->name, BAD_CAST"image"))) {
if (NULL != (tmp = parse_image (cur))) {
- feed_channel_set_image (feed, tmp);
+ grss_feed_channel_set_image (feed, tmp);
g_free (tmp);
}
}
@@ -488,8 +488,8 @@ feed_rss_handler_parse (FeedHandler *self, FeedChannel *feed, xmlDocPtr doc, GEr
item = parse_rss_item (parser, feed, doc, iter);
if (item != NULL) {
- if (feed_item_get_publish_time (item) == 0)
- feed_item_set_publish_time (item, now);
+ if (grss_feed_item_get_publish_time (item) == 0)
+ grss_feed_item_set_publish_time (item, now);
items = g_list_append (items, item);
}
@@ -500,8 +500,8 @@ feed_rss_handler_parse (FeedHandler *self, FeedChannel *feed, xmlDocPtr doc, GEr
item = parse_rss_item (parser, feed, doc, cur);
if (item != NULL) {
- if (feed_item_get_publish_time (item) == 0)
- feed_item_set_publish_time (item, now);
+ if (grss_feed_item_get_publish_time (item) == 0)
+ grss_feed_item_set_publish_time (item, now);
items = g_list_append (items, item);
}
diff --git a/src/feeds-group-handler.c b/src/feeds-group-handler.c
index 7042e56..26c97d2 100644
--- a/src/feeds-group-handler.c
+++ b/src/feeds-group-handler.c
@@ -25,46 +25,46 @@
* SECTION: feeds-group-handler
* @short_description: interface for specialized groups parsers
*
- * The #FeedsGroupHandler interface defines a unique API for all specialized
+ * The #GrssFeedsGroupHandler interface defines a unique API for all specialized
* groups parsers implementations
*/
static void
-feeds_group_handler_base_init (gpointer g_class)
+grss_feeds_group_handler_base_init (gpointer g_class)
{
}
GType
-feeds_group_handler_get_type ()
+grss_feeds_group_handler_get_type ()
{
static GType iface_type = 0;
if (iface_type == 0) {
static const GTypeInfo info = {
- sizeof (FeedsGroupHandlerInterface),
- feeds_group_handler_base_init,
+ sizeof (GrssFeedsGroupHandlerInterface),
+ grss_feeds_group_handler_base_init,
NULL,
};
- iface_type = g_type_register_static (G_TYPE_INTERFACE, "FeedsGroupHandler", &info, 0);
+ iface_type = g_type_register_static (G_TYPE_INTERFACE, "GrssFeedsGroupHandler", &info, 0);
}
return iface_type;
}
/**
- * feeds_group_handler_check_format:
- * @self: a #FeedsGroupHandler
+ * grss_feeds_group_handler_check_format:
+ * @self: a #GrssFeedsGroupHandler
* @doc: XML document from a parsed feed
* @cur: first valid node into the XML document
*
* Used to check validity of an XML document against the given group parser
*
* Return value: %TRUE if the document can be parsed with the given
- * #FeedsGroupHandler, %FALSE otherwise
+ * #GrssFeedsGroupHandler, %FALSE otherwise
*/
gboolean
-feeds_group_handler_check_format (FeedsGroupHandler *self, xmlDocPtr doc, xmlNodePtr cur)
+grss_feeds_group_handler_check_format (GrssFeedsGroupHandler *self, xmlDocPtr doc, xmlNodePtr cur)
{
if (IS_FEEDS_GROUP_HANDLER (self) == FALSE)
return FALSE;
@@ -73,18 +73,18 @@ feeds_group_handler_check_format (FeedsGroupHandler *self, xmlDocPtr doc, xmlNod
}
/**
- * feeds_group_handler_parse:
- * @self: a #FeedsGroupHandler
+ * grss_feeds_group_handler_parse:
+ * @self: a #GrssFeedsGroupHandler
* @doc: XML document from the feed
* @error: location for eventual errors
*
- * Parses the given @doc and extracts a list of #FeedChannels
+ * Parses the given @doc and extracts a list of #GrssFeedChannels
*
- * Return value: a list of #FeedChannels, to be freed when no longer in use,
+ * Return value: a list of #GrssFeedChannels, to be freed when no longer in use,
* or %NULL if an error occours (and @error is set accordly)
*/
GList*
-feeds_group_handler_parse (FeedsGroupHandler *self, xmlDocPtr doc, GError **error)
+grss_feeds_group_handler_parse (GrssFeedsGroupHandler *self, xmlDocPtr doc, GError **error)
{
if (IS_FEEDS_GROUP_HANDLER (self) == FALSE)
return FALSE;
@@ -93,9 +93,9 @@ feeds_group_handler_parse (FeedsGroupHandler *self, xmlDocPtr doc, GError **erro
}
/**
- * feeds_group_handler_dump:
- * @self: a #FeedsGroupHandler
- * @channels: list of #FeedChannels
+ * grss_feeds_group_handler_dump:
+ * @self: a #GrssFeedsGroupHandler
+ * @channels: list of #GrssFeedChannels
* @error: location for eventual errors
*
* Builds a rappresentation of the given list of @channels for the managed
@@ -105,7 +105,7 @@ feeds_group_handler_parse (FeedsGroupHandler *self, xmlDocPtr doc, GError **erro
* no longer in use, or %NULL if an error occours (and @error is set accordly)
*/
gchar*
-feeds_group_handler_dump (FeedsGroupHandler *self, GList *channels, GError **error)
+grss_feeds_group_handler_dump (GrssFeedsGroupHandler *self, GList *channels, GError **error)
{
if (IS_FEEDS_GROUP_HANDLER (self) == FALSE)
return FALSE;
diff --git a/src/feeds-group-handler.h b/src/feeds-group-handler.h
index 3e1ea21..7c7ee0e 100644
--- a/src/feeds-group-handler.h
+++ b/src/feeds-group-handler.h
@@ -23,26 +23,26 @@
#include "libgrss.h"
-#define FEEDS_GROUP_HANDLER_TYPE (feeds_group_handler_get_type ())
-#define FEEDS_GROUP_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), FEEDS_GROUP_HANDLER_TYPE, FeedsGroupHandler))
+#define FEEDS_GROUP_HANDLER_TYPE (grss_feeds_group_handler_get_type ())
+#define FEEDS_GROUP_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), FEEDS_GROUP_HANDLER_TYPE, GrssFeedsGroupHandler))
#define IS_FEEDS_GROUP_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), FEEDS_GROUP_HANDLER_TYPE))
-#define FEEDS_GROUP_HANDLER_GET_INTERFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE ((inst), FEEDS_GROUP_HANDLER_TYPE, FeedsGroupHandlerInterface))
+#define FEEDS_GROUP_HANDLER_GET_INTERFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE ((inst), FEEDS_GROUP_HANDLER_TYPE, GrssFeedsGroupHandlerInterface))
-typedef struct _FeedsGroupHandler FeedsGroupHandler;
-typedef struct _FeedsGroupHandlerInterface FeedsGroupHandlerInterface;
+typedef struct _GrssFeedsGroupHandler GrssFeedsGroupHandler;
+typedef struct _GrssFeedsGroupHandlerInterface GrssFeedsGroupHandlerInterface;
-struct _FeedsGroupHandlerInterface {
+struct _GrssFeedsGroupHandlerInterface {
GTypeInterface parent_iface;
- gboolean (*check_format) (FeedsGroupHandler *self, xmlDocPtr doc, xmlNodePtr cur);
- GList* (*parse) (FeedsGroupHandler *self, xmlDocPtr doc, GError **error);
- gchar* (*dump) (FeedsGroupHandler *self, GList *channels, GError **error);
+ gboolean (*check_format) (GrssFeedsGroupHandler *self, xmlDocPtr doc, xmlNodePtr cur);
+ GList* (*parse) (GrssFeedsGroupHandler *self, xmlDocPtr doc, GError **error);
+ gchar* (*dump) (GrssFeedsGroupHandler *self, GList *channels, GError **error);
};
-GType feeds_group_handler_get_type ();
+GType grss_feeds_group_handler_get_type ();
-gboolean feeds_group_handler_check_format (FeedsGroupHandler *self, xmlDocPtr doc, xmlNodePtr cur);
-GList* feeds_group_handler_parse (FeedsGroupHandler *self, xmlDocPtr doc, GError **error);
-gchar* feeds_group_handler_dump (FeedsGroupHandler *self, GList *channels, GError **error);
+gboolean grss_feeds_group_handler_check_format (GrssFeedsGroupHandler *self, xmlDocPtr doc, xmlNodePtr cur);
+GList* grss_feeds_group_handler_parse (GrssFeedsGroupHandler *self, xmlDocPtr doc, GError **error);
+gchar* grss_feeds_group_handler_dump (GrssFeedsGroupHandler *self, GList *channels, GError **error);
#endif /* __FEEDS_GROUP_HANDLER_H__ */
diff --git a/src/feeds-group.c b/src/feeds-group.c
index 5484c70..f09e565 100644
--- a/src/feeds-group.c
+++ b/src/feeds-group.c
@@ -26,19 +26,19 @@
#include "feeds-xoxo-group-handler.h"
#include "feeds-xbel-group-handler.h"
-#define FEEDS_GROUP_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), FEEDS_GROUP_TYPE, FeedsGroupPrivate))
+#define FEEDS_GROUP_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), FEEDS_GROUP_TYPE, GrssFeedsGroupPrivate))
/**
* SECTION: feeds-group
* @short_description: import and export group of channels
*
- * #FeedsGroup is an utility to import and export list of #FeedChannels in
+ * #GrssFeedsGroup is an utility to import and export list of #GrssFeedChannels in
* different formats, such as OPML and XOXO.
*/
-#define FEEDS_GROUP_ERROR feeds_group_error_quark()
+#define FEEDS_GROUP_ERROR grss_feeds_group_error_quark()
-struct _FeedsGroupPrivate {
+struct _GrssFeedsGroupPrivate {
GSList *handlers;
};
@@ -46,42 +46,42 @@ enum {
FEEDS_GROUP_PARSE_ERROR,
};
-G_DEFINE_TYPE (FeedsGroup, feeds_group, G_TYPE_OBJECT)
+G_DEFINE_TYPE (GrssFeedsGroup, grss_feeds_group, G_TYPE_OBJECT)
static GQuark
-feeds_group_error_quark ()
+grss_feeds_group_error_quark ()
{
- return g_quark_from_static_string ("feeds_group_error");
+ return g_quark_from_static_string ("grss_feeds_group_error");
}
static void
-feeds_group_finalize (GObject *object)
+grss_feeds_group_finalize (GObject *object)
{
- FeedsGroup *group;
+ GrssFeedsGroup *group;
group = FEEDS_GROUP (object);
- G_OBJECT_CLASS (feeds_group_parent_class)->finalize (object);
+ G_OBJECT_CLASS (grss_feeds_group_parent_class)->finalize (object);
}
static void
-feeds_group_class_init (FeedsGroupClass *klass)
+grss_feeds_group_class_init (GrssFeedsGroupClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
- g_type_class_add_private (object_class, sizeof (FeedsGroupPrivate));
- object_class->finalize = feeds_group_finalize;
+ g_type_class_add_private (object_class, sizeof (GrssFeedsGroupPrivate));
+ object_class->finalize = grss_feeds_group_finalize;
}
static void
-feeds_group_init (FeedsGroup *object)
+grss_feeds_group_init (GrssFeedsGroup *object)
{
object->priv = FEEDS_GROUP_GET_PRIVATE (object);
}
static GSList*
-feeds_groups_get_list (FeedsGroup *group)
+feeds_groups_get_list (GrssFeedsGroup *group)
{
- FeedsGroupHandler *parser;
+ GrssFeedsGroupHandler *parser;
if (group->priv->handlers == NULL) {
/*
@@ -102,33 +102,33 @@ feeds_groups_get_list (FeedsGroup *group)
}
/**
- * feeds_group_new:
+ * grss_feeds_group_new:
*
- * Allocates a new #FeedsGroup
+ * Allocates a new #GrssFeedsGroup
*
- * Return value: a new #FeedsGroup
+ * Return value: a new #GrssFeedsGroup
*/
-FeedsGroup*
-feeds_group_new ()
+GrssFeedsGroup*
+grss_feeds_group_new ()
{
- FeedsGroup *group;
+ GrssFeedsGroup *group;
group = g_object_new (FEEDS_GROUP_TYPE, NULL);
return group;
}
-static FeedsGroupHandler*
-retrieve_group_handler (FeedsGroup *group, xmlDocPtr doc, xmlNodePtr cur)
+static GrssFeedsGroupHandler*
+retrieve_group_handler (GrssFeedsGroup *group, xmlDocPtr doc, xmlNodePtr cur)
{
GSList *iter;
- FeedsGroupHandler *handler;
+ GrssFeedsGroupHandler *handler;
iter = feeds_groups_get_list (group);
while (iter) {
- handler = (FeedsGroupHandler*) (iter->data);
+ handler = (GrssFeedsGroupHandler*) (iter->data);
- if (handler && feeds_group_handler_check_format (handler, doc, cur))
+ if (handler && grss_feeds_group_handler_check_format (handler, doc, cur))
return handler;
iter = g_slist_next (iter);
@@ -139,23 +139,23 @@ retrieve_group_handler (FeedsGroup *group, xmlDocPtr doc, xmlNodePtr cur)
}
/**
- * feeds_group_parse_file:
- * @group: a #FeedsGroup
+ * grss_feeds_group_parse_file:
+ * @group: a #GrssFeedsGroup
* @path: path of the file to parse
* @error: location for eventual errors
*
* Parses the given file to obtain list of listed feeds
*
- * Return value: a list of #FeedChannels, or NULL if an error occours and
+ * Return value: a list of #GrssFeedChannels, or NULL if an error occours and
* @error is set
*/
GList*
-feeds_group_parse_file (FeedsGroup *group, const gchar *path, GError **error)
+grss_feeds_group_parse_file (GrssFeedsGroup *group, const gchar *path, GError **error)
{
GList *items;
xmlDocPtr doc;
xmlNodePtr cur;
- FeedsGroupHandler *handler;
+ GrssFeedsGroupHandler *handler;
items = NULL;
doc = NULL;
@@ -182,7 +182,7 @@ feeds_group_parse_file (FeedsGroup *group, const gchar *path, GError **error)
if (handler == NULL)
break;
- items = feeds_group_handler_parse (handler, doc, error);
+ items = grss_feeds_group_handler_parse (handler, doc, error);
} while (0);
@@ -193,7 +193,7 @@ feeds_group_parse_file (FeedsGroup *group, const gchar *path, GError **error)
}
gboolean
-feeds_group_export_file (FeedsGroup *groups, GList *channels, const gchar *path, GError *error)
+grss_feeds_group_export_file (GrssFeedsGroup *groups, GList *channels, const gchar *path, GError *error)
{
return FALSE;
}
diff --git a/src/feeds-group.h b/src/feeds-group.h
index 134b897..70f7d76 100644
--- a/src/feeds-group.h
+++ b/src/feeds-group.h
@@ -23,30 +23,30 @@
#include "libgrss.h"
-#define FEEDS_GROUP_TYPE (feeds_group_get_type())
-#define FEEDS_GROUP(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FEEDS_GROUP_TYPE, FeedsGroup))
-#define FEEDS_GROUP_CLASS(c) (G_TYPE_CHECK_CLASS_CAST ((c), FEEDS_GROUP_TYPE, FeedsGroupClass))
+#define FEEDS_GROUP_TYPE (grss_feeds_group_get_type())
+#define FEEDS_GROUP(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FEEDS_GROUP_TYPE, GrssFeedsGroup))
+#define FEEDS_GROUP_CLASS(c) (G_TYPE_CHECK_CLASS_CAST ((c), FEEDS_GROUP_TYPE, GrssFeedsGroupClass))
#define IS_FEEDS_GROUP(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FEEDS_GROUP_TYPE))
#define IS_FEEDS_GROUP_CLASS(c) (G_TYPE_CHECK_CLASS_TYPE ((c), FEEDS_GROUP_TYPE))
-#define FEEDS_GROUP_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FEEDS_GROUP_TYPE, FeedsGroupClass))
+#define FEEDS_GROUP_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FEEDS_GROUP_TYPE, GrssFeedsGroupClass))
-typedef struct _FeedsGroup FeedsGroup;
-typedef struct _FeedsGroupPrivate FeedsGroupPrivate;
+typedef struct _GrssFeedsGroup GrssFeedsGroup;
+typedef struct _GrssFeedsGroupPrivate GrssFeedsGroupPrivate;
-struct _FeedsGroup {
+struct _GrssFeedsGroup {
GObject parent;
- FeedsGroupPrivate *priv;
+ GrssFeedsGroupPrivate *priv;
};
typedef struct {
GObjectClass parent;
-} FeedsGroupClass;
+} GrssFeedsGroupClass;
-GType feeds_group_get_type () G_GNUC_CONST;
+GType grss_feeds_group_get_type () G_GNUC_CONST;
-FeedsGroup* feeds_group_new ();
+GrssFeedsGroup* grss_feeds_group_new ();
-GList* feeds_group_parse_file (FeedsGroup *group, const gchar *path, GError **error);
-gboolean feeds_group_export_file (FeedsGroup *group, GList *channels, const gchar *path, GError *error);
+GList* grss_feeds_group_parse_file (GrssFeedsGroup *group, const gchar *path, GError **error);
+gboolean grss_feeds_group_export_file (GrssFeedsGroup *group, GList *channels, const gchar *path, GError *error);
#endif /* __FEEDS_GROUP_H__ */
diff --git a/src/feeds-opml-group-handler.c b/src/feeds-opml-group-handler.c
index 2fb5726..5a833d6 100644
--- a/src/feeds-opml-group-handler.c
+++ b/src/feeds-opml-group-handler.c
@@ -37,17 +37,17 @@
* SECTION: feeds-opml-group-handler
* @short_description: specialized parser for OPML files
*
- * #FeedsOpmlGroupHandler is a #FeedsGroupHandler specialized for OPML contents
+ * #FeedsOpmlGroupHandler is a #GrssFeedsGroupHandler specialized for OPML contents
*/
struct FeedsOpmlGroupHandlerPrivate {
int rfu;
};
-static void feeds_group_handler_interface_init (FeedsGroupHandlerInterface *iface);
+static void grss_feeds_group_handler_interface_init (GrssFeedsGroupHandlerInterface *iface);
G_DEFINE_TYPE_WITH_CODE (FeedsOpmlGroupHandler, feeds_opml_group_handler, G_TYPE_OBJECT,
G_IMPLEMENT_INTERFACE (FEEDS_GROUP_HANDLER_TYPE,
- feeds_group_handler_interface_init));
+ grss_feeds_group_handler_interface_init));
static void
feeds_opml_group_handler_finalize (GObject *object)
@@ -59,7 +59,7 @@ feeds_opml_group_handler_finalize (GObject *object)
}
static gboolean
-feeds_opml_group_handler_check_format (FeedsGroupHandler *self, xmlDocPtr doc, xmlNodePtr cur)
+feeds_opml_group_handler_check_format (GrssFeedsGroupHandler *self, xmlDocPtr doc, xmlNodePtr cur)
{
if (!xmlStrcmp (cur->name, BAD_CAST"opml"))
return TRUE;
@@ -81,13 +81,13 @@ get_source_url (xmlNodePtr cur)
return tmp;
}
-static FeedChannel*
+static GrssFeedChannel*
import_parse_outline (xmlNodePtr cur)
{
xmlChar *tmp;
- FeedChannel *channel;
+ GrssFeedChannel *channel;
- channel = feed_channel_new ();
+ channel = grss_feed_channel_new ();
tmp = xmlGetProp (cur, BAD_CAST"title");
if (!tmp || !xmlStrcmp (tmp, BAD_CAST"")) {
@@ -97,19 +97,19 @@ import_parse_outline (xmlNodePtr cur)
}
if (tmp) {
- feed_channel_set_title (channel, (gchar*) tmp);
+ grss_feed_channel_set_title (channel, (gchar*) tmp);
xmlFree (tmp);
}
tmp = get_source_url (cur);
if (tmp) {
- feed_channel_set_source (channel, (gchar*) tmp);
+ grss_feed_channel_set_source (channel, (gchar*) tmp);
xmlFree (tmp);
tmp = xmlGetProp (cur, BAD_CAST"htmlUrl");
if (tmp && xmlStrcmp (tmp, BAD_CAST""))
- feed_channel_set_homepage (channel, (gchar*) tmp);
+ grss_feed_channel_set_homepage (channel, (gchar*) tmp);
xmlFree (tmp);
}
@@ -123,7 +123,7 @@ import_parse_body (xmlNodePtr n)
xmlChar *tmp;
GList *items;
GList *subitems;
- FeedChannel *outline;
+ GrssFeedChannel *outline;
xmlNodePtr cur;
cur = n->xmlChildrenNode;
@@ -191,7 +191,7 @@ import_parse_OPML (xmlNodePtr n)
}
static GList*
-feeds_opml_group_handler_parse (FeedsGroupHandler *self, xmlDocPtr doc, GError **error)
+feeds_opml_group_handler_parse (GrssFeedsGroupHandler *self, xmlDocPtr doc, GError **error)
{
xmlNodePtr cur;
GList *items;
@@ -217,7 +217,7 @@ feeds_opml_group_handler_parse (FeedsGroupHandler *self, xmlDocPtr doc, GError *
}
static gchar*
-feeds_opml_group_handler_dump (FeedsGroupHandler *self, GList *channels, GError **error)
+feeds_opml_group_handler_dump (GrssFeedsGroupHandler *self, GList *channels, GError **error)
{
/**
TODO
@@ -227,7 +227,7 @@ feeds_opml_group_handler_dump (FeedsGroupHandler *self, GList *channels, GError
}
static void
-feeds_group_handler_interface_init (FeedsGroupHandlerInterface *iface)
+grss_feeds_group_handler_interface_init (GrssFeedsGroupHandlerInterface *iface)
{
iface->check_format = feeds_opml_group_handler_check_format;
iface->parse = feeds_opml_group_handler_parse;
diff --git a/src/feeds-pool.c b/src/feeds-pool.c
index 931f509..3ddfa7e 100644
--- a/src/feeds-pool.c
+++ b/src/feeds-pool.c
@@ -23,31 +23,31 @@
#include "feed-parser.h"
#include "feed-marshal.h"
-#define FEEDS_POOL_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), FEEDS_POOL_TYPE, FeedsPoolPrivate))
+#define FEEDS_POOL_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), FEEDS_POOL_TYPE, GrssFeedsPoolPrivate))
/**
* SECTION: feeds-pool
* @short_description: feeds auto-fetcher
*
- * The #FeedsPool permits to automatically "listen" for more feeds: it
+ * The #GrssFeedsPool permits to automatically "listen" for more feeds: it
* provides to fetch them on regular intervals (as defined by
- * feed_channel_get_update_interval() for each channel), parse them with
- * #FeedParser, and emits signals when feeds are ready
+ * grss_feed_channel_get_update_interval() for each channel), parse them with
+ * #GrssFeedParser, and emits signals when feeds are ready
*/
-struct _FeedsPoolPrivate {
+struct _GrssFeedsPoolPrivate {
gboolean running;
GList *feeds_list;
SoupSession *soupsession;
- FeedParser *parser;
+ GrssFeedParser *parser;
guint scheduler;
};
typedef struct {
time_t next_fetch;
- FeedChannel *channel;
- FeedsPool *pool;
-} FeedChannelWrap;
+ GrssFeedChannel *channel;
+ GrssFeedsPool *pool;
+} GrssFeedChannelWrap;
enum {
FEED_FETCHING,
@@ -57,17 +57,17 @@ enum {
static guint signals [LAST_SIGNAL] = {0};
-G_DEFINE_TYPE (FeedsPool, feeds_pool, G_TYPE_OBJECT);
+G_DEFINE_TYPE (GrssFeedsPool, grss_feeds_pool, G_TYPE_OBJECT);
static void
-remove_currently_listened (FeedsPool *pool)
+remove_currently_listened (GrssFeedsPool *pool)
{
GList *iter;
- FeedChannelWrap *wrap;
+ GrssFeedChannelWrap *wrap;
if (pool->priv->feeds_list != NULL) {
for (iter = pool->priv->feeds_list; iter; iter = g_list_next (iter)) {
- wrap = (FeedChannelWrap*) iter->data;
+ wrap = (GrssFeedChannelWrap*) iter->data;
g_object_unref (wrap->channel);
g_free (wrap);
}
@@ -77,7 +77,7 @@ remove_currently_listened (FeedsPool *pool)
}
static void
-feed_handled_cb (FeedsPool *pool, FeedChannel *feed, GList *items)
+feed_handled_cb (GrssFeedsPool *pool, GrssFeedChannel *feed, GList *items)
{
GList *iter;
@@ -89,35 +89,35 @@ feed_handled_cb (FeedsPool *pool, FeedChannel *feed, GList *items)
}
static void
-feeds_pool_finalize (GObject *obj)
+grss_feeds_pool_finalize (GObject *obj)
{
- FeedsPool *pool;
+ GrssFeedsPool *pool;
pool = FEEDS_POOL (obj);
- feeds_pool_switch (pool, FALSE);
+ grss_feeds_pool_switch (pool, FALSE);
remove_currently_listened (pool);
g_object_unref (pool->priv->parser);
g_object_unref (pool->priv->soupsession);
}
static void
-feeds_pool_class_init (FeedsPoolClass *klass)
+grss_feeds_pool_class_init (GrssFeedsPoolClass *klass)
{
GObjectClass *gobject_class;
- g_type_class_add_private (klass, sizeof (FeedsPoolPrivate));
+ g_type_class_add_private (klass, sizeof (GrssFeedsPoolPrivate));
gobject_class = G_OBJECT_CLASS (klass);
- gobject_class->finalize = feeds_pool_finalize;
+ gobject_class->finalize = grss_feeds_pool_finalize;
klass->feed_ready = feed_handled_cb;
/**
- * FeedsPool::feed-fetching:
- * @pool: the #FeedsPool emitting the signal
- * @feed: the #FeedChannel which is going to be fetched
+ * GrssFeedsPool::feed-fetching:
+ * @pool: the #GrssFeedsPool emitting the signal
+ * @feed: the #GrssFeedChannel which is going to be fetched
*
- * Emitted when the @pool starts fetching a new #FeedChannel. To be
+ * Emitted when the @pool starts fetching a new #GrssFeedChannel. To be
* used to know the internal status of the component
*/
signals [FEED_FETCHING] = g_signal_new ("feed-fetching", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, 0,
@@ -125,12 +125,12 @@ feeds_pool_class_init (FeedsPoolClass *klass)
G_TYPE_NONE, 1, G_TYPE_OBJECT);
/**
- * FeedsPool::feed-ready:
- * @pool: the #FeedsPool emitting the signal
- * @feed: the #FeedChannel which has been fetched and parsed
- * @items: list of #FeedItem obtained parsing the feed
+ * GrssFeedsPool::feed-ready:
+ * @pool: the #GrssFeedsPool emitting the signal
+ * @feed: the #GrssFeedChannel which has been fetched and parsed
+ * @items: list of #GrssFeedItem obtained parsing the feed
*
- * Emitted when a #FeedChannel assigned to the @pool has been fetched
+ * Emitted when a #GrssFeedChannel assigned to the @pool has been fetched
* and parsed. All parsed items are exposed in the array, with no
* regards about previously existing elements. @items may be NULL, if
* an error occourred while fetching and/or parsing. List of @items
@@ -142,41 +142,41 @@ feeds_pool_class_init (FeedsPoolClass *klass)
}
static void
-feeds_pool_init (FeedsPool *node)
+grss_feeds_pool_init (GrssFeedsPool *node)
{
node->priv = FEEDS_POOL_GET_PRIVATE (node);
- memset (node->priv, 0, sizeof (FeedsPoolPrivate));
- node->priv->parser = feed_parser_new ();
+ memset (node->priv, 0, sizeof (GrssFeedsPoolPrivate));
+ node->priv->parser = grss_feed_parser_new ();
node->priv->soupsession = soup_session_async_new ();
}
/**
- * feeds_pool_new:
+ * grss_feeds_pool_new:
*
- * Allocates a new #FeedsPool
+ * Allocates a new #GrssFeedsPool
*
- * Return value: a new #FeedsPool
+ * Return value: a new #GrssFeedsPool
*/
-FeedsPool*
-feeds_pool_new ()
+GrssFeedsPool*
+grss_feeds_pool_new ()
{
return g_object_new (FEEDS_POOL_TYPE, NULL);
}
static void
-create_listened (FeedsPool *pool, GList *feeds)
+create_listened (GrssFeedsPool *pool, GList *feeds)
{
GList *list;
GList *iter;
- FeedChannel *feed;
- FeedChannelWrap *wrap;
+ GrssFeedChannel *feed;
+ GrssFeedChannelWrap *wrap;
list = NULL;
for (iter = feeds; iter; iter = g_list_next (iter)) {
feed = FEED_CHANNEL (iter->data);
- wrap = g_new0 (FeedChannelWrap, 1);
+ wrap = g_new0 (GrssFeedChannelWrap, 1);
g_object_ref (feed);
wrap->channel = feed;
wrap->pool = pool;
@@ -187,43 +187,43 @@ create_listened (FeedsPool *pool, GList *feeds)
}
/**
- * feeds_pool_listen:
- * @pool: a #FeedsPool
- * @feeds: a list of #FeedChannel
+ * grss_feeds_pool_listen:
+ * @pool: a #GrssFeedsPool
+ * @feeds: a list of #GrssFeedChannel
*
* To set the list of feeds to be managed by the pool. The previous list, if
- * any, is invalidated. After invokation to the function, feeds_pool_switch()
+ * any, is invalidated. After invokation to the function, grss_feeds_pool_switch()
* must be call to run the auto-fetching (always, also if previous state was
* "running").
- * The list in @feeds can be freed after calling this; linked #FeedChannel
+ * The list in @feeds can be freed after calling this; linked #GrssFeedChannel
* are g_object_ref'd here
*/
void
-feeds_pool_listen (FeedsPool *pool, GList *feeds)
+grss_feeds_pool_listen (GrssFeedsPool *pool, GList *feeds)
{
gboolean original_status;
original_status = pool->priv->running;
- feeds_pool_switch (pool, FALSE);
+ grss_feeds_pool_switch (pool, FALSE);
remove_currently_listened (pool);
create_listened (pool, feeds);
- feeds_pool_switch (pool, original_status);
+ grss_feeds_pool_switch (pool, original_status);
}
/**
- * feeds_pool_get_listened:
- * @pool: a #FeedsPool
+ * grss_feeds_pool_get_listened:
+ * @pool: a #GrssFeedsPool
*
* Returns the list of feeds currently managed by the @pool. Please consider
* this function has to build the list that returns, and of course this is a
* time and resources consuming task: if you only need to know how many feeds
- * are currently handled, check feeds_pool_get_listened_num()
+ * are currently handled, check grss_feeds_pool_get_listened_num()
*
- * Return value: a list of #FeedChannel, to be freed with g_list_free() when
+ * Return value: a list of #GrssFeedChannel, to be freed with g_list_free() when
* no longer in use. Do not modify elements found in this list
*/
GList*
-feeds_pool_get_listened (FeedsPool *pool)
+grss_feeds_pool_get_listened (GrssFeedsPool *pool)
{
GList *ret;
GList *iter;
@@ -231,23 +231,23 @@ feeds_pool_get_listened (FeedsPool *pool)
ret = NULL;
for (iter = pool->priv->feeds_list; iter; iter = g_list_next (iter))
- ret = g_list_prepend (ret, ((FeedChannelWrap*)iter->data)->channel);
+ ret = g_list_prepend (ret, ((GrssFeedChannelWrap*)iter->data)->channel);
return g_list_reverse (ret);
}
/**
- * feeds_pool_get_listened:
- * @pool: a #FeedsPool
+ * grss_feeds_pool_get_listened:
+ * @pool: a #GrssFeedsPool
*
* Returns number of feeds under the @pool control, as provided by
- * feeds_pool_listen(). To get the complete list of those feeds, check
- * feeds_pool_get_listened()
+ * grss_feeds_pool_listen(). To get the complete list of those feeds, check
+ * grss_feeds_pool_get_listened()
*
- * Return value: number of feeds currently managed by the #FeedsPool
+ * Return value: number of feeds currently managed by the #GrssFeedsPool
*/
int
-feeds_pool_get_listened_num (FeedsPool *pool)
+grss_feeds_pool_get_listened_num (GrssFeedsPool *pool)
{
if (pool->priv->feeds_list == NULL)
return 0;
@@ -262,29 +262,29 @@ feed_downloaded (SoupSession *session, SoupMessage *msg, gpointer user_data)
GList *items;
GError *error;
xmlDocPtr doc;
- FeedChannelWrap *feed;
+ GrssFeedChannelWrap *feed;
- feed = (FeedChannelWrap*) user_data;
+ feed = (GrssFeedChannelWrap*) user_data;
if (feed->pool->priv->running == FALSE)
return;
items = NULL;
- feed->next_fetch = time (NULL) + (feed_channel_get_update_interval (feed->channel) * 60);
+ feed->next_fetch = time (NULL) + (grss_feed_channel_get_update_interval (feed->channel) * 60);
g_object_get (msg, "status-code", &status, NULL);
if (status < 200 || status > 299) {
- g_warning ("Unable to download from %s", feed_channel_get_source (feed->channel));
+ g_warning ("Unable to download from %s", grss_feed_channel_get_source (feed->channel));
}
else {
doc = content_to_xml ((const gchar*) msg->response_body->data, msg->response_body->length);
if (doc != NULL) {
error = NULL;
- items = feed_parser_parse (feed->pool->priv->parser, feed->channel, doc, &error);
+ items = grss_feed_parser_parse (feed->pool->priv->parser, feed->channel, doc, &error);
xmlFreeDoc (doc);
if (items == NULL && error) {
- g_warning ("Unable to parse feed at %s: %s", feed_channel_get_source (feed->channel), error->message);
+ g_warning ("Unable to parse feed at %s: %s", grss_feed_channel_get_source (feed->channel), error->message);
g_error_free (error);
}
}
@@ -294,12 +294,12 @@ feed_downloaded (SoupSession *session, SoupMessage *msg, gpointer user_data)
}
static void
-fetch_feed (FeedChannelWrap *feed)
+fetch_feed (GrssFeedChannelWrap *feed)
{
SoupMessage *msg;
g_signal_emit (feed->pool, signals [FEED_FETCHING], 0, feed->channel, NULL);
- msg = soup_message_new ("GET", feed_channel_get_source (feed->channel));
+ msg = soup_message_new ("GET", grss_feed_channel_get_source (feed->channel));
soup_session_queue_message (feed->pool->priv->soupsession, msg, feed_downloaded, feed);
}
@@ -308,10 +308,10 @@ fetch_feeds (gpointer data)
{
time_t now;
GList *iter;
- FeedsPool *pool;
- FeedChannelWrap *feed;
+ GrssFeedsPool *pool;
+ GrssFeedChannelWrap *feed;
- pool = (FeedsPool*) data;
+ pool = (GrssFeedsPool*) data;
if (pool->priv->running == FALSE) {
return FALSE;
@@ -320,7 +320,7 @@ fetch_feeds (gpointer data)
now = time (NULL);
for (iter = pool->priv->feeds_list; iter; iter = g_list_next (iter)) {
- feed = (FeedChannelWrap*) iter->data;
+ feed = (GrssFeedChannelWrap*) iter->data;
if (feed->next_fetch <= now)
fetch_feed (feed);
}
@@ -329,12 +329,12 @@ fetch_feeds (gpointer data)
}
static void
-run_scheduler (FeedsPool *pool)
+run_scheduler (GrssFeedsPool *pool)
{
int interval;
int min_interval;
GList *iter;
- FeedChannelWrap *feed;
+ GrssFeedChannelWrap *feed;
if (pool->priv->feeds_list == NULL)
return;
@@ -342,12 +342,12 @@ run_scheduler (FeedsPool *pool)
min_interval = G_MAXINT;
for (iter = pool->priv->feeds_list; iter; iter = g_list_next (iter)) {
- feed = (FeedChannelWrap*) iter->data;
- interval = feed_channel_get_update_interval (feed->channel);
+ feed = (GrssFeedChannelWrap*) iter->data;
+ interval = grss_feed_channel_get_update_interval (feed->channel);
if (interval == 0) {
interval = 30;
- feed_channel_set_update_interval (feed->channel, interval);
+ grss_feed_channel_set_update_interval (feed->channel, interval);
}
if (min_interval > interval)
@@ -361,15 +361,15 @@ run_scheduler (FeedsPool *pool)
}
/**
- * feeds_pool_switch:
- * @pool: a #FeedsPool
+ * grss_feeds_pool_switch:
+ * @pool: a #GrssFeedsPool
* @run: TRUE to run the pool, FALSE to pause it
*
* Permits to pause or resume the @pool fetching feeds. If @run is #TRUE, the
* @pool starts immediately
*/
void
-feeds_pool_switch (FeedsPool *pool, gboolean run)
+grss_feeds_pool_switch (GrssFeedsPool *pool, gboolean run)
{
if (pool->priv->running != run) {
pool->priv->running = run;
@@ -385,15 +385,15 @@ feeds_pool_switch (FeedsPool *pool, gboolean run)
}
/**
- * feeds_pool_get_session:
- * @pool: a #FeedsPool
+ * grss_feeds_pool_get_session:
+ * @pool: a #GrssFeedsPool
*
* To access the internal #SoupSession used by the @pool to fetch items
*
* Return value: istance of #SoupSession. Do not free it
*/
SoupSession*
-feeds_pool_get_session (FeedsPool *pool)
+grss_feeds_pool_get_session (GrssFeedsPool *pool)
{
return pool->priv->soupsession;
}
diff --git a/src/feeds-pool.h b/src/feeds-pool.h
index 204b925..f8a24be 100644
--- a/src/feeds-pool.h
+++ b/src/feeds-pool.h
@@ -23,36 +23,36 @@
#include "libgrss.h"
-#define FEEDS_POOL_TYPE (feeds_pool_get_type())
-#define FEEDS_POOL(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FEEDS_POOL_TYPE, FeedsPool))
-#define FEEDS_POOL_CLASS(c) (G_TYPE_CHECK_CLASS_CAST ((c), FEEDS_POOL_TYPE, FeedsPoolClass))
+#define FEEDS_POOL_TYPE (grss_feeds_pool_get_type())
+#define FEEDS_POOL(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FEEDS_POOL_TYPE, GrssFeedsPool))
+#define FEEDS_POOL_CLASS(c) (G_TYPE_CHECK_CLASS_CAST ((c), FEEDS_POOL_TYPE, GrssFeedsPoolClass))
#define IS_FEEDS_POOL(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FEEDS_POOL_TYPE))
#define IS_FEEDS_POOL_CLASS(c) (G_TYPE_CHECK_CLASS_TYPE ((c), FEEDS_POOL_TYPE))
-#define FEEDS_POOL_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FEEDS_POOL_TYPE, FeedsPoolClass))
+#define FEEDS_POOL_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FEEDS_POOL_TYPE, GrssFeedsPoolClass))
-typedef struct _FeedsPool FeedsPool;
-typedef struct _FeedsPoolPrivate FeedsPoolPrivate;
+typedef struct _GrssFeedsPool GrssFeedsPool;
+typedef struct _GrssFeedsPoolPrivate GrssFeedsPoolPrivate;
-struct _FeedsPool {
+struct _GrssFeedsPool {
GObject parent;
- FeedsPoolPrivate *priv;
+ GrssFeedsPoolPrivate *priv;
};
typedef struct {
GObjectClass parent;
- void (*feed_fetching) (FeedsPool *pool, FeedChannel *feed);
- void (*feed_ready) (FeedsPool *pool, FeedChannel *feed, GList *items);
-} FeedsPoolClass;
+ void (*feed_fetching) (GrssFeedsPool *pool, GrssFeedChannel *feed);
+ void (*feed_ready) (GrssFeedsPool *pool, GrssFeedChannel *feed, GList *items);
+} GrssFeedsPoolClass;
-GType feeds_pool_get_type () G_GNUC_CONST;
+GType grss_feeds_pool_get_type () G_GNUC_CONST;
-FeedsPool* feeds_pool_new ();
+GrssFeedsPool* grss_feeds_pool_new ();
-void feeds_pool_listen (FeedsPool *pool, GList *feeds);
-GList* feeds_pool_get_listened (FeedsPool *pool);
-int feeds_pool_get_listened_num (FeedsPool *pool);
-void feeds_pool_switch (FeedsPool *pool, gboolean run);
-SoupSession* feeds_pool_get_session (FeedsPool *pool);
+void grss_feeds_pool_listen (GrssFeedsPool *pool, GList *feeds);
+GList* grss_feeds_pool_get_listened (GrssFeedsPool *pool);
+int grss_feeds_pool_get_listened_num (GrssFeedsPool *pool);
+void grss_feeds_pool_switch (GrssFeedsPool *pool, gboolean run);
+SoupSession* grss_feeds_pool_get_session (GrssFeedsPool *pool);
#endif /* __FEEDS_POOL_H__ */
diff --git a/src/feeds-publisher.c b/src/feeds-publisher.c
index ecdcca7..c2036a7 100644
--- a/src/feeds-publisher.c
+++ b/src/feeds-publisher.c
@@ -27,13 +27,13 @@
#define DEFAULT_SERVER_PORT 80
#define DEFAULT_REFRESH_CHECK_INTERVAL 60
-#define FEEDS_PUBLISHER_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), FEEDS_PUBLISHER_TYPE, FeedsPublisherPrivate))
+#define FEEDS_PUBLISHER_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), FEEDS_PUBLISHER_TYPE, GrssFeedsPublisherPrivate))
/**
* SECTION: feeds-publisher
* @short_description: feed writer and PubSubHubbub publisher
*
- * #FeedsPublisher may be used to expose contents for any given #FeedChannel,
+ * #GrssFeedsPublisher may be used to expose contents for any given #GrssFeedChannel,
* both writing a file to be dispatched by the local webserver or providing
* himself to distribute it, and implements a server able to receive
* subscriptions by PubSubHubbub clients and deliver them new contents in
@@ -43,7 +43,7 @@
static void subscribe_verify_cb (SoupSession *session, SoupMessage *msg, gpointer user_data);
static void verify_delivery_cb (SoupSession *session, SoupMessage *msg, gpointer user_data);
-struct _FeedsPublisherPrivate {
+struct _GrssFeedsPublisherPrivate {
gboolean running;
int port;
@@ -58,7 +58,7 @@ struct _FeedsPublisherPrivate {
};
typedef struct {
- FeedChannel *channel;
+ GrssFeedChannel *channel;
GList *subscribers;
GList *items_delivered;
guint resend_handler;
@@ -70,7 +70,7 @@ typedef enum {
} SUBSCRIBER_STATUS;
typedef struct {
- FeedsPublisher *parent;
+ GrssFeedsPublisher *parent;
SUBSCRIBER_STATUS status;
gchar *topic;
ValidTopic *topic_struct;
@@ -91,7 +91,7 @@ enum {
static guint signals [LAST_SIGNAL] = {0};
-G_DEFINE_TYPE (FeedsPublisher, feeds_publisher, G_TYPE_OBJECT);
+G_DEFINE_TYPE (GrssFeedsPublisher, grss_feeds_publisher, G_TYPE_OBJECT);
static void
destroy_remote_subscriber (RemoteSubscriber *client)
@@ -136,37 +136,37 @@ topic_remove_helper (gpointer key, gpointer value, gpointer user_data)
}
static void
-remove_current_topics (FeedsPublisher *pub)
+remove_current_topics (GrssFeedsPublisher *pub)
{
g_hash_table_foreach_remove (pub->priv->topics, topic_remove_helper, NULL);
}
static void
-feeds_publisher_finalize (GObject *obj)
+grss_feeds_publisher_finalize (GObject *obj)
{
- FeedsPublisher *pub;
+ GrssFeedsPublisher *pub;
pub = FEEDS_PUBLISHER (obj);
- feeds_publisher_hub_switch (pub, FALSE);
+ grss_feeds_publisher_hub_switch (pub, FALSE);
remove_current_topics (pub);
g_hash_table_destroy (pub->priv->topics);
}
static void
-feeds_publisher_class_init (FeedsPublisherClass *klass)
+grss_feeds_publisher_class_init (GrssFeedsPublisherClass *klass)
{
GObjectClass *gobject_class;
- g_type_class_add_private (klass, sizeof (FeedsPublisherPrivate));
+ g_type_class_add_private (klass, sizeof (GrssFeedsPublisherPrivate));
gobject_class = G_OBJECT_CLASS (klass);
- gobject_class->finalize = feeds_publisher_finalize;
+ gobject_class->finalize = grss_feeds_publisher_finalize;
/**
- * FeedsSubscriber::new_subscription:
- * @pub: the #FeedsPublisher emitting the signal
- * @topic: #FeedChannel for which subscription has been added
+ * GrssFeedsSubscriber::new_subscription:
+ * @pub: the #GrssFeedsPublisher emitting the signal
+ * @topic: #GrssFeedChannel for which subscription has been added
* @callback: callback required for new subscriber
*
* Emitted when a new remote client subscribes to this publisher
@@ -176,9 +176,9 @@ feeds_publisher_class_init (FeedsPublisherClass *klass)
G_TYPE_NONE, 2, FEED_CHANNEL_TYPE, G_TYPE_STRING);
/**
- * FeedsSubscriber::new_subscription:
- * @pub: the #FeedsPublisher emitting the signal
- * @topic: #FeedChannel for which subscription has been removed
+ * GrssFeedsSubscriber::new_subscription:
+ * @pub: the #GrssFeedsPublisher emitting the signal
+ * @topic: #GrssFeedChannel for which subscription has been removed
* @callback: callback revoked by the subscriber
*
* Emitted when a new remote client unsubscribes to this publisher
@@ -189,29 +189,29 @@ feeds_publisher_class_init (FeedsPublisherClass *klass)
}
static void
-feeds_publisher_init (FeedsPublisher *node)
+grss_feeds_publisher_init (GrssFeedsPublisher *node)
{
node->priv = FEEDS_PUBLISHER_GET_PRIVATE (node);
- memset (node->priv, 0, sizeof (FeedsPublisherPrivate));
+ memset (node->priv, 0, sizeof (GrssFeedsPublisherPrivate));
node->priv->port = DEFAULT_SERVER_PORT;
node->priv->topics = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, destroy_topic);
}
/**
- * feeds_publisher_new:
+ * grss_feeds_publisher_new:
*
- * Allocates a new #FeedsPublisher
+ * Allocates a new #GrssFeedsPublisher
*
- * Return value: a new #FeedsPublisher
+ * Return value: a new #GrssFeedsPublisher
*/
-FeedsPublisher*
-feeds_publisher_new ()
+GrssFeedsPublisher*
+grss_feeds_publisher_new ()
{
return g_object_new (FEEDS_PUBLISHER_TYPE, NULL);
}
static gchar*
-format_feed_text (FeedsPublisher *pub, FeedChannel *channel, GList *items)
+format_feed_text (GrssFeedsPublisher *pub, GrssFeedChannel *channel, GList *items)
{
const gchar *str;
gchar *formatted;
@@ -219,50 +219,50 @@ format_feed_text (FeedsPublisher *pub, FeedChannel *channel, GList *items)
GList *iter;
const GList *list;
GString *text;
- FeedItem *item;
+ GrssFeedItem *item;
text = g_string_new ("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<feed xmlns=\"http://www.w3.org/2005/Atom\";>\n");
- str = feed_channel_get_title (channel);
+ str = grss_feed_channel_get_title (channel);
if (str != NULL)
g_string_append_printf (text, "<title>%s</title>\n", str);
- str = feed_channel_get_description (channel);
+ str = grss_feed_channel_get_description (channel);
if (str != NULL)
g_string_append_printf (text, "<subtitle>%s</subtitle>\n", str);
- str = feed_channel_get_homepage (channel);
+ str = grss_feed_channel_get_homepage (channel);
if (str != NULL)
g_string_append_printf (text, "<link href=\"%s\" />\n", str);
- str = feed_channel_get_copyright (channel);
+ str = grss_feed_channel_get_copyright (channel);
if (str != NULL)
g_string_append_printf (text, "<author>%s</author>\n", str);
- str = feed_channel_get_editor (channel);
+ str = grss_feed_channel_get_editor (channel);
if (str != NULL)
g_string_append_printf (text, "<rights>%s</rights>\n", str);
- str = feed_channel_get_generator (channel);
+ str = grss_feed_channel_get_generator (channel);
if (str != NULL)
g_string_append_printf (text, "<generator>%s</generator>\n", str);
- list = feed_channel_get_contributors (channel);
+ list = grss_feed_channel_get_contributors (channel);
while (list != NULL) {
g_string_append_printf (text, "<contributor>%s</contributor>\n", (gchar*) list->data);
list = list->next;
}
- date = feed_channel_get_update_time (channel);
+ date = grss_feed_channel_get_update_time (channel);
formatted = date_to_ISO8601 (date);
g_string_append_printf (text, "<updated>%s</updated>\n", formatted);
g_free (formatted);
- str = feed_channel_get_icon (channel);
+ str = grss_feed_channel_get_icon (channel);
if (str != NULL)
g_string_append_printf (text, "<icon>%s</icon>\n", str);
- str = feed_channel_get_image (channel);
+ str = grss_feed_channel_get_image (channel);
if (str != NULL)
g_string_append_printf (text, "<logo>%s</logo>\n", str);
@@ -271,37 +271,37 @@ format_feed_text (FeedsPublisher *pub, FeedChannel *channel, GList *items)
g_string_append (text, "\t<entry>\n");
- str = feed_item_get_title (item);
+ str = grss_feed_item_get_title (item);
if (str != NULL)
g_string_append_printf (text, "\t<title>%s</title>\n", str);
- str = feed_item_get_id (item);
+ str = grss_feed_item_get_id (item);
if (str != NULL)
g_string_append_printf (text, "\t<id>%s</id>\n", str);
- str = feed_item_get_source (item);
+ str = grss_feed_item_get_source (item);
if (str != NULL)
g_string_append_printf (text, "<link href=\"%s\" />\n", str);
- str = feed_item_get_description (item);
+ str = grss_feed_item_get_description (item);
if (str != NULL)
g_string_append_printf (text, "\t<summary>%s</summary>\n", str);
- str = feed_item_get_author (item);
+ str = grss_feed_item_get_author (item);
if (str != NULL)
g_string_append_printf (text, "\t<author>%s</author>\n", str);
- str = feed_item_get_copyright (item);
+ str = grss_feed_item_get_copyright (item);
if (str != NULL)
g_string_append_printf (text, "\t<rights>%s</rights>\n", str);
- list = feed_item_get_contributors (item);
+ list = grss_feed_item_get_contributors (item);
while (list != NULL) {
g_string_append_printf (text, "\t<contributor>%s</contributor>\n", (gchar*) list->data);
list = list->next;
}
- date = feed_item_get_publish_time (item);
+ date = grss_feed_item_get_publish_time (item);
formatted = date_to_ISO8601 (date);
g_string_append_printf (text, "<published>%s</published>\n", formatted);
g_free (formatted);
@@ -372,7 +372,7 @@ verify_delivery_cb (SoupSession *session, SoupMessage *msg, gpointer user_data)
}
static void
-deliver_to_subscribers (FeedsPublisher *pub, FeedChannel *channel, GList *items)
+deliver_to_subscribers (GrssFeedsPublisher *pub, GrssFeedChannel *channel, GList *items)
{
gboolean found;
gchar *text;
@@ -385,21 +385,21 @@ deliver_to_subscribers (FeedsPublisher *pub, FeedChannel *channel, GList *items)
RemoteSubscriber *client;
ValidTopic *topic;
- topic = g_hash_table_lookup (pub->priv->topics, feed_channel_get_source (channel));
+ topic = g_hash_table_lookup (pub->priv->topics, grss_feed_channel_get_source (channel));
if (topic == NULL || topic->subscribers == NULL)
return;
to_deliver = NULL;
for (oiter = items; oiter; oiter = oiter->next) {
- olink = feed_item_get_source (oiter->data);
+ olink = grss_feed_item_get_source (oiter->data);
if (olink == NULL)
continue;
found = FALSE;
for (iiter = topic->items_delivered; iiter; iiter = iiter->next) {
- ilink = feed_item_get_source (iiter->data);
+ ilink = grss_feed_item_get_source (iiter->data);
if (strcmp (ilink, olink) == 0) {
found = TRUE;
@@ -474,18 +474,18 @@ feed_required_by_web_cb (SoupServer *server, SoupMessage *msg, const char *path,
}
/**
- * feeds_publisher_publish:
- * @pub: a #FeedsPublisher
- * @channel: the #FeedChannel to dump in the file
- * @items: list of #FeedItems to be added in the feed
+ * grss_feeds_publisher_publish:
+ * @pub: a #GrssFeedsPublisher
+ * @channel: the #GrssFeedChannel to dump in the file
+ * @items: list of #GrssFeedItems to be added in the feed
* @id: name used in the external URL of the feed
*
* If the local web server has been executed (with
- * feeds_publisher_hub_switch()) this function exposes the given @channel as
+ * grss_feeds_publisher_hub_switch()) this function exposes the given @channel as
* an Atom formatted file avalable to http://[LOCAL_IP:DEFINED_PORT]/@id
*/
void
-feeds_publisher_publish (FeedsPublisher *pub, FeedChannel *channel, GList *items, const gchar *id)
+grss_feeds_publisher_publish (GrssFeedsPublisher *pub, GrssFeedChannel *channel, GList *items, const gchar *id)
{
gchar *path;
GFile *file;
@@ -500,9 +500,9 @@ feeds_publisher_publish (FeedsPublisher *pub, FeedChannel *channel, GList *items
path = g_strdup_printf ("file://%s/libgrss/activefeeds/%s", g_get_tmp_dir (), id);
/*
- PubSubHubbub notifies are already delivered by feeds_publisher_publish_file()
+ PubSubHubbub notifies are already delivered by grss_feeds_publisher_publish_file()
*/
- feeds_publisher_publish_file (pub, channel, items, (const gchar*) path);
+ grss_feeds_publisher_publish_file (pub, channel, items, (const gchar*) path);
file = g_file_new_for_uri (path);
soup_server_add_handler (pub->priv->server, id, feed_required_by_web_cb, file, g_object_unref);
@@ -511,19 +511,19 @@ feeds_publisher_publish (FeedsPublisher *pub, FeedChannel *channel, GList *items
}
/**
- * feeds_publisher_publish_file:
- * @pub: a #FeedsPublisher
- * @channel: the #FeedChannel to dump in the file
- * @items: list of #FeedItems to be added in the feed
+ * grss_feeds_publisher_publish_file:
+ * @pub: a #GrssFeedsPublisher
+ * @channel: the #GrssFeedChannel to dump in the file
+ * @items: list of #GrssFeedItems to be added in the feed
* @path: path of the file to write
*
* Dump the given @channel in an Atom formatted file in @path. If the local
- * PubSubHubbub hub has been activated (with feeds_publisher_hub_switch())
+ * PubSubHubbub hub has been activated (with grss_feeds_publisher_hub_switch())
* notifies remote subscribers about the new items which has been added since
- * previous invocation of this function for the same #FeedChannel
+ * previous invocation of this function for the same #GrssFeedChannel
*/
void
-feeds_publisher_publish_file (FeedsPublisher *pub, FeedChannel *channel, GList *items, const gchar *uri)
+grss_feeds_publisher_publish_file (GrssFeedsPublisher *pub, GrssFeedChannel *channel, GList *items, const gchar *uri)
{
gchar *text;
GFile *file;
@@ -543,7 +543,7 @@ feeds_publisher_publish_file (FeedsPublisher *pub, FeedChannel *channel, GList *
}
static void
-add_client_to_topic (FeedsPublisher *pub, RemoteSubscriber *client)
+add_client_to_topic (GrssFeedsPublisher *pub, RemoteSubscriber *client)
{
ValidTopic *topic;
@@ -562,7 +562,7 @@ add_client_to_topic (FeedsPublisher *pub, RemoteSubscriber *client)
}
static void
-remove_client_to_topic (FeedsPublisher *pub, RemoteSubscriber *client)
+remove_client_to_topic (GrssFeedsPublisher *pub, RemoteSubscriber *client)
{
GList *iter;
ValidTopic *topic;
@@ -697,7 +697,7 @@ subscribe_verify_cb (SoupSession *session, SoupMessage *msg, gpointer user_data)
}
static RemoteSubscriber*
-search_subscriber_by_topic_and_callback (FeedsPublisher *pub, gchar *topic, gchar *callback)
+search_subscriber_by_topic_and_callback (GrssFeedsPublisher *pub, gchar *topic, gchar *callback)
{
GList *iter;
ValidTopic *topic_test;
@@ -733,7 +733,7 @@ handle_incoming_requests_cb (SoupServer *server, SoupMessage *msg, const char *p
gchar *callback;
gchar *verify;
SoupMessage *verify_msg;
- FeedsPublisher *pub;
+ GrssFeedsPublisher *pub;
RemoteSubscriber *client;
ValidTopic *topic_struct;
@@ -821,7 +821,7 @@ handle_incoming_requests_cb (SoupServer *server, SoupMessage *msg, const char *p
}
static void
-close_server (FeedsPublisher *pub)
+close_server (GrssFeedsPublisher *pub)
{
if (pub->priv->server != NULL) {
soup_server_remove_handler (pub->priv->server, NULL);
@@ -832,7 +832,7 @@ close_server (FeedsPublisher *pub)
}
static void
-create_and_run_server (FeedsPublisher *pub)
+create_and_run_server (GrssFeedsPublisher *pub)
{
SoupAddress *soup_addr;
@@ -848,8 +848,8 @@ create_and_run_server (FeedsPublisher *pub)
}
/**
- * feeds_publisher_hub_set_port:
- * @pub: a #FeedsPublisher
+ * grss_feeds_publisher_hub_set_port:
+ * @pub: a #GrssFeedsPublisher
* @port: new listening port for the server
*
* To customize the port opened by the local server to deliver feeds and
@@ -857,32 +857,32 @@ create_and_run_server (FeedsPublisher *pub)
* while the hub is running imply restart the local server
*/
void
-feeds_publisher_hub_set_port (FeedsPublisher *pub, int port)
+grss_feeds_publisher_hub_set_port (GrssFeedsPublisher *pub, int port)
{
if (port != pub->priv->port) {
pub->priv->port = port;
if (pub->priv->running == TRUE) {
- feeds_publisher_hub_switch (pub, FALSE);
- feeds_publisher_hub_switch (pub, TRUE);
+ grss_feeds_publisher_hub_switch (pub, FALSE);
+ grss_feeds_publisher_hub_switch (pub, TRUE);
}
}
}
/**
- * feeds_publisher_hub_set_topics:
- * @pub: a #FeedsPublisher
- * @topics: a list of #FeedChannels
+ * grss_feeds_publisher_hub_set_topics:
+ * @pub: a #GrssFeedsPublisher
+ * @topics: a list of #GrssFeedChannels
*
- * To define a list of valid "topics" for which the #FeedsPublisher will
+ * To define a list of valid "topics" for which the #GrssFeedsPublisher will
* deliver contents. Sources of those channels, as retrieved by
- * feed_channel_get_source(), are accepted as "hub.topic" parameter in
+ * grss_feed_channel_get_source(), are accepted as "hub.topic" parameter in
* PubSubHubbub registration requests from remote subscribers.
* Pay attention to the fact subscriptions requests for different topic are
* now rejected
*/
void
-feeds_publisher_hub_set_topics (FeedsPublisher *pub, GList *topics)
+grss_feeds_publisher_hub_set_topics (GrssFeedsPublisher *pub, GList *topics)
{
GList *iter;
ValidTopic *topic;
@@ -893,7 +893,7 @@ feeds_publisher_hub_set_topics (FeedsPublisher *pub, GList *topics)
topic = g_new0 (ValidTopic, 1);
topic->channel = g_object_ref (iter->data);
topic->resend_handler = -1;
- g_hash_table_insert (pub->priv->topics, (gpointer) feed_channel_get_source (iter->data), topic);
+ g_hash_table_insert (pub->priv->topics, (gpointer) grss_feed_channel_get_source (iter->data), topic);
}
}
@@ -902,7 +902,7 @@ refresh_subscribers_in_topic (gpointer key, gpointer value, gpointer user_data)
{
GList *iter;
SoupMessage *verify_msg;
- FeedsPublisher *pub;
+ GrssFeedsPublisher *pub;
ValidTopic *topic;
RemoteSubscriber *client;
@@ -922,7 +922,7 @@ refresh_subscribers_in_topic (gpointer key, gpointer value, gpointer user_data)
static gboolean
refresh_subscribers (gpointer user_data)
{
- FeedsPublisher *pub;
+ GrssFeedsPublisher *pub;
pub = user_data;
pub->priv->current_time = time (NULL);
@@ -932,26 +932,26 @@ refresh_subscribers (gpointer user_data)
}
static void
-install_refresh_handler (FeedsPublisher *pub)
+install_refresh_handler (GrssFeedsPublisher *pub)
{
pub->priv->refresh_handler = g_timeout_add_seconds (DEFAULT_REFRESH_CHECK_INTERVAL, refresh_subscribers, pub);
}
static void
-remove_refresh_handler (FeedsPublisher *pub)
+remove_refresh_handler (GrssFeedsPublisher *pub)
{
g_source_remove (pub->priv->refresh_handler);
}
/**
- * feeds_publisher_hub_switch:
- * @pub: a #FeedsPublisher
+ * grss_feeds_publisher_hub_switch:
+ * @pub: a #GrssFeedsPublisher
* @run: TRUE to run the local server, FALSE to stop it
*
* Permits to start and stop the webserver implemented by this object
*/
void
-feeds_publisher_hub_switch (FeedsPublisher *pub, gboolean run)
+grss_feeds_publisher_hub_switch (GrssFeedsPublisher *pub, gboolean run)
{
if (pub->priv->running != run) {
pub->priv->running = run;
diff --git a/src/feeds-publisher.h b/src/feeds-publisher.h
index 001896d..9024d34 100644
--- a/src/feeds-publisher.h
+++ b/src/feeds-publisher.h
@@ -23,37 +23,37 @@
#include "libgrss.h"
-#define FEEDS_PUBLISHER_TYPE (feeds_publisher_get_type())
-#define FEEDS_PUBLISHER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FEEDS_PUBLISHER_TYPE, FeedsPublisher))
-#define FEEDS_PUBLISHER_CLASS(c) (G_TYPE_CHECK_CLASS_CAST ((c), FEEDS_PUBLISHER_TYPE, FeedsPublisherClass))
+#define FEEDS_PUBLISHER_TYPE (grss_feeds_publisher_get_type())
+#define FEEDS_PUBLISHER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FEEDS_PUBLISHER_TYPE, GrssFeedsPublisher))
+#define FEEDS_PUBLISHER_CLASS(c) (G_TYPE_CHECK_CLASS_CAST ((c), FEEDS_PUBLISHER_TYPE, GrssFeedsPublisherClass))
#define IS_FEEDS_PUBLISHER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FEEDS_PUBLISHER_TYPE))
#define IS_FEEDS_PUBLISHER_CLASS(c) (G_TYPE_CHECK_CLASS_TYPE ((c), FEEDS_PUBLISHER_TYPE))
-#define FEEDS_PUBLISHER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FEEDS_PUBLISHER_TYPE, FeedsPublisherClass))
+#define FEEDS_PUBLISHER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FEEDS_PUBLISHER_TYPE, GrssFeedsPublisherClass))
-typedef struct _FeedsPublisher FeedsPublisher;
-typedef struct _FeedsPublisherPrivate FeedsPublisherPrivate;
+typedef struct _GrssFeedsPublisher GrssFeedsPublisher;
+typedef struct _GrssFeedsPublisherPrivate GrssFeedsPublisherPrivate;
-struct _FeedsPublisher {
+struct _GrssFeedsPublisher {
GObject parent;
- FeedsPublisherPrivate *priv;
+ GrssFeedsPublisherPrivate *priv;
};
typedef struct {
GObjectClass parent;
- void (*new_subscription) (FeedsPublisher *pub, FeedChannel *topic, gchar *callback);
- void (*delete_subscription) (FeedsPublisher *pub, FeedChannel *topic, gchar *callback);
-} FeedsPublisherClass;
+ void (*new_subscription) (GrssFeedsPublisher *pub, GrssFeedChannel *topic, gchar *callback);
+ void (*delete_subscription) (GrssFeedsPublisher *pub, GrssFeedChannel *topic, gchar *callback);
+} GrssFeedsPublisherClass;
-GType feeds_publisher_get_type () G_GNUC_CONST;
+GType grss_feeds_publisher_get_type () G_GNUC_CONST;
-FeedsPublisher* feeds_publisher_new ();
+GrssFeedsPublisher* grss_feeds_publisher_new ();
-void feeds_publisher_publish (FeedsPublisher *pub, FeedChannel *channel, GList *items, const gchar *id);
-void feeds_publisher_publish_file (FeedsPublisher *pub, FeedChannel *channel, GList *items, const gchar *uri);
+void grss_feeds_publisher_publish (GrssFeedsPublisher *pub, GrssFeedChannel *channel, GList *items, const gchar *id);
+void grss_feeds_publisher_publish_file (GrssFeedsPublisher *pub, GrssFeedChannel *channel, GList *items, const gchar *uri);
-void feeds_publisher_hub_set_port (FeedsPublisher *pub, int port);
-void feeds_publisher_hub_set_topics (FeedsPublisher *pub, GList *topics);
-void feeds_publisher_hub_switch (FeedsPublisher *pub, gboolean run);
+void grss_feeds_publisher_hub_set_port (GrssFeedsPublisher *pub, int port);
+void grss_feeds_publisher_hub_set_topics (GrssFeedsPublisher *pub, GList *topics);
+void grss_feeds_publisher_hub_switch (GrssFeedsPublisher *pub, gboolean run);
#endif /* __FEEDS_PUBLISHER_H__ */
diff --git a/src/feeds-store.c b/src/feeds-store.c
index fd8da7e..9f33d5a 100644
--- a/src/feeds-store.c
+++ b/src/feeds-store.c
@@ -21,32 +21,32 @@
#include "utils.h"
#include "feeds-pool.h"
-#define FEEDS_STORE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), FEEDS_STORE_TYPE, FeedsStorePrivate))
+#define FEEDS_STORE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), FEEDS_STORE_TYPE, GrssFeedsStorePrivate))
/**
* SECTION: feeds-store
* @short_description: abstract class for feeds permanent storage
*
- * #FeedsStore is a class which abstracts storage of feeds, implementing some
+ * #GrssFeedsStore is a class which abstracts storage of feeds, implementing some
* behaviours valid for all. Extensions of this must provide implementation
* of different callbacks so to permit permanent saving of channels and feeds.
*/
-G_DEFINE_ABSTRACT_TYPE (FeedsStore, feeds_store, G_TYPE_OBJECT);
+G_DEFINE_ABSTRACT_TYPE (GrssFeedsStore, grss_feeds_store, G_TYPE_OBJECT);
-struct _FeedsStorePrivate {
+struct _GrssFeedsStorePrivate {
gboolean running;
- FeedsPool *pool;
+ GrssFeedsPool *pool;
};
static void
-feeds_store_class_init (FeedsStoreClass *klass)
+grss_feeds_store_class_init (GrssFeedsStoreClass *klass)
{
- g_type_class_add_private (klass, sizeof (FeedsStorePrivate));
+ g_type_class_add_private (klass, sizeof (GrssFeedsStorePrivate));
}
static void
-feeds_store_init (FeedsStore *node)
+grss_feeds_store_init (GrssFeedsStore *node)
{
node->priv = FEEDS_STORE_GET_PRIVATE (node);
node->priv->running = FALSE;
@@ -54,40 +54,40 @@ feeds_store_init (FeedsStore *node)
}
/**
- * feeds_store_get_channels:
- * @store: a #FeedsStore
+ * grss_feeds_store_get_channels:
+ * @store: a #GrssFeedsStore
*
* To retrieve list of feeds permanently saved into the store
*
- * Return value: list of #FeedChannel found in the @store. Do not modify or
+ * Return value: list of #GrssFeedChannel found in the @store. Do not modify or
* free it
*/
GList*
-feeds_store_get_channels (FeedsStore *store)
+grss_feeds_store_get_channels (GrssFeedsStore *store)
{
return FEEDS_STORE_GET_CLASS (store)->get_channels (store);
}
/**
- * feeds_store_get_items_by_channel:
- * @store: a #FeedsStore
+ * grss_feeds_store_get_items_by_channel:
+ * @store: a #GrssFeedsStore
* @channel: parent feed containing required items
*
* To retrieve list of items saved into the store, assigned to the given
* @channel
*
- * Return value: list of #FeedItem found in the @store. Do not modify or free
+ * Return value: list of #GrssFeedItem found in the @store. Do not modify or free
* it
*/
GList*
-feeds_store_get_items_by_channel (FeedsStore *store, FeedChannel *channel)
+grss_feeds_store_get_items_by_channel (GrssFeedsStore *store, GrssFeedChannel *channel)
{
return FEEDS_STORE_GET_CLASS (store)->get_items_by_channel (store, channel);
}
/**
- * feeds_store_has_item:
- * @store: a #FeedsStore
+ * grss_feeds_store_has_item:
+ * @store: a #GrssFeedsStore
* @channel: parent feed containing required item
* @id: unique ID to look for
*
@@ -96,53 +96,53 @@ feeds_store_get_items_by_channel (FeedsStore *store, FeedChannel *channel)
* Return value: %TRUE if the specified item exists, %FALSE otherwise
*/
gboolean
-feeds_store_has_item (FeedsStore *store, FeedChannel *channel, const gchar *id)
+grss_feeds_store_has_item (GrssFeedsStore *store, GrssFeedChannel *channel, const gchar *id)
{
return FEEDS_STORE_GET_CLASS (store)->has_item (store, channel, id);
}
/**
- * feeds_store_add_item_in_channel:
- * @store: a #FeedsStore
+ * grss_feeds_store_add_item_in_channel:
+ * @store: a #GrssFeedsStore
* @channel: parent feed for the new item
* @item: new item to permanently save
*
- * To save a new #FeedItem into the @store. It performs a check to grant
+ * To save a new #GrssFeedItem into the @store. It performs a check to grant
* @item is not already saved
*/
void
-feeds_store_add_item_in_channel (FeedsStore *store, FeedChannel *channel, FeedItem *item)
+grss_feeds_store_add_item_in_channel (GrssFeedsStore *store, GrssFeedChannel *channel, GrssFeedItem *item)
{
- if (feeds_store_has_item (store, channel, feed_item_get_id (item)) == FALSE)
+ if (grss_feeds_store_has_item (store, channel, grss_feed_item_get_id (item)) == FALSE)
FEEDS_STORE_GET_CLASS (store)->add_item_in_channel (store, channel, item);
}
static void
-feed_fetched (FeedsPool *pool, FeedChannel *feed, GList *items, gpointer user_data)
+feed_fetched (GrssFeedsPool *pool, GrssFeedChannel *feed, GList *items, gpointer user_data)
{
GList *iter;
- FeedItem *item;
- FeedsStore *store;
+ GrssFeedItem *item;
+ GrssFeedsStore *store;
- store = (FeedsStore*) user_data;
+ store = (GrssFeedsStore*) user_data;
for (iter = items; iter; iter = g_list_next (iter)) {
- item = (FeedItem*) iter->data;
- feeds_store_add_item_in_channel (store, feed, item);
+ item = (GrssFeedItem*) iter->data;
+ grss_feeds_store_add_item_in_channel (store, feed, item);
}
}
/**
- * feeds_store_switch:
- * @store: a #FeedsStore
+ * grss_feeds_store_switch:
+ * @store: a #GrssFeedsStore
* @run: %TRUE to run the @store, %FALSE to stop
*
* This is to permit the @store to auto-update itself: it creates an internal
- * #FeedsPool and listens for his signals, so to implement the whole loop
+ * #GrssFeedsPool and listens for his signals, so to implement the whole loop
* fetch-parse-save trasparently
*/
void
-feeds_store_switch (FeedsStore *store, gboolean run)
+grss_feeds_store_switch (GrssFeedsStore *store, gboolean run)
{
GList *channels;
@@ -151,17 +151,17 @@ feeds_store_switch (FeedsStore *store, gboolean run)
if (run == TRUE) {
if (store->priv->pool == NULL) {
- store->priv->pool = feeds_pool_new ();
+ store->priv->pool = grss_feeds_pool_new ();
g_signal_connect (store->priv->pool, "feed-ready", G_CALLBACK (feed_fetched), store);
}
- channels = feeds_store_get_channels (store);
- feeds_pool_listen (store->priv->pool, channels);
- feeds_pool_switch (store->priv->pool, TRUE);
+ channels = grss_feeds_store_get_channels (store);
+ grss_feeds_pool_listen (store->priv->pool, channels);
+ grss_feeds_pool_switch (store->priv->pool, TRUE);
}
else {
if (store->priv->pool != NULL)
- feeds_pool_switch (store->priv->pool, FALSE);
+ grss_feeds_pool_switch (store->priv->pool, FALSE);
}
store->priv->running = run;
diff --git a/src/feeds-store.h b/src/feeds-store.h
index 4972f4a..ab940fc 100644
--- a/src/feeds-store.h
+++ b/src/feeds-store.h
@@ -22,36 +22,36 @@
#include "libgrss.h"
-#define FEEDS_STORE_TYPE (feeds_store_get_type())
-#define FEEDS_STORE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FEEDS_STORE_TYPE, FeedsStore))
-#define FEEDS_STORE_CLASS(c) (G_TYPE_CHECK_CLASS_CAST ((c), FEEDS_STORE_TYPE, FeedsStoreClass))
+#define FEEDS_STORE_TYPE (grss_feeds_store_get_type())
+#define FEEDS_STORE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FEEDS_STORE_TYPE, GrssFeedsStore))
+#define FEEDS_STORE_CLASS(c) (G_TYPE_CHECK_CLASS_CAST ((c), FEEDS_STORE_TYPE, GrssFeedsStoreClass))
#define IS_FEEDS_STORE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FEEDS_STORE_TYPE))
#define IS_FEEDS_STORE_CLASS(c) (G_TYPE_CHECK_CLASS_TYPE ((c), FEEDS_STORE_TYPE))
-#define FEEDS_STORE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FEEDS_STORE_TYPE, FeedsStoreClass))
+#define FEEDS_STORE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FEEDS_STORE_TYPE, GrssFeedsStoreClass))
-typedef struct _FeedsStore FeedsStore;
-typedef struct _FeedsStorePrivate FeedsStorePrivate;
+typedef struct _GrssFeedsStore GrssFeedsStore;
+typedef struct _GrssFeedsStorePrivate GrssFeedsStorePrivate;
-struct _FeedsStore {
+struct _GrssFeedsStore {
GObject parent;
- FeedsStorePrivate *priv;
+ GrssFeedsStorePrivate *priv;
};
typedef struct {
GObjectClass parent;
- GList* (*get_channels) (FeedsStore *store);
- GList* (*get_items_by_channel) (FeedsStore *store, FeedChannel *channel);
- gboolean (*has_item) (FeedsStore *store, FeedChannel *channel, const gchar *id);
- void (*add_item_in_channel) (FeedsStore *store, FeedChannel *channel, FeedItem *item);
-} FeedsStoreClass;
+ GList* (*get_channels) (GrssFeedsStore *store);
+ GList* (*get_items_by_channel) (GrssFeedsStore *store, GrssFeedChannel *channel);
+ gboolean (*has_item) (GrssFeedsStore *store, GrssFeedChannel *channel, const gchar *id);
+ void (*add_item_in_channel) (GrssFeedsStore *store, GrssFeedChannel *channel, GrssFeedItem *item);
+} GrssFeedsStoreClass;
-GType feeds_store_get_type () G_GNUC_CONST;
+GType grss_feeds_store_get_type () G_GNUC_CONST;
-GList* feeds_store_get_channels (FeedsStore *store);
-GList* feeds_store_get_items_by_channel (FeedsStore *store, FeedChannel *channel);
-gboolean feeds_store_has_item (FeedsStore *store, FeedChannel *channel, const gchar *id);
-void feeds_store_add_item_in_channel (FeedsStore *store, FeedChannel *channel, FeedItem *item);
-void feeds_store_switch (FeedsStore *store, gboolean run);
+GList* grss_feeds_store_get_channels (GrssFeedsStore *store);
+GList* grss_feeds_store_get_items_by_channel (GrssFeedsStore *store, GrssFeedChannel *channel);
+gboolean grss_feeds_store_has_item (GrssFeedsStore *store, GrssFeedChannel *channel, const gchar *id);
+void grss_feeds_store_add_item_in_channel (GrssFeedsStore *store, GrssFeedChannel *channel, GrssFeedItem *item);
+void grss_feeds_store_switch (GrssFeedsStore *store, gboolean run);
#endif /* __FEEDS_STORE_H__ */
diff --git a/src/feeds-subscriber.c b/src/feeds-subscriber.c
index a9547fe..60c192d 100644
--- a/src/feeds-subscriber.c
+++ b/src/feeds-subscriber.c
@@ -25,18 +25,18 @@
#define DEFAULT_SERVER_PORT 8444
-#define FEEDS_SUBSCRIBER_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), FEEDS_SUBSCRIBER_TYPE, FeedsSubscriberPrivate))
+#define FEEDS_SUBSCRIBER_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), FEEDS_SUBSCRIBER_TYPE, GrssFeedsSubscriberPrivate))
/**
* SECTION: feeds-subscriber
* @short_description: PubSubHubbub subscriber
*
- * #FeedsSubscriber is an alternative for #FeedsPool, able to receive
+ * #GrssFeedsSubscriber is an alternative for #GrssFeedsPool, able to receive
* real-time notifications by feeds managed by a PubSubHubbub hub.
- * When the subscriber is executed (with feeds_subscriber_switch()) it opens
- * a server on a local port (configurable with feeds_subscriber_set_port()),
- * engage a subscription for each #FeedChannel passed with
- * feeds_subscriber_listen(), and waits for direct notifications by the
+ * When the subscriber is executed (with grss_feeds_subscriber_switch()) it opens
+ * a server on a local port (configurable with grss_feeds_subscriber_set_port()),
+ * engage a subscription for each #GrssFeedChannel passed with
+ * grss_feeds_subscriber_listen(), and waits for direct notifications by the
* remote hub.
* For more information look at http://code.google.com/p/pubsubhubbub/
*/
@@ -55,12 +55,12 @@ typedef enum {
SUBSCRIBER_CHECKING_PUBLIC_IP
} SUBSCRIBER_INIT_STATUS;
-static void subscribe_feeds (FeedsSubscriber *sub);
-static void try_another_subscription_policy (FeedsSubscriber *sub);
+static void subscribe_feeds (GrssFeedsSubscriber *sub);
+static void try_another_subscription_policy (GrssFeedsSubscriber *sub);
-typedef void (*SubscriberJobCallback) (FeedsSubscriber *subscriber);
+typedef void (*SubscriberJobCallback) (GrssFeedsSubscriber *subscriber);
-struct _FeedsSubscriberPrivate {
+struct _GrssFeedsSubscriberPrivate {
gboolean running;
SUBSCRIBER_INIT_STATUS initing_status;
@@ -73,7 +73,7 @@ struct _FeedsSubscriberPrivate {
gchar *hub;
SoupSession *soupsession;
- FeedParser *parser;
+ GrssFeedParser *parser;
GList *feeds_list;
guint refresh_scheduler;
@@ -87,19 +87,19 @@ typedef enum {
} FEED_SUBSCRIPTION_STATUS;
typedef struct {
- FeedChannel *channel;
+ GrssFeedChannel *channel;
FEED_SUBSCRIPTION_STATUS status;
int identifier;
gchar *path;
- FeedsSubscriber *sub;
-} FeedChannelWrap;
+ GrssFeedsSubscriber *sub;
+} GrssFeedChannelWrap;
typedef struct {
int counter;
SubscriberJobCallback callback;
- FeedsSubscriber *subscriber;
+ GrssFeedsSubscriber *subscriber;
} SubscriberJob;
enum {
@@ -109,17 +109,17 @@ enum {
static guint signals [LAST_SIGNAL] = {0};
-G_DEFINE_TYPE (FeedsSubscriber, feeds_subscriber, G_TYPE_OBJECT);
+G_DEFINE_TYPE (GrssFeedsSubscriber, grss_feeds_subscriber, G_TYPE_OBJECT);
static void
-remove_currently_listened (FeedsSubscriber *sub)
+remove_currently_listened (GrssFeedsSubscriber *sub)
{
GList *iter;
- FeedChannelWrap *wrap;
+ GrssFeedChannelWrap *wrap;
if (sub->priv->feeds_list != NULL) {
for (iter = sub->priv->feeds_list; iter; iter = g_list_next (iter)) {
- wrap = (FeedChannelWrap*) iter->data;
+ wrap = (GrssFeedChannelWrap*) iter->data;
g_free (wrap->path);
g_object_unref (wrap->channel);
g_free (wrap);
@@ -130,40 +130,40 @@ remove_currently_listened (FeedsSubscriber *sub)
}
static void
-notification_handled_cb (FeedsSubscriber *sub, FeedChannel *feed, FeedItem *item)
+notification_handled_cb (GrssFeedsSubscriber *sub, GrssFeedChannel *feed, GrssFeedItem *item)
{
g_object_unref (item);
}
static void
-feeds_subscriber_finalize (GObject *obj)
+grss_feeds_subscriber_finalize (GObject *obj)
{
- FeedsSubscriber *sub;
+ GrssFeedsSubscriber *sub;
sub = FEEDS_SUBSCRIBER (obj);
- feeds_subscriber_switch (sub, FALSE);
+ grss_feeds_subscriber_switch (sub, FALSE);
remove_currently_listened (sub);
FREE_STRING (sub->priv->hub);
g_object_unref (sub->priv->parser);
}
static void
-feeds_subscriber_class_init (FeedsSubscriberClass *klass)
+grss_feeds_subscriber_class_init (GrssFeedsSubscriberClass *klass)
{
GObjectClass *gobject_class;
- g_type_class_add_private (klass, sizeof (FeedsSubscriberPrivate));
+ g_type_class_add_private (klass, sizeof (GrssFeedsSubscriberPrivate));
gobject_class = G_OBJECT_CLASS (klass);
- gobject_class->finalize = feeds_subscriber_finalize;
+ gobject_class->finalize = grss_feeds_subscriber_finalize;
klass->notification_received = notification_handled_cb;
/**
- * FeedsSubscriber::notification-received:
- * @pool: the #FeedsSubscriber emitting the signal
- * @feed: the #FeedChannel which has been updated
- * @item: the #FeedItem received
+ * GrssFeedsSubscriber::notification-received:
+ * @pool: the #GrssFeedsSubscriber emitting the signal
+ * @feed: the #GrssFeedChannel which has been updated
+ * @item: the #GrssFeedItem received
*
* Emitted when a notification has been received and parsed. The
* @item is unref'd at the end of signal
@@ -174,40 +174,40 @@ feeds_subscriber_class_init (FeedsSubscriberClass *klass)
}
static void
-feeds_subscriber_init (FeedsSubscriber *node)
+grss_feeds_subscriber_init (GrssFeedsSubscriber *node)
{
node->priv = FEEDS_SUBSCRIBER_GET_PRIVATE (node);
- memset (node->priv, 0, sizeof (FeedsSubscriberPrivate));
- node->priv->parser = feed_parser_new ();
+ memset (node->priv, 0, sizeof (GrssFeedsSubscriberPrivate));
+ node->priv->parser = grss_feed_parser_new ();
node->priv->port = DEFAULT_SERVER_PORT;
}
/**
- * feeds_subscriber_new:
+ * grss_feeds_subscriber_new:
*
- * Allocates a new #FeedsSubscriber
+ * Allocates a new #GrssFeedsSubscriber
*
- * Return value: a new #FeedsSubscriber
+ * Return value: a new #GrssFeedsSubscriber
*/
-FeedsSubscriber*
-feeds_subscriber_new ()
+GrssFeedsSubscriber*
+grss_feeds_subscriber_new ()
{
return g_object_new (FEEDS_SUBSCRIBER_TYPE, NULL);
}
static gboolean
-create_listened (FeedsSubscriber *sub, GList *feeds)
+create_listened (GrssFeedsSubscriber *sub, GList *feeds)
{
GList *list;
GList *iter;
- FeedChannel *feed;
- FeedChannelWrap *wrap;
+ GrssFeedChannel *feed;
+ GrssFeedChannelWrap *wrap;
for (iter = feeds; iter; iter = g_list_next (iter)) {
- feed = (FeedChannel*) iter->data;
+ feed = (GrssFeedChannel*) iter->data;
- if (feed_channel_get_pubsubhub (feed, NULL, NULL) == FALSE) {
- g_warning ("Feed at %s has not PubSubHubbub capability", feed_channel_get_source (feed));
+ if (grss_feed_channel_get_pubsubhub (feed, NULL, NULL) == FALSE) {
+ g_warning ("Feed at %s has not PubSubHubbub capability", grss_feed_channel_get_source (feed));
return FALSE;
}
}
@@ -215,9 +215,9 @@ create_listened (FeedsSubscriber *sub, GList *feeds)
list = NULL;
for (iter = feeds; iter; iter = g_list_next (iter)) {
- feed = (FeedChannel*) iter->data;
+ feed = (GrssFeedChannel*) iter->data;
- wrap = g_new0 (FeedChannelWrap, 1);
+ wrap = g_new0 (GrssFeedChannelWrap, 1);
g_object_ref (feed);
wrap->status = FEED_SUBSCRIPTION_IDLE;
wrap->path = NULL;
@@ -231,37 +231,37 @@ create_listened (FeedsSubscriber *sub, GList *feeds)
}
/**
- * feeds_subscriber_listen:
- * @sub: a #FeedsSubscriber
- * @feeds: a list of #FeedChannel
+ * grss_feeds_subscriber_listen:
+ * @sub: a #GrssFeedsSubscriber
+ * @feeds: a list of #GrssFeedChannel
*
* To set the list of feeds to be managed by @sub. The previous list, if any,
- * is invalidated. After invokation to the function, feeds_subscriber_switch()
+ * is invalidated. After invokation to the function, grss_feeds_subscriber_switch()
* must be call to run the subscription.
- * The list in @feeds can be freed after calling this; linked #FeedChannel
+ * The list in @feeds can be freed after calling this; linked #GrssFeedChannel
* are g_object_ref'd here
*
- * Return value: %TRUE if all #FeedChannels involved in @feeds are valid
- * (feed_channel_get_pubsubhub() returns %TRUE), %FALSE otherwise
+ * Return value: %TRUE if all #GrssFeedChannels involved in @feeds are valid
+ * (grss_feed_channel_get_pubsubhub() returns %TRUE), %FALSE otherwise
*/
gboolean
-feeds_subscriber_listen (FeedsSubscriber *sub, GList *feeds)
+grss_feeds_subscriber_listen (GrssFeedsSubscriber *sub, GList *feeds)
{
remove_currently_listened (sub);
return create_listened (sub, feeds);
}
/**
- * feeds_subscriber_get_listened:
- * @sub: a #FeedsSubscriber
+ * grss_feeds_subscriber_get_listened:
+ * @sub: a #GrssFeedsSubscriber
*
* Returns the list of feeds currently managed by @sub
*
- * Return value: a list of #FeedChannel, to be freed with g_list_free() when
+ * Return value: a list of #GrssFeedChannel, to be freed with g_list_free() when
* no longer in use. Do not modify elements found in this list
*/
GList*
-feeds_subscriber_get_listened (FeedsSubscriber *sub)
+grss_feeds_subscriber_get_listened (GrssFeedsSubscriber *sub)
{
GList *ret;
GList *iter;
@@ -269,7 +269,7 @@ feeds_subscriber_get_listened (FeedsSubscriber *sub)
ret = NULL;
for (iter = sub->priv->feeds_list; iter; iter = g_list_next (iter))
- ret = g_list_prepend (ret, ((FeedChannelWrap*)iter->data)->channel);
+ ret = g_list_prepend (ret, ((GrssFeedChannelWrap*)iter->data)->channel);
return g_list_reverse (ret);
}
@@ -295,9 +295,9 @@ handle_incoming_notification_cb (SoupServer *server, SoupMessage *msg, const cha
GList *items;
GError *error;
xmlDocPtr doc;
- FeedChannelWrap *feed;
+ GrssFeedChannelWrap *feed;
- feed = (FeedChannelWrap*) user_data;
+ feed = (GrssFeedChannelWrap*) user_data;
if (query != NULL) {
mode = (gchar*) g_hash_table_lookup (query, "hub.mode");
@@ -326,15 +326,15 @@ handle_incoming_notification_cb (SoupServer *server, SoupMessage *msg, const cha
doc = content_to_xml (msg->request_body->data, strlen (msg->request_body->data));
error = NULL;
- items = feed_parser_parse (feed->sub->priv->parser, feed->channel, doc, &error);
+ items = grss_feed_parser_parse (feed->sub->priv->parser, feed->channel, doc, &error);
if (items == NULL) {
- g_warning ("Unable to parse notification from %s: %s", feed_channel_get_source (feed->channel), error->message);
+ g_warning ("Unable to parse notification from %s: %s", grss_feed_channel_get_source (feed->channel), error->message);
g_error_free (error);
}
else {
for (iter = items; iter; iter = g_list_next (iter))
- g_signal_emit (feed->sub, signals [NOTIFICATION_RECEIVED], 0, feed->channel, (FeedItem*) iter->data, NULL);
+ g_signal_emit (feed->sub, signals [NOTIFICATION_RECEIVED], 0, feed->channel, (GrssFeedItem*) iter->data, NULL);
g_list_free (items);
}
@@ -347,26 +347,26 @@ handle_incoming_notification_cb (SoupServer *server, SoupMessage *msg, const cha
}
static void
-unregister_handlers (FeedsSubscriber *sub)
+unregister_handlers (GrssFeedsSubscriber *sub)
{
GList *iter;
- FeedChannelWrap *feed;
+ GrssFeedChannelWrap *feed;
for (iter = sub->priv->feeds_list; iter; iter = g_list_next (iter)) {
- feed = (FeedChannelWrap*) iter->data;
+ feed = (GrssFeedChannelWrap*) iter->data;
soup_server_remove_handler (sub->priv->server, feed->path);
}
}
static void
-register_handlers (FeedsSubscriber *sub)
+register_handlers (GrssFeedsSubscriber *sub)
{
register int i;
GList *iter;
- FeedChannelWrap *feed;
+ GrssFeedChannelWrap *feed;
for (i = 1, iter = sub->priv->feeds_list; iter; iter = g_list_next (iter), i++) {
- feed = (FeedChannelWrap*) iter->data;
+ feed = (GrssFeedChannelWrap*) iter->data;
feed->identifier = i;
feed->status = FEED_SUBSCRIPTION_SUBSCRIBING;
@@ -377,7 +377,7 @@ register_handlers (FeedsSubscriber *sub)
}
static void
-close_server (FeedsSubscriber *sub)
+close_server (GrssFeedsSubscriber *sub)
{
if (sub->priv->server != NULL) {
unregister_handlers (sub);
@@ -388,7 +388,7 @@ close_server (FeedsSubscriber *sub)
}
static void
-feeds_subscribed_cb (FeedsSubscriber *sub)
+feeds_subscribed_cb (GrssFeedsSubscriber *sub)
{
if (sub->priv->has_errors_in_subscription == TRUE)
try_another_subscription_policy (sub);
@@ -412,14 +412,14 @@ subscribe_response_cb (SoupSession *session, SoupMessage *msg, gpointer user_dat
}
static void
-subscribe_feed (FeedsSubscriber *sub, FeedChannelWrap *feed, SubscriberJob *job)
+subscribe_feed (GrssFeedsSubscriber *sub, GrssFeedChannelWrap *feed, SubscriberJob *job)
{
gchar *body;
gchar *pubsubhub;
gchar *feed_reference;
SoupMessage *msg;
- if (feed_channel_get_pubsubhub (feed->channel, &pubsubhub, &feed_reference) == FALSE)
+ if (grss_feed_channel_get_pubsubhub (feed->channel, &pubsubhub, &feed_reference) == FALSE)
return;
if (sub->priv->hub != NULL)
@@ -435,10 +435,10 @@ subscribe_feed (FeedsSubscriber *sub, FeedChannelWrap *feed, SubscriberJob *job)
}
static void
-subscribe_feeds (FeedsSubscriber *sub)
+subscribe_feeds (GrssFeedsSubscriber *sub)
{
GList *iter;
- FeedChannelWrap *feed;
+ GrssFeedChannelWrap *feed;
SubscriberJob *job;
if (sub->priv->feeds_list == NULL)
@@ -452,13 +452,13 @@ subscribe_feeds (FeedsSubscriber *sub)
sub->priv->has_errors_in_subscription = FALSE;
for (iter = sub->priv->feeds_list; iter; iter = g_list_next (iter)) {
- feed = (FeedChannelWrap*) iter->data;
+ feed = (GrssFeedChannelWrap*) iter->data;
subscribe_feed (sub, feed, job);
}
}
static GInetAddress*
-my_detect_internet_address (FeedsSubscriber *sub)
+my_detect_internet_address (GrssFeedsSubscriber *sub)
{
if (sub->priv->local_addr == NULL)
sub->priv->local_addr = detect_internet_address ();
@@ -467,7 +467,7 @@ my_detect_internet_address (FeedsSubscriber *sub)
}
static void
-create_and_run_server (FeedsSubscriber *sub)
+create_and_run_server (GrssFeedsSubscriber *sub)
{
gchar *ip;
struct sockaddr_in low_addr;
@@ -497,9 +497,9 @@ create_and_run_server (FeedsSubscriber *sub)
static void
external_ip_received_cb (SoupSession *session, SoupMessage *msg, gpointer data)
{
- FeedsSubscriber *sub;
+ GrssFeedsSubscriber *sub;
- sub = (FeedsSubscriber*) data;
+ sub = (GrssFeedsSubscriber*) data;
sub->priv->external_addr = g_inet_address_new_from_string (msg->response_body->data);
if (sub->priv->external_addr == NULL) {
@@ -511,7 +511,7 @@ external_ip_received_cb (SoupSession *session, SoupMessage *msg, gpointer data)
}
static void
-subscribe_with_external_ip (FeedsSubscriber *sub)
+subscribe_with_external_ip (GrssFeedsSubscriber *sub)
{
SoupMessage *msg;
@@ -526,7 +526,7 @@ subscribe_with_external_ip (FeedsSubscriber *sub)
}
static void
-try_another_subscription_policy (FeedsSubscriber *sub)
+try_another_subscription_policy (GrssFeedsSubscriber *sub)
{
switch (sub->priv->initing_status) {
case SUBSCRIBER_TRYING_LOCAL_IP:
@@ -542,7 +542,7 @@ try_another_subscription_policy (FeedsSubscriber *sub)
}
static void
-init_run_server (FeedsSubscriber *sub)
+init_run_server (GrssFeedsSubscriber *sub)
{
gboolean done;
GInetAddress *addr;
@@ -615,7 +615,7 @@ init_run_server (FeedsSubscriber *sub)
}
static void
-feeds_unsubscribed_cb (FeedsSubscriber *sub)
+feeds_unsubscribed_cb (GrssFeedsSubscriber *sub)
{
close_server (sub);
g_object_unref (sub->priv->soupsession);
@@ -632,14 +632,14 @@ unsubscribe_response_cb (SoupSession *session, SoupMessage *msg, gpointer user_d
}
static void
-unsubscribe_feed (FeedsSubscriber *sub, FeedChannelWrap *feed, SubscriberJob *job)
+unsubscribe_feed (GrssFeedsSubscriber *sub, GrssFeedChannelWrap *feed, SubscriberJob *job)
{
gchar *body;
gchar *pubsubhub;
gchar *feed_reference;
SoupMessage *msg;
- if (feed_channel_get_pubsubhub (feed->channel, &pubsubhub, &feed_reference) == FALSE) {
+ if (grss_feed_channel_get_pubsubhub (feed->channel, &pubsubhub, &feed_reference) == FALSE) {
check_complete_job (job);
return;
}
@@ -659,10 +659,10 @@ unsubscribe_feed (FeedsSubscriber *sub, FeedChannelWrap *feed, SubscriberJob *jo
}
static void
-unsubscribe_feeds (FeedsSubscriber *sub)
+unsubscribe_feeds (GrssFeedsSubscriber *sub)
{
GList *iter;
- FeedChannelWrap *wrap;
+ GrssFeedChannelWrap *wrap;
SubscriberJob *job;
job = g_new0 (SubscriberJob, 1);
@@ -671,7 +671,7 @@ unsubscribe_feeds (FeedsSubscriber *sub)
job->subscriber = sub;
for (iter = sub->priv->feeds_list; iter; iter = g_list_next (iter)) {
- wrap = (FeedChannelWrap*) iter->data;
+ wrap = (GrssFeedChannelWrap*) iter->data;
unsubscribe_feed (sub, wrap, job);
}
@@ -679,14 +679,14 @@ unsubscribe_feeds (FeedsSubscriber *sub)
}
static void
-stop_server (FeedsSubscriber *sub)
+stop_server (GrssFeedsSubscriber *sub)
{
unsubscribe_feeds (sub);
}
/**
- * feeds_subscriber_set_port:
- * @sub: a #FeedsSubscriber
+ * grss_feeds_subscriber_set_port:
+ * @sub: a #GrssFeedsSubscriber
* @port: new listening port for the server
*
* To customize the port opened by the local server to catch incoming
@@ -696,28 +696,28 @@ stop_server (FeedsSubscriber *sub)
* certain ports
*/
void
-feeds_subscriber_set_port (FeedsSubscriber *sub, int port)
+grss_feeds_subscriber_set_port (GrssFeedsSubscriber *sub, int port)
{
if (port != sub->priv->port) {
sub->priv->port = port;
if (sub->priv->running == TRUE) {
- feeds_subscriber_switch (sub, FALSE);
- feeds_subscriber_switch (sub, TRUE);
+ grss_feeds_subscriber_switch (sub, FALSE);
+ grss_feeds_subscriber_switch (sub, TRUE);
}
}
}
/**
- * feeds_subscriber_set_hub:
- * @sub: a #FeedsSubscriber
+ * grss_feeds_subscriber_set_hub:
+ * @sub: a #GrssFeedsSubscriber
* @hub: URL of the custom hub
*
* To customize the default hub to which send subscriptions. If this value is
* set, hubs from specific feeds are ignored
*/
void
-feeds_subscriber_set_hub (FeedsSubscriber *sub, gchar *hub)
+grss_feeds_subscriber_set_hub (GrssFeedsSubscriber *sub, gchar *hub)
{
FREE_STRING (sub->priv->hub);
if (hub != NULL)
@@ -725,14 +725,14 @@ feeds_subscriber_set_hub (FeedsSubscriber *sub, gchar *hub)
}
/**
- * feeds_subscriber_switch:
- * @sub: a #FeedsSubscriber
+ * grss_feeds_subscriber_switch:
+ * @sub: a #GrssFeedsSubscriber
* @run: TRUE to run the subscriber, FALSE to pause it
*
* Permits to pause or resume @sub listening for events
*/
void
-feeds_subscriber_switch (FeedsSubscriber *sub, gboolean run)
+grss_feeds_subscriber_switch (GrssFeedsSubscriber *sub, gboolean run)
{
if (sub->priv->running != run) {
sub->priv->running = run;
diff --git a/src/feeds-subscriber.h b/src/feeds-subscriber.h
index 1b37149..90557c6 100644
--- a/src/feeds-subscriber.h
+++ b/src/feeds-subscriber.h
@@ -23,35 +23,35 @@
#include "libgrss.h"
-#define FEEDS_SUBSCRIBER_TYPE (feeds_subscriber_get_type())
-#define FEEDS_SUBSCRIBER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FEEDS_SUBSCRIBER_TYPE, FeedsSubscriber))
-#define FEEDS_SUBSCRIBER_CLASS(c) (G_TYPE_CHECK_CLASS_CAST ((c), FEEDS_SUBSCRIBER_TYPE, FeedsSubscriberClass))
+#define FEEDS_SUBSCRIBER_TYPE (grss_feeds_subscriber_get_type())
+#define FEEDS_SUBSCRIBER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FEEDS_SUBSCRIBER_TYPE, GrssFeedsSubscriber))
+#define FEEDS_SUBSCRIBER_CLASS(c) (G_TYPE_CHECK_CLASS_CAST ((c), FEEDS_SUBSCRIBER_TYPE, GrssFeedsSubscriberClass))
#define IS_FEEDS_SUBSCRIBER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FEEDS_SUBSCRIBER_TYPE))
#define IS_FEEDS_SUBSCRIBER_CLASS(c) (G_TYPE_CHECK_CLASS_TYPE ((c), FEEDS_SUBSCRIBER_TYPE))
-#define FEEDS_SUBSCRIBER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FEEDS_SUBSCRIBER_TYPE, FeedsSubscriberClass))
+#define FEEDS_SUBSCRIBER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FEEDS_SUBSCRIBER_TYPE, GrssFeedsSubscriberClass))
-typedef struct _FeedsSubscriber FeedsSubscriber;
-typedef struct _FeedsSubscriberPrivate FeedsSubscriberPrivate;
+typedef struct _GrssFeedsSubscriber GrssFeedsSubscriber;
+typedef struct _GrssFeedsSubscriberPrivate GrssFeedsSubscriberPrivate;
-struct _FeedsSubscriber {
+struct _GrssFeedsSubscriber {
GObject parent;
- FeedsSubscriberPrivate *priv;
+ GrssFeedsSubscriberPrivate *priv;
};
typedef struct {
GObjectClass parent;
- void (*notification_received) (FeedsSubscriber *sub, FeedChannel *feed, FeedItem *item);
-} FeedsSubscriberClass;
+ void (*notification_received) (GrssFeedsSubscriber *sub, GrssFeedChannel *feed, GrssFeedItem *item);
+} GrssFeedsSubscriberClass;
-GType feeds_subscriber_get_type () G_GNUC_CONST;
+GType grss_feeds_subscriber_get_type () G_GNUC_CONST;
-FeedsSubscriber* feeds_subscriber_new ();
+GrssFeedsSubscriber* grss_feeds_subscriber_new ();
-gboolean feeds_subscriber_listen (FeedsSubscriber *sub, GList *feeds);
-GList* feeds_subscriber_get_listened (FeedsSubscriber *sub);
-void feeds_subscriber_set_port (FeedsSubscriber *sub, int port);
-void feeds_subscriber_set_hub (FeedsSubscriber *sub, gchar *hub);
-void feeds_subscriber_switch (FeedsSubscriber *sub, gboolean run);
+gboolean grss_feeds_subscriber_listen (GrssFeedsSubscriber *sub, GList *feeds);
+GList* grss_feeds_subscriber_get_listened (GrssFeedsSubscriber *sub);
+void grss_feeds_subscriber_set_port (GrssFeedsSubscriber *sub, int port);
+void grss_feeds_subscriber_set_hub (GrssFeedsSubscriber *sub, gchar *hub);
+void grss_feeds_subscriber_switch (GrssFeedsSubscriber *sub, gboolean run);
#endif /* __FEEDS_SUBSCRIBER_H__ */
diff --git a/src/feeds-xbel-group-handler.c b/src/feeds-xbel-group-handler.c
index 1e64f22..ba65d7b 100644
--- a/src/feeds-xbel-group-handler.c
+++ b/src/feeds-xbel-group-handler.c
@@ -29,17 +29,17 @@
* SECTION: feeds-xbel-group-handler
* @short_description: specialized parser for XBEL files
*
- * #FeedsXbelGroupHandler is a #FeedsGroupHandler specialized for XBEL contents
+ * #FeedsXbelGroupHandler is a #GrssFeedsGroupHandler specialized for XBEL contents
*/
struct FeedsXbelGroupHandlerPrivate {
int rfu;
};
-static void feeds_group_handler_interface_init (FeedsGroupHandlerInterface *iface);
+static void grss_feeds_group_handler_interface_init (GrssFeedsGroupHandlerInterface *iface);
G_DEFINE_TYPE_WITH_CODE (FeedsXbelGroupHandler, feeds_xbel_group_handler, G_TYPE_OBJECT,
G_IMPLEMENT_INTERFACE (FEEDS_GROUP_HANDLER_TYPE,
- feeds_group_handler_interface_init));
+ grss_feeds_group_handler_interface_init));
static void
feeds_xbel_group_handler_finalize (GObject *object)
@@ -51,7 +51,7 @@ feeds_xbel_group_handler_finalize (GObject *object)
}
static gboolean
-feeds_xbel_group_handler_check_format (FeedsGroupHandler *self, xmlDocPtr doc, xmlNodePtr cur)
+feeds_xbel_group_handler_check_format (GrssFeedsGroupHandler *self, xmlDocPtr doc, xmlNodePtr cur)
{
if (!xmlStrcmp (cur->name, BAD_CAST"xbel"))
return TRUE;
@@ -60,7 +60,7 @@ feeds_xbel_group_handler_check_format (FeedsGroupHandler *self, xmlDocPtr doc, x
}
static GList*
-feeds_xbel_group_handler_parse (FeedsGroupHandler *self, xmlDocPtr doc, GError **error)
+feeds_xbel_group_handler_parse (GrssFeedsGroupHandler *self, xmlDocPtr doc, GError **error)
{
int i;
gchar *str;
@@ -69,7 +69,7 @@ feeds_xbel_group_handler_parse (FeedsGroupHandler *self, xmlDocPtr doc, GError *
GList *items;
xmlXPathObjectPtr xpathObj;
xmlXPathContextPtr xpathCtx;
- FeedChannel *channel;
+ GrssFeedChannel *channel;
FeedsXbelGroupHandler *parser;
items = NULL;
@@ -89,16 +89,16 @@ feeds_xbel_group_handler_parse (FeedsGroupHandler *self, xmlDocPtr doc, GError *
str = (gchar*) xmlGetProp (cur, BAD_CAST"href");
if (str != NULL && strlen (str) != 0) {
- channel = feed_channel_new ();
+ channel = grss_feed_channel_new ();
- feed_channel_set_source (channel, str);
+ grss_feed_channel_set_source (channel, str);
xmlFree (str);
if (cur->children != NULL && strcmp ((gchar*) cur->children->name, "title") == 0) {
subnode = cur->children;
str = (gchar*) xmlNodeListGetString (doc, subnode->xmlChildrenNode, TRUE);
if (str != NULL) {
- feed_channel_set_title (channel, str);
+ grss_feed_channel_set_title (channel, str);
g_free (str);
}
}
@@ -117,7 +117,7 @@ feeds_xbel_group_handler_parse (FeedsGroupHandler *self, xmlDocPtr doc, GError *
}
static gchar*
-feeds_xbel_group_handler_dump (FeedsGroupHandler *self, GList *channels, GError **error)
+feeds_xbel_group_handler_dump (GrssFeedsGroupHandler *self, GList *channels, GError **error)
{
/**
TODO
@@ -127,7 +127,7 @@ feeds_xbel_group_handler_dump (FeedsGroupHandler *self, GList *channels, GError
}
static void
-feeds_group_handler_interface_init (FeedsGroupHandlerInterface *iface)
+grss_feeds_group_handler_interface_init (GrssFeedsGroupHandlerInterface *iface)
{
iface->check_format = feeds_xbel_group_handler_check_format;
iface->parse = feeds_xbel_group_handler_parse;
diff --git a/src/feeds-xoxo-group-handler.c b/src/feeds-xoxo-group-handler.c
index 5f7463c..c95add0 100644
--- a/src/feeds-xoxo-group-handler.c
+++ b/src/feeds-xoxo-group-handler.c
@@ -29,17 +29,17 @@
* SECTION: feeds-xoxo-group-handler
* @short_description: specialized parser for XOXO files
*
- * #FeedsXoxoGroupHandler is a #FeedsGroupHandler specialized for XOXO contents
+ * #FeedsXoxoGroupHandler is a #GrssFeedsGroupHandler specialized for XOXO contents
*/
struct FeedsXoxoGroupHandlerPrivate {
int rfu;
};
-static void feeds_group_handler_interface_init (FeedsGroupHandlerInterface *iface);
+static void grss_feeds_group_handler_interface_init (GrssFeedsGroupHandlerInterface *iface);
G_DEFINE_TYPE_WITH_CODE (FeedsXoxoGroupHandler, feeds_xoxo_group_handler, G_TYPE_OBJECT,
G_IMPLEMENT_INTERFACE (FEEDS_GROUP_HANDLER_TYPE,
- feeds_group_handler_interface_init));
+ grss_feeds_group_handler_interface_init));
static xmlNode* find_first_element (xmlDocPtr doc)
{
@@ -71,13 +71,13 @@ feeds_xoxo_group_handler_finalize (GObject *object)
}
static gboolean
-feeds_xoxo_group_handler_check_format (FeedsGroupHandler *self, xmlDocPtr doc, xmlNodePtr cur)
+feeds_xoxo_group_handler_check_format (GrssFeedsGroupHandler *self, xmlDocPtr doc, xmlNodePtr cur)
{
return (find_first_element (doc) != NULL);
}
static GList*
-feeds_xoxo_group_handler_parse (FeedsGroupHandler *self, xmlDocPtr doc, GError **error)
+feeds_xoxo_group_handler_parse (GrssFeedsGroupHandler *self, xmlDocPtr doc, GError **error)
{
int i;
gchar *str;
@@ -85,7 +85,7 @@ feeds_xoxo_group_handler_parse (FeedsGroupHandler *self, xmlDocPtr doc, GError *
GList *items;
xmlXPathObjectPtr xpathObj;
xmlXPathContextPtr xpathCtx;
- FeedChannel *channel;
+ GrssFeedChannel *channel;
FeedsXoxoGroupHandler *parser;
items = NULL;
@@ -106,14 +106,14 @@ feeds_xoxo_group_handler_parse (FeedsGroupHandler *self, xmlDocPtr doc, GError *
str = (gchar*) xmlGetProp (cur, BAD_CAST"href");
if (str != NULL && strlen (str) != 0) {
- channel = feed_channel_new ();
+ channel = grss_feed_channel_new ();
- feed_channel_set_source (channel, str);
+ grss_feed_channel_set_source (channel, str);
xmlFree (str);
str = unhtmlize ((gchar*) xmlNodeListGetString (doc, cur->xmlChildrenNode, TRUE));
if (str != NULL) {
- feed_channel_set_title (channel, str);
+ grss_feed_channel_set_title (channel, str);
g_free (str);
}
@@ -131,7 +131,7 @@ feeds_xoxo_group_handler_parse (FeedsGroupHandler *self, xmlDocPtr doc, GError *
}
static gchar*
-feeds_xoxo_group_handler_dump (FeedsGroupHandler *self, GList *channels, GError **error)
+feeds_xoxo_group_handler_dump (GrssFeedsGroupHandler *self, GList *channels, GError **error)
{
/**
TODO
@@ -141,7 +141,7 @@ feeds_xoxo_group_handler_dump (FeedsGroupHandler *self, GList *channels, GError
}
static void
-feeds_group_handler_interface_init (FeedsGroupHandlerInterface *iface)
+grss_feeds_group_handler_interface_init (GrssFeedsGroupHandlerInterface *iface)
{
iface->check_format = feeds_xoxo_group_handler_check_format;
iface->parse = feeds_xoxo_group_handler_parse;
diff --git a/src/ns-handler.c b/src/ns-handler.c
index 79cdfb4..ec9c6d5 100644
--- a/src/ns-handler.c
+++ b/src/ns-handler.c
@@ -30,7 +30,7 @@
* The #NSHandler object is a special extension used by #FeedHandlers to
* handle more tags in feeds. When unknow XML elements are found they are
* filtered by the #NSHandler, which check if that rappresent a valid
- * extension and populates the specified #FeedChannel (or #FeedItem) with
+ * extension and populates the specified #GrssFeedChannel (or #GrssFeedItem) with
* more attributes
*/
@@ -40,8 +40,8 @@ struct _NSHandlerPrivate {
};
typedef struct {
- gboolean (*handle_channel) (FeedChannel *channel, xmlNodePtr cur);
- void (*handle_item) (FeedItem *item, xmlNodePtr cur);
+ gboolean (*handle_channel) (GrssFeedChannel *channel, xmlNodePtr cur);
+ void (*handle_item) (GrssFeedItem *item, xmlNodePtr cur);
} InternalNsHandler;
G_DEFINE_TYPE (NSHandler, ns_handler, G_TYPE_OBJECT);
@@ -68,7 +68,7 @@ ns_handler_class_init (NSHandlerClass *klass)
}
static gboolean
-ns_admin_channel (FeedChannel *feed, xmlNodePtr cur)
+ns_admin_channel (GrssFeedChannel *feed, xmlNodePtr cur)
{
gchar *value;
gboolean ret;
@@ -77,11 +77,11 @@ ns_admin_channel (FeedChannel *feed, xmlNodePtr cur)
ret = FALSE;
if (!xmlStrcmp (BAD_CAST "errorReportsTo", cur->name)) {
- feed_channel_set_webmaster (feed, value);
+ grss_feed_channel_set_webmaster (feed, value);
ret = TRUE;
}
else if (!xmlStrcmp (BAD_CAST "generatorAgent", cur->name)) {
- feed_channel_set_generator (feed, value);
+ grss_feed_channel_set_generator (feed, value);
ret = TRUE;
}
@@ -90,21 +90,21 @@ ns_admin_channel (FeedChannel *feed, xmlNodePtr cur)
}
static void
-ns_content_item (FeedItem *item, xmlNodePtr cur)
+ns_content_item (GrssFeedItem *item, xmlNodePtr cur)
{
gchar *tmp;
if (!xmlStrcmp (cur->name, BAD_CAST "encoded")) {
tmp = xhtml_extract (cur, 0, NULL);
if (tmp) {
- feed_item_set_description (item, tmp);
+ grss_feed_item_set_description (item, tmp);
g_free (tmp);
}
}
}
static void
-ns_dc_item (FeedItem *item, xmlNodePtr cur)
+ns_dc_item (GrssFeedItem *item, xmlNodePtr cur)
{
time_t t;
gchar *value;
@@ -114,25 +114,25 @@ ns_dc_item (FeedItem *item, xmlNodePtr cur)
if (value) {
if (!xmlStrcmp (BAD_CAST "date", cur->name)) {
t = date_parse_ISO8601 (value);
- feed_item_set_publish_time (item, t);
+ grss_feed_item_set_publish_time (item, t);
}
else if (!xmlStrcmp (BAD_CAST "title", cur->name)) {
- feed_item_set_title (item, value);
+ grss_feed_item_set_title (item, value);
}
else if (!xmlStrcmp (BAD_CAST "creator", cur->name)) {
- feed_item_set_author (item, value);
+ grss_feed_item_set_author (item, value);
}
else if (!xmlStrcmp (BAD_CAST "subject", cur->name)) {
- feed_item_add_category (item, value);
+ grss_feed_item_add_category (item, value);
}
else if (!xmlStrcmp (BAD_CAST "description", cur->name)) {
- feed_item_set_description (item, value);
+ grss_feed_item_set_description (item, value);
}
else if (!xmlStrcmp (BAD_CAST "contributor", cur->name)) {
- feed_item_add_contributor (item, value);
+ grss_feed_item_add_contributor (item, value);
}
else if (!xmlStrcmp (BAD_CAST "rights", cur->name)) {
- feed_item_set_copyright (item, value);
+ grss_feed_item_set_copyright (item, value);
}
g_free (value);
@@ -140,7 +140,7 @@ ns_dc_item (FeedItem *item, xmlNodePtr cur)
}
static gboolean
-ns_dc_channel (FeedChannel *feed, xmlNodePtr cur)
+ns_dc_channel (GrssFeedChannel *feed, xmlNodePtr cur)
{
gchar *value;
gboolean ret;
@@ -150,31 +150,31 @@ ns_dc_channel (FeedChannel *feed, xmlNodePtr cur)
if (value) {
if (!xmlStrcmp (BAD_CAST "title", cur->name)) {
- feed_channel_set_title (feed, value);
+ grss_feed_channel_set_title (feed, value);
ret = TRUE;
}
else if (!xmlStrcmp (BAD_CAST "creator", cur->name)) {
- feed_channel_set_editor (feed, value);
+ grss_feed_channel_set_editor (feed, value);
ret = TRUE;
}
else if (!xmlStrcmp (BAD_CAST "subject", cur->name)) {
- feed_channel_set_category (feed, value);
+ grss_feed_channel_set_category (feed, value);
ret = TRUE;
}
else if (!xmlStrcmp (BAD_CAST "description", cur->name)) {
- feed_channel_set_description (feed, value);
+ grss_feed_channel_set_description (feed, value);
ret = TRUE;
}
else if (!xmlStrcmp (BAD_CAST "publisher", cur->name)) {
- feed_channel_set_webmaster (feed, value);
+ grss_feed_channel_set_webmaster (feed, value);
ret = TRUE;
}
else if (!xmlStrcmp (BAD_CAST "contributor", cur->name)) {
- feed_channel_add_contributor (feed, value);
+ grss_feed_channel_add_contributor (feed, value);
ret = TRUE;
}
else if (!xmlStrcmp (BAD_CAST "rights", cur->name)) {
- feed_channel_set_copyright (feed, value);
+ grss_feed_channel_set_copyright (feed, value);
ret = TRUE;
}
@@ -185,7 +185,7 @@ ns_dc_channel (FeedChannel *feed, xmlNodePtr cur)
}
static void
-ns_georss_item (FeedItem *item, xmlNodePtr cur)
+ns_georss_item (GrssFeedItem *item, xmlNodePtr cur)
{
gchar *tmp;
gchar *sep;
@@ -201,7 +201,7 @@ ns_georss_item (FeedItem *item, xmlNodePtr cur)
*sep = '\0';
latitude = strtod (tmp, NULL);
longitude = strtod (sep + 1, NULL);
- feed_item_set_geo_point (item, latitude, longitude);
+ grss_feed_item_set_geo_point (item, latitude, longitude);
}
g_free (tmp);
@@ -210,7 +210,7 @@ ns_georss_item (FeedItem *item, xmlNodePtr cur)
}
static void
-ns_geo_item (FeedItem *item, xmlNodePtr cur)
+ns_geo_item (GrssFeedItem *item, xmlNodePtr cur)
{
gchar *tmp;
double latitude;
@@ -234,25 +234,25 @@ ns_geo_item (FeedItem *item, xmlNodePtr cur)
}
}
- feed_item_set_geo_point (item, latitude, longitude);
+ grss_feed_item_set_geo_point (item, latitude, longitude);
}
static void
-ns_itunes_item (FeedItem *item, xmlNodePtr cur)
+ns_itunes_item (GrssFeedItem *item, xmlNodePtr cur)
{
gchar *tmp;
if (!xmlStrcmp (cur->name, BAD_CAST"author")) {
tmp = (gchar*) xmlNodeListGetString (cur->doc, cur->xmlChildrenNode, 1);
if (tmp) {
- feed_item_set_author (item, tmp);
+ grss_feed_item_set_author (item, tmp);
g_free (tmp);
}
}
if (!xmlStrcmp (cur->name, BAD_CAST"summary")) {
tmp = xhtml_extract (cur, 0, NULL);
- feed_item_add_category (item, tmp);
+ grss_feed_item_add_category (item, tmp);
g_free (tmp);
}
@@ -271,7 +271,7 @@ ns_itunes_item (FeedItem *item, xmlNodePtr cur)
keyword = g_utf8_next_char (keyword);
}
- feed_item_add_category (item, keyword);
+ grss_feed_item_add_category (item, keyword);
keyword = tmp;
}
@@ -280,7 +280,7 @@ ns_itunes_item (FeedItem *item, xmlNodePtr cur)
}
static gboolean
-ns_itunes_channel (FeedChannel *feed, xmlNodePtr cur)
+ns_itunes_channel (GrssFeedChannel *feed, xmlNodePtr cur)
{
gchar *tmp;
const gchar *old;
@@ -288,9 +288,9 @@ ns_itunes_channel (FeedChannel *feed, xmlNodePtr cur)
if (!xmlStrcmp (cur->name, BAD_CAST"summary") || !xmlStrcmp (cur->name, BAD_CAST"subtitle")) {
tmp = xhtml_extract (cur, 0, NULL);
- old = feed_channel_get_description (feed);
+ old = grss_feed_channel_get_description (feed);
if (!old || strlen (old) < strlen (tmp))
- feed_channel_set_description (feed, tmp);
+ grss_feed_channel_set_description (feed, tmp);
g_free (tmp);
return TRUE;
@@ -300,13 +300,13 @@ ns_itunes_channel (FeedChannel *feed, xmlNodePtr cur)
}
static void
-ns_media_item (FeedItem *item, xmlNodePtr cur)
+ns_media_item (GrssFeedItem *item, xmlNodePtr cur)
{
gchar *tmp;
gchar *tmp2;
gchar *tmp3;
- FeedEnclosure *enclosure;
- FeedChannel *feed;
+ GrssFeedEnclosure *enclosure;
+ GrssFeedChannel *feed;
/*
Maximual definition could look like this:
@@ -342,8 +342,8 @@ ns_media_item (FeedItem *item, xmlNodePtr cur)
if (lengthStr)
length = atol (lengthStr);
- feed = feed_item_get_parent (item);
- tmp3 = (gchar*) feed_channel_get_homepage (feed);
+ feed = grss_feed_item_get_parent (item);
+ tmp3 = (gchar*) grss_feed_channel_get_homepage (feed);
if ((strstr (tmp, "://") == NULL) &&
(tmp3 != NULL) &&
@@ -361,13 +361,13 @@ ns_media_item (FeedItem *item, xmlNodePtr cur)
}
else {
/* Never add enclosures for images already contained in the description */
- tmp2 = (gchar*) feed_item_get_description (item);
+ tmp2 = (gchar*) grss_feed_item_get_description (item);
if (!(tmp2 && strstr (tmp2, tmp))) {
- enclosure = feed_enclosure_new (tmp);
- feed_enclosure_set_format (enclosure, type);
- feed_enclosure_set_length (enclosure, length);
- feed_item_add_enclosure (item, enclosure);
+ enclosure = grss_feed_enclosure_new (tmp);
+ grss_feed_enclosure_set_format (enclosure, type);
+ grss_feed_enclosure_set_length (enclosure, length);
+ grss_feed_item_add_enclosure (item, enclosure);
}
}
@@ -382,13 +382,13 @@ ns_media_item (FeedItem *item, xmlNodePtr cur)
}
static gboolean
-ns_syn_channel (FeedChannel *channel, xmlNodePtr cur)
+ns_syn_channel (GrssFeedChannel *channel, xmlNodePtr cur)
{
xmlChar *tmp;
gint period;
gint frequency = 1;
- period = feed_channel_get_update_interval (channel);
+ period = grss_feed_channel_get_update_interval (channel);
if (!xmlStrcmp (cur->name, BAD_CAST"updatePeriod")) {
if (NULL != (tmp = xmlNodeListGetString (cur->doc, cur->xmlChildrenNode, 1))) {
@@ -419,12 +419,12 @@ ns_syn_channel (FeedChannel *channel, xmlNodePtr cur)
if (0 != frequency)
period /= frequency;
- feed_channel_set_update_interval (channel, period);
+ grss_feed_channel_set_update_interval (channel, period);
return TRUE;
}
static void
-ns_trackback_item (FeedItem *item, xmlNodePtr cur)
+ns_trackback_item (GrssFeedItem *item, xmlNodePtr cur)
{
gchar *tmp;
@@ -441,13 +441,13 @@ ns_trackback_item (FeedItem *item, xmlNodePtr cur)
tmp = (gchar*) xmlNodeListGetString (cur->doc, cur->xmlChildrenNode, 1);
if (tmp) {
- feed_item_set_related (item, tmp);
+ grss_feed_item_set_related (item, tmp);
g_free (tmp);
}
}
static void
-ns_wfw_item (FeedItem *item, xmlNodePtr cur)
+ns_wfw_item (GrssFeedItem *item, xmlNodePtr cur)
{
gchar *uri = NULL;
@@ -455,13 +455,13 @@ ns_wfw_item (FeedItem *item, xmlNodePtr cur)
uri = (gchar*) xmlNodeListGetString (cur->doc, cur->xmlChildrenNode, 1);
if (uri) {
- feed_item_set_comments_url (item, uri);
+ grss_feed_item_set_comments_url (item, uri);
g_free (uri);
}
}
static gboolean
-ns_atom10_channel (FeedChannel *feed, xmlNodePtr cur)
+ns_atom10_channel (GrssFeedChannel *feed, xmlNodePtr cur)
{
/*
Used to manage PubSubHubbub information in RSS feeds
@@ -477,9 +477,9 @@ ns_atom10_channel (FeedChannel *feed, xmlNodePtr cur)
href = (gchar*) xmlGetNsProp (cur, BAD_CAST "href", NULL);
if (strcmp (relation, "self") == 0)
- feed_channel_set_pubsubhub (feed, NULL, href);
+ grss_feed_channel_set_pubsubhub (feed, NULL, href);
else if (strcmp (relation, "hub") == 0)
- feed_channel_set_pubsubhub (feed, href, NULL);
+ grss_feed_channel_set_pubsubhub (feed, href, NULL);
g_free (relation);
g_free (href);
@@ -657,7 +657,7 @@ retrieve_internal_handler (NSHandler *handler, xmlNodePtr cur)
* otherwise
*/
gboolean
-ns_handler_channel (NSHandler *handler, FeedChannel *feed, xmlNodePtr cur)
+ns_handler_channel (NSHandler *handler, GrssFeedChannel *feed, xmlNodePtr cur)
{
InternalNsHandler *nsh;
@@ -681,7 +681,7 @@ ns_handler_channel (NSHandler *handler, FeedChannel *feed, xmlNodePtr cur)
* otherwise
*/
gboolean
-ns_handler_item (NSHandler *handler, FeedItem *item, xmlNodePtr cur)
+ns_handler_item (NSHandler *handler, GrssFeedItem *item, xmlNodePtr cur)
{
InternalNsHandler *nsh;
diff --git a/src/ns-handler.h b/src/ns-handler.h
index bbaf433..59d806b 100644
--- a/src/ns-handler.h
+++ b/src/ns-handler.h
@@ -46,7 +46,7 @@ GType ns_handler_get_type () G_GNUC_CONST;
NSHandler* ns_handler_new ();
-gboolean ns_handler_channel (NSHandler *handler, FeedChannel *feed, xmlNodePtr cur);
-gboolean ns_handler_item (NSHandler *handler, FeedItem *item, xmlNodePtr cur);
+gboolean ns_handler_channel (NSHandler *handler, GrssFeedChannel *feed, xmlNodePtr cur);
+gboolean ns_handler_item (NSHandler *handler, GrssFeedItem *item, xmlNodePtr cur);
#endif /* __NS_HANDLER_H__ */
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
