summaryrefslogtreecommitdiffstats
path: root/akregator/src/articlefilter.h
blob: ddf05490e7d1c997c9075e6bd7e709861493d842 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
/*
 * articlefilter.h
 *
 * Copyright (c) 2004, 2005 Frerich Raabe <raabe@kde.org>
 *               2005 Frank Osterfeld <frank.osterfeld@kdemail.net>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSETQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#ifndef ARTICLEFILTER_H
#define ARTICLEFILTER_H

#include <tqstring.h>
#include <tqvaluelist.h>
#include <tqvariant.h>

class KConfig;

namespace Akregator {

class Article;

namespace Filters {

class AbstractAction;
class AbstractMatcher;
class Criterion;

/** an article filter, basically a matcher and an action. 
 *  @author Frank Osterfeld
 */
class ArticleFilter
{
    public:

        ArticleFilter();
        ArticleFilter(const AbstractMatcher& matcher, const AbstractAction& action);
        ArticleFilter(const ArticleFilter& other);

        virtual ~ArticleFilter();

        /** checks whether an article matches the matcher, and executes the action if so */
        void applyTo(Article& article) const;

        
        
        /** name of the filter, for display in filter list */
        const TQString& name() const;
        void setName(const TQString& name);

        int id() const;

        AbstractMatcher* matcher() const;
        void setMatcher(const AbstractMatcher& matcher);

        AbstractAction* action() const;
        void setAction(const AbstractAction& action);

        ArticleFilter& operator=(const ArticleFilter& other);
        bool operator==(const ArticleFilter& other) const;

        void writeConfig(KConfig* config) const;
        void readConfig(KConfig* config);

    private:
        class ArticleFilterPrivate;
        ArticleFilterPrivate* d;
    
};

class ArticleFilterList : public TQValueList<ArticleFilter>
{
public:
    
    void writeConfig(KConfig* config) const;
    void readConfig(KConfig* config);
};

/** Abstract base class for matchers, a matcher just takes an article and checks whether the article matches some criterion or not. 
 *  @author Frank Osterfeld
 */
class AbstractMatcher
{
    public:

        virtual ~AbstractMatcher() {}
        /** returns a copy of the matcher */
        virtual AbstractMatcher* clone() const = 0;

        virtual bool matches(const Article& article) const = 0;

        virtual void writeConfig(KConfig* config) const = 0;
        virtual void readConfig(KConfig* config) = 0;

        virtual bool operator==(const AbstractMatcher&) const = 0;
        virtual bool operator!=(const AbstractMatcher &other) const = 0;
};

class TagMatcher : public AbstractMatcher
{
    public:

        TagMatcher();
        TagMatcher(const TQString& tagID);
        TagMatcher(const TagMatcher& other);
        
        virtual ~TagMatcher();
        

        virtual bool matches(const Article& article) const;

        virtual TagMatcher* clone() const;

        virtual void writeConfig(KConfig* config) const;
        virtual void readConfig(KConfig* config);

        TagMatcher& operator=(const TagMatcher& other);
        virtual bool operator==(const AbstractMatcher&) const;
        virtual bool operator!=(const AbstractMatcher &other) const;
        
    private:
    
         class TagMatcherPrivate;
         TagMatcherPrivate* d;
};

class AbstractAction
{
    public:
        virtual void exec(Article& article) = 0;

        virtual void writeConfig(KConfig* config) const = 0;
        virtual void readConfig(KConfig* config) = 0;

        virtual AbstractAction* clone() const = 0;
        virtual bool operator==(const AbstractAction& other) = 0;
};

class DeleteAction : public AbstractAction
{
    public:
        virtual void exec(Article& article);
        
        virtual void writeConfig(KConfig* config) const;
        virtual void readConfig(KConfig* config);

        virtual DeleteAction* clone() const { return new DeleteAction; }
        virtual bool operator==(const AbstractAction& other);
};

class SeStatusAction : public AbstractAction
{
    public:
        SeStatusAction(int status=0);
        
        virtual void exec(Article& article);
        
        int status() const;
        void seStatus(int status);

        virtual void writeConfig(KConfig* config) const;
        virtual void readConfig(KConfig* config);

        virtual SeStatusAction* clone() const { return new SeStatusAction(*this); }
        virtual bool operator==(const AbstractAction& other);

    private:
        int m_status;
};

class AssignTagAction : public AbstractAction
{
    public:

        AssignTagAction(const TQString& tagID=TQString());
        virtual void exec(Article& article);
                
        const TQString& tagID() const;
        void setTagID(const TQString& tagID);

        virtual void writeConfig(KConfig* config) const;
        virtual void readConfig(KConfig* config);

        virtual AssignTagAction* clone() const { return new AssignTagAction(*this); }
        virtual bool operator==(const AbstractAction& other);

    private:
        TQString m_tagID;
};

/** a powerful matcher supporting multiple criterions, which can be combined      via logical OR or AND
 *  @author Frerich Raabe
 */
class ArticleMatcher : public AbstractMatcher
{
    public:

        enum Association {
            None, LogicalAnd, LogicalOr
        };

        ArticleMatcher();
        ArticleMatcher( const TQValueList<Criterion> &criteria, Association assoc);
        
        ArticleMatcher(const ArticleMatcher& other);
        virtual ~ArticleMatcher();

        /**
         * returns whether the matcher matches all articles anyway (empty criteria list),
         * so there is no need to call matches() at all.
         */
        virtual bool matchesAll() const;
        
        ArticleMatcher& operator=(const ArticleMatcher& other);
        virtual ArticleMatcher* clone() const;
        virtual bool matches(const Article &article) const;
        virtual bool operator==(const AbstractMatcher &other) const;
        virtual bool operator!=(const AbstractMatcher &other) const;
        
        
        virtual void writeConfig(KConfig* config) const;
        virtual void readConfig(KConfig* config);

    private:

        static Association stringToAssociation(const TQString& assocStr);
        static TQString associationToString(Association association);

        bool anyCriterionMatches( const Article &a ) const;
        bool allCriteriaMatch( const Article &a ) const;

        TQValueList<Criterion> m_criteria;
        Association m_association;
};

/** Criterion for ArticleMatcher
 *  @author Frerich Raabe
 */
class Criterion
{
    public:

        enum Subject {
            Title, Description, Author, Link, Status, KeepFlag
        };

        static TQString subjectToString(Subject subj);
        static Subject stringToSubject(const TQString& subjStr);

        enum Predicate {
            Contains = 0x01,
            Equals = 0x02,
            Matches = 0x03,
            Negation = 0x80
        };

        static TQString predicateToString(Predicate pred);
        static Predicate stringToPredicate(const TQString& predStr);
    
        Criterion();
        Criterion( Subject subject, Predicate predicate, const TQVariant &object );
        
        bool satisfiedBy( const Article &article ) const;

        virtual void writeConfig(KConfig* config) const;
        virtual void readConfig(KConfig* config);

        Subject subject() const;
        Predicate predicate() const;
        TQVariant object() const;
        bool operator==(const Criterion& other) const
        { return m_subject == other.m_subject && m_predicate == other.m_predicate && m_object == other.m_object; }
        
    private:
        Subject m_subject;
        Predicate m_predicate;
        TQVariant m_object;
};

} // namespace Filters
} // namespace Akregator

#endif