summaryrefslogtreecommitdiffstats
path: root/akregator/src/feedstoragedummyimpl.cpp
diff options
context:
space:
mode:
authortoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
committertoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
commit460c52653ab0dcca6f19a4f492ed2c5e4e963ab0 (patch)
tree67208f7c145782a7e90b123b982ca78d88cc2c87 /akregator/src/feedstoragedummyimpl.cpp
downloadtdepim-460c52653ab0dcca6f19a4f492ed2c5e4e963ab0.tar.gz
tdepim-460c52653ab0dcca6f19a4f492ed2c5e4e963ab0.zip
Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.
BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdepim@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'akregator/src/feedstoragedummyimpl.cpp')
-rw-r--r--akregator/src/feedstoragedummyimpl.cpp469
1 files changed, 469 insertions, 0 deletions
diff --git a/akregator/src/feedstoragedummyimpl.cpp b/akregator/src/feedstoragedummyimpl.cpp
new file mode 100644
index 000000000..f1e194949
--- /dev/null
+++ b/akregator/src/feedstoragedummyimpl.cpp
@@ -0,0 +1,469 @@
+/*
+ This file is part of Akregator.
+
+ Copyright (C) 2005 Frank Osterfeld <frank.osterfeld@kdemail.net>
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+ As a special exception, permission is given to link this program
+ with any edition of Qt, and distribute the resulting executable,
+ without including the source code for Qt in the source distribution.
+*/
+
+#include "feedstoragedummyimpl.h"
+#include "storagedummyimpl.h"
+
+#include <feed.h>
+
+#include <qmap.h>
+#include <qstring.h>
+#include <qstringlist.h>
+#include <qvaluelist.h>
+
+//typedef unsigned int uint;
+namespace Akregator {
+namespace Backend {
+
+class FeedStorageDummyImpl::FeedStorageDummyImplPrivate
+{
+ public:
+ class Entry
+ {
+ public:
+ Entry() : guidIsHash(false), guidIsPermaLink(false), status(0), pubDate(0), hash(0) {}
+ StorageDummyImpl* mainStorage;
+ QValueList<Category> categories;
+ QString title;
+ QString description;
+ QString link;
+ QString author;
+ QString commentsLink;
+ bool guidIsHash;
+ bool guidIsPermaLink;
+ int comments;
+ int status;
+ uint pubDate;
+ uint hash;
+ QStringList tags;
+ bool hasEnclosure;
+ QString enclosureUrl;
+ QString enclosureType;
+ int enclosureLength;
+ };
+ QMap<QString, Entry> entries;
+
+ // all tags occurring in the feed
+ QStringList tags;
+
+ // tag -> articles index
+ QMap<QString, QStringList > taggedArticles;
+
+ QValueList<Category> categories;
+ QMap<Category, QStringList> categorizedArticles;
+
+ Storage* mainStorage;
+ QString url;
+};
+
+
+void FeedStorageDummyImpl::convertOldArchive()
+{
+}
+
+FeedStorageDummyImpl::FeedStorageDummyImpl(const QString& url, StorageDummyImpl* main) : d(new FeedStorageDummyImplPrivate)
+{
+ d->url = url;
+ d->mainStorage = main;
+}
+
+FeedStorageDummyImpl::~FeedStorageDummyImpl()
+{
+ delete d; d = 0;
+}
+
+void FeedStorageDummyImpl::commit()
+{
+}
+
+void FeedStorageDummyImpl::rollback()
+{
+}
+
+void FeedStorageDummyImpl::close()
+{
+}
+
+int FeedStorageDummyImpl::unread()
+{
+ return d->mainStorage->unreadFor(d->url);
+}
+
+void FeedStorageDummyImpl::setUnread(int unread)
+{
+ d->mainStorage->setUnreadFor(d->url, unread);
+}
+
+int FeedStorageDummyImpl::totalCount()
+{
+ return d->mainStorage->totalCountFor(d->url);
+}
+
+void FeedStorageDummyImpl::setTotalCount(int total)
+{
+ d->mainStorage->setTotalCountFor(d->url, total);
+}
+
+int FeedStorageDummyImpl::lastFetch()
+{
+ return d->mainStorage->lastFetchFor(d->url);
+}
+
+void FeedStorageDummyImpl::setLastFetch(int lastFetch)
+{
+ d->mainStorage->setLastFetchFor(d->url, lastFetch);
+}
+
+QStringList FeedStorageDummyImpl::articles(const QString& tag)
+{
+ return tag.isNull() ? QStringList(d->entries.keys()) : d->taggedArticles[tag];
+}
+
+QStringList FeedStorageDummyImpl::articles(const Category& cat)
+{
+ return d->categorizedArticles[cat];
+}
+
+void FeedStorageDummyImpl::addEntry(const QString& guid)
+{
+ if (!d->entries.contains(guid))
+ {
+ d->entries[guid] = FeedStorageDummyImplPrivate::Entry();
+ setTotalCount(totalCount()+1);
+ }
+}
+
+bool FeedStorageDummyImpl::contains(const QString& guid)
+{
+ return d->entries.contains(guid);
+}
+
+void FeedStorageDummyImpl::deleteArticle(const QString& guid)
+{
+ if (!d->entries.contains(guid))
+ return;
+
+ setDeleted(guid);
+
+ d->entries.remove(guid);
+}
+
+int FeedStorageDummyImpl::comments(const QString& guid)
+{
+
+ return contains(guid) ? d->entries[guid].comments : 0;
+}
+
+QString FeedStorageDummyImpl::commentsLink(const QString& guid)
+{
+ return contains(guid) ? d->entries[guid].commentsLink : "";
+}
+
+bool FeedStorageDummyImpl::guidIsHash(const QString& guid)
+{
+ return contains(guid) ? d->entries[guid].guidIsHash : false;
+}
+
+bool FeedStorageDummyImpl::guidIsPermaLink(const QString& guid)
+{
+ return contains(guid) ? d->entries[guid].guidIsPermaLink : false;
+}
+
+uint FeedStorageDummyImpl::hash(const QString& guid)
+{
+ return contains(guid) ? d->entries[guid].hash : 0;
+}
+
+
+void FeedStorageDummyImpl::setDeleted(const QString& guid)
+{
+ if (!contains(guid))
+ return;
+
+ FeedStorageDummyImplPrivate::Entry entry = d->entries[guid];
+
+ // remove article from tag->article index
+ QStringList::ConstIterator it = entry.tags.begin();
+ QStringList::ConstIterator end = entry.tags.end();
+
+ for ( ; it != end; ++it)
+ {
+ d->taggedArticles[*it].remove(guid);
+ if (d->taggedArticles[*it].count() == 0)
+ d->tags.remove(*it);
+ }
+
+ // remove article from tag->category index
+ QValueList<Category>::ConstIterator it2 = entry.categories.begin();
+ QValueList<Category>::ConstIterator end2 = entry.categories.end();
+
+ for ( ; it2 != end2; ++it2)
+ {
+ d->categorizedArticles[*it2].remove(guid);
+ if (d->categorizedArticles[*it2].count() == 0)
+ d->categories.remove(*it2);
+ }
+
+ entry.description = "";
+ entry.title = "";
+ entry.link = "";
+ entry.commentsLink = "";
+}
+
+QString FeedStorageDummyImpl::link(const QString& guid)
+{
+ return contains(guid) ? d->entries[guid].link : "";
+}
+
+uint FeedStorageDummyImpl::pubDate(const QString& guid)
+{
+ return contains(guid) ? d->entries[guid].pubDate : 0;
+}
+
+int FeedStorageDummyImpl::status(const QString& guid)
+{
+ return contains(guid) ? d->entries[guid].status : 0;
+}
+
+void FeedStorageDummyImpl::setStatus(const QString& guid, int status)
+{
+ if (contains(guid))
+ d->entries[guid].status = status;
+}
+
+QString FeedStorageDummyImpl::title(const QString& guid)
+{
+ return contains(guid) ? d->entries[guid].title : "";
+}
+
+QString FeedStorageDummyImpl::description(const QString& guid)
+{
+ return contains(guid) ? d->entries[guid].description : "";
+}
+
+
+void FeedStorageDummyImpl::setPubDate(const QString& guid, uint pubdate)
+{
+ if (contains(guid))
+ d->entries[guid].pubDate = pubdate;
+}
+
+void FeedStorageDummyImpl::setGuidIsHash(const QString& guid, bool isHash)
+{
+ if (contains(guid))
+ d->entries[guid].guidIsHash = isHash;
+}
+
+void FeedStorageDummyImpl::setLink(const QString& guid, const QString& link)
+{
+ if (contains(guid))
+ d->entries[guid].link = link;
+}
+
+void FeedStorageDummyImpl::setHash(const QString& guid, uint hash)
+{
+ if (contains(guid))
+ d->entries[guid].hash = hash;
+}
+
+void FeedStorageDummyImpl::setTitle(const QString& guid, const QString& title)
+{
+ if (contains(guid))
+ d->entries[guid].title = title;
+}
+
+void FeedStorageDummyImpl::setDescription(const QString& guid, const QString& description)
+{
+ if (contains(guid))
+ d->entries[guid].description = description;
+}
+
+void FeedStorageDummyImpl::setCommentsLink(const QString& guid, const QString& commentsLink)
+{
+ if (contains(guid))
+ d->entries[guid].commentsLink = commentsLink;
+}
+
+void FeedStorageDummyImpl::setComments(const QString& guid, int comments)
+{
+ if (contains(guid))
+ d->entries[guid].comments = comments;
+}
+
+
+void FeedStorageDummyImpl::setGuidIsPermaLink(const QString& guid, bool isPermaLink)
+{
+ if (contains(guid))
+ d->entries[guid].guidIsPermaLink = isPermaLink;
+}
+
+void FeedStorageDummyImpl::addTag(const QString& guid, const QString& tag)
+{
+ if (contains(guid))
+ {
+ d->entries[guid].tags.append(tag);
+ if (!d->taggedArticles[tag].contains(guid))
+ d->taggedArticles[tag].append(guid);
+ if (!d->tags.contains(tag))
+ d->tags.append(tag);
+ }
+
+}
+
+void FeedStorageDummyImpl::addCategory(const QString& guid, const Category& cat)
+{
+ if (!contains(guid))
+ return;
+
+ d->entries[guid].categories.append(cat);
+
+ if (d->categorizedArticles[cat].count() == 0)
+ d->categories.append(cat);
+ d->categorizedArticles[cat].append(guid);
+}
+
+void FeedStorageDummyImpl::setAuthor(const QString& guid, const QString& author)
+{
+ if (contains(guid))
+ d->entries[guid].author = author;
+}
+
+QString FeedStorageDummyImpl::author(const QString& guid)
+{
+ return contains(guid) ? d->entries[guid].author : QString();
+}
+
+QValueList<Category> FeedStorageDummyImpl::categories(const QString& guid)
+{
+ if (!guid.isNull())
+ return contains(guid) ? d->entries[guid].categories : QValueList<Category>();
+ else
+ return d->categories;
+}
+
+
+void FeedStorageDummyImpl::removeTag(const QString& guid, const QString& tag)
+{
+ if (contains(guid))
+ {
+ d->entries[guid].tags.remove(tag);
+ d->taggedArticles[tag].remove(guid);
+ if (d->taggedArticles[tag].count() == 0)
+ d->tags.remove(tag);
+ }
+}
+
+QStringList FeedStorageDummyImpl::tags(const QString& guid)
+{
+ if (!guid.isNull())
+ return contains(guid) ? d->entries[guid].tags : QStringList();
+ else
+ {
+ return d->tags;
+ }
+}
+
+void FeedStorageDummyImpl::add(FeedStorage* source)
+{
+ QStringList articles = source->articles();
+ for (QStringList::ConstIterator it = articles.begin(); it != articles.end(); ++it)
+ copyArticle(*it, source);
+ setUnread(source->unread());
+ setLastFetch(source->lastFetch());
+ setTotalCount(source->totalCount());
+}
+
+void FeedStorageDummyImpl::copyArticle(const QString& guid, FeedStorage* source)
+{
+ if (!contains(guid))
+ addEntry(guid);
+
+ setComments(guid, source->comments(guid));
+ setCommentsLink(guid, source->commentsLink(guid));
+ setDescription(guid, source->description(guid));
+ setGuidIsHash(guid, source->guidIsHash(guid));
+ setGuidIsPermaLink(guid, source->guidIsPermaLink(guid));
+ setHash(guid, source->hash(guid));
+ setLink(guid, source->link(guid));
+ setPubDate(guid, source->pubDate(guid));
+ setStatus(guid, source->status(guid));
+ setTitle(guid, source->title(guid));
+ QStringList tags = source->tags(guid);
+
+ for (QStringList::ConstIterator it = tags.begin(); it != tags.end(); ++it)
+ addTag(guid, *it);
+}
+
+void FeedStorageDummyImpl::clear()
+{
+ d->entries.clear();
+ setUnread(0);
+ setTotalCount(0);
+}
+
+void FeedStorageDummyImpl::setEnclosure(const QString& guid, const QString& url, const QString& type, int length)
+{
+ if (contains(guid))
+ {
+ FeedStorageDummyImplPrivate::Entry entry = d->entries[guid];
+ entry.hasEnclosure = true;
+ entry.enclosureUrl = url;
+ entry.enclosureType = type;
+ entry.enclosureLength = length;
+ }
+}
+
+void FeedStorageDummyImpl::removeEnclosure(const QString& guid)
+{
+ if (contains(guid))
+ {
+ FeedStorageDummyImplPrivate::Entry entry = d->entries[guid];
+ entry.hasEnclosure = false;
+ entry.enclosureUrl = QString::null;
+ entry.enclosureType = QString::null;
+ entry.enclosureLength = -1;
+ }
+}
+
+void FeedStorageDummyImpl::enclosure(const QString& guid, bool& hasEnclosure, QString& url, QString& type, int& length)
+{
+ if (contains(guid))
+ {
+ FeedStorageDummyImplPrivate::Entry entry = d->entries[guid];
+ hasEnclosure = entry.hasEnclosure;
+ url = entry.enclosureUrl;
+ type = entry.enclosureType;
+ length = entry.enclosureLength;
+ }
+ else
+ {
+ hasEnclosure = false;
+ url = QString::null;
+ type = QString::null;
+ length = -1;
+ }
+}
+
+} // namespace Backend
+} // namespace Akregator