Parent: [de82f1] (diff)

Child: [bd100b] (diff)

Download this file

docseq.h    292 lines (261 with data), 8.1 kB

  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
/* Copyright (C) 2004 J.F.Dockes
* 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.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef _DOCSEQ_H_INCLUDED_
#define _DOCSEQ_H_INCLUDED_
#include <string>
#include <list>
#include <vector>
#include "rcldoc.h"
#include "refcntr.h"
#include "hldata.h"
// Need this for the "Snippet" class def.
#include "rclquery.h"
// A result list entry.
struct ResListEntry {
Rcl::Doc doc;
std::string subHeader;
};
/** Sort specification. */
class DocSeqSortSpec {
public:
DocSeqSortSpec() : desc(false) {}
bool isNotNull() const {return !field.empty();}
void reset() {field.erase();}
std::string field;
bool desc;
};
/** Filtering spec. This is only used to filter by doc category for now, hence
the rather specialized interface */
class DocSeqFiltSpec {
public:
DocSeqFiltSpec() {}
enum Crit {DSFS_MIMETYPE, DSFS_QLANG, DSFS_PASSALL};
void orCrit(Crit crit, const std::string& value) {
crits.push_back(crit);
values.push_back(value);
}
std::vector<Crit> crits;
std::vector<std::string> values;
void reset() {crits.clear(); values.clear();}
bool isNotNull() const {return crits.size() != 0;}
};
/** Interface for a list of documents coming from some source.
The result list display data may come from different sources (ie:
history or Db query), and be post-processed (DocSeqSorted).
Additional functionality like filtering/sorting can either be
obtained by stacking DocSequence objects (ie: sorting history), or
by native capability (ex: docseqdb can sort and filter). The
implementation might be nicer by using more sophisticated c++ with
multiple inheritance of sort and filter virtual interfaces, but
the current one will have to do for now.
*/
class DocSequence {
public:
DocSequence(const std::string &t) : m_title(t) {}
virtual ~DocSequence() {}
/** Get document at given rank.
*
* @param num document rank in sequence
* @param doc return data
* @param sh subheader to display before this result (ie: date change
* inside history)
* @return true if ok, false for error or end of data
*/
virtual bool getDoc(int num, Rcl::Doc &doc, std::string *sh = 0) = 0;
/** Get next page of documents. This accumulates entries into the result
* list parameter (doesn't reset it). */
virtual int getSeqSlice(int offs, int cnt,
std::vector<ResListEntry>& result);
/** Get abstract for document. This is special because it may take time.
* The default is to return the input doc's abstract fields, but some
* sequences can compute a better value (ie: docseqdb) */
virtual bool getAbstract(Rcl::Doc& doc, std::vector<std::string>& abs) {
abs.push_back(doc.meta[Rcl::Doc::keyabs]);
return true;
}
virtual bool getAbstract(Rcl::Doc& doc,
std::vector<Rcl::Snippet>& abs)
{
abs.push_back(Rcl::Snippet(0, doc.meta[Rcl::Doc::keyabs]));
return true;
}
virtual int getFirstMatchPage(Rcl::Doc&, std::string&)
{
return -1;
}
/** Get duplicates. */
virtual bool docDups(const Rcl::Doc&, std::vector<Rcl::Doc>&)
{
return false;
}
virtual bool getEnclosing(Rcl::Doc&, Rcl::Doc&);
/** Get estimated total count in results */
virtual int getResCnt() = 0;
/** Get title for result list */
virtual std::string title()
{
return m_title;
}
/** Can do snippets ? */
virtual bool snippetsCapable()
{
return false;
}
/** Get description for underlying query */
virtual std::string getDescription() = 0;
/** Get search terms (for highlighting abstracts). Some sequences
* may have no associated search terms. Implement this for them. */
virtual void getTerms(HighlightData& hld)
{
hld.clear();
}
virtual std::list<std::string> expand(Rcl::Doc &)
{
return std::list<std::string>();
}
virtual std::string getReason()
{
return m_reason;
}
/** Optional functionality. */
virtual bool canFilter() {return false;}
virtual bool canSort() {return false;}
virtual bool setFiltSpec(const DocSeqFiltSpec &) {return false;}
virtual bool setSortSpec(const DocSeqSortSpec &) {return false;}
virtual RefCntr<DocSequence> getSourceSeq() {return RefCntr<DocSequence>();}
static void set_translations(const std::string& sort, const std::string& filt)
{
o_sort_trans = sort;
o_filt_trans = filt;
}
virtual Rcl::Db *getDb() = 0;
protected:
static std::string o_sort_trans;
static std::string o_filt_trans;
std::string m_reason;
private:
std::string m_title;
};
/** A modifier has a child sequence which does the real work and does
* something with the results. Some operations are just delegated
*/
class DocSeqModifier : public DocSequence {
public:
DocSeqModifier(RefCntr<DocSequence> iseq)
: DocSequence(""), m_seq(iseq)
{}
virtual ~DocSeqModifier() {}
virtual bool getAbstract(Rcl::Doc& doc, std::vector<std::string>& abs)
{
if (m_seq.isNull())
return false;
return m_seq->getAbstract(doc, abs);
}
virtual bool getAbstract(Rcl::Doc& doc,
std::vector<Rcl::Snippet>& abs)
{
if (m_seq.isNull())
return false;
return m_seq->getAbstract(doc, abs);
}
/** Get duplicates. */
virtual bool docDups(const Rcl::Doc& doc, std::vector<Rcl::Doc>& dups)
{
if (m_seq.isNull())
return false;
return m_seq->docDups(doc, dups);
}
virtual bool snippetsCapable()
{
if (m_seq.isNull())
return false;
return m_seq->snippetsCapable();
}
virtual std::string getDescription()
{
if (m_seq.isNull())
return "";
return m_seq->getDescription();
}
virtual void getTerms(HighlightData& hld)
{
if (m_seq.isNull())
return;
m_seq->getTerms(hld);
}
virtual bool getEnclosing(Rcl::Doc& doc, Rcl::Doc& pdoc)
{
if (m_seq.isNull())
return false;
return m_seq->getEnclosing(doc, pdoc);
}
virtual std::string getReason()
{
if (m_seq.isNull())
return string();
return m_seq->getReason();
}
virtual std::string title()
{
return m_seq->title();
}
virtual RefCntr<DocSequence> getSourceSeq()
{
return m_seq;
}
virtual Rcl::Db *getDb()
{
if (m_seq.isNull())
return 0;
return m_seq->getDb();
}
protected:
RefCntr<DocSequence> m_seq;
};
class RclConfig;
// A DocSource can juggle docseqs of different kinds to implement
// sorting and filtering in ways depending on the base seqs capabilities
class DocSource : public DocSeqModifier {
public:
DocSource(RclConfig *config, RefCntr<DocSequence> iseq)
: DocSeqModifier(iseq), m_config(config)
{}
virtual bool canFilter() {return true;}
virtual bool canSort() {return true;}
virtual bool setFiltSpec(const DocSeqFiltSpec &);
virtual bool setSortSpec(const DocSeqSortSpec &);
virtual bool getDoc(int num, Rcl::Doc &doc, std::string *sh = 0)
{
if (m_seq.isNull())
return false;
return m_seq->getDoc(num, doc, sh);
}
virtual int getResCnt()
{
if (m_seq.isNull())
return 0;
return m_seq->getResCnt();
}
virtual std::string title();
private:
bool buildStack();
void stripStack();
RclConfig *m_config;
DocSeqFiltSpec m_fspec;
DocSeqSortSpec m_sspec;
};
#endif /* _DOCSEQ_H_INCLUDED_ */