Parent: [2fc294] (diff)

Child: [a7728c] (diff)

Download this file

mimehandler.h    153 lines (130 with data), 4.7 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
/* 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 _MIMEHANDLER_H_INCLUDED_
#define _MIMEHANDLER_H_INCLUDED_
#include "autoconfig.h"
#include <stdio.h>
#include <string>
#include <list>
using std::string;
using std::list;
#include <Filter.h>
class RclConfig;
class RecollFilter : public Dijon::Filter {
public:
RecollFilter(RclConfig *config, const string& mtype)
: Dijon::Filter(mtype), m_config(config),
m_forPreview(false), m_havedoc(false)
{}
virtual ~RecollFilter() {}
virtual void setConfig(RclConfig *config)
{
m_config = config;
}
virtual bool set_property(Properties p, const string &v) {
switch (p) {
case DJF_UDI:
m_udi = v;
break;
case DEFAULT_CHARSET:
m_dfltInputCharset = v;
break;
case OPERATING_MODE:
if (!v.empty() && v[0] == 'v')
m_forPreview = true;
else
m_forPreview = false;
break;
}
return true;
}
// We don't use this for now
virtual bool set_document_uri(const std::string &) {return false;}
// This does nothing right now but should be called from the
// subclass method in case we need some common processing one day
// (was used for xattrs at some point). Yes this is the "call
// super" anti-pattern, bad, but we have several layers of derived
// classes, so that implementing the template method approach (by
// having a pure virtual called from here and implemented in the
// subclass) would have to be repeated in each derived class. It's
// just simpler this way.
virtual bool set_document_file(const string & /*file_path*/) {return true;}
// Default implementations
virtual bool set_document_string(const std::string &) {return false;}
virtual bool set_document_data(const char *cp, unsigned int sz) {
return set_document_string(string(cp, sz));
}
virtual void set_docsize(size_t size)
{
char csize[30];
sprintf(csize, "%lld", (long long)size);
m_metaData[cstr_dj_keydocsize] = csize;
}
virtual bool has_documents() const {return m_havedoc;}
// Most doc types are single-doc
virtual bool skip_to_document(const string& s) {
if (s.empty())
return true;
return false;
}
virtual bool is_data_input_ok(DataInput input) const {
if (input == DOCUMENT_FILE_NAME)
return true;
return false;
}
virtual string get_error() const {
return m_reason;
}
// "Call super" anti-pattern again. Must be called from derived
// classes which reimplement clear()
virtual void clear() {
Dijon::Filter::clear();
m_forPreview = m_havedoc = false;
m_dfltInputCharset.clear();
m_reason.clear();
}
// This only makes sense if the contents are currently txt/plain
// It converts from keyorigcharset to UTF-8 and sets keycharset.
bool txtdcode(const string& who);
protected:
bool preview() {return m_forPreview;}
RclConfig *m_config;
bool m_forPreview;
string m_dfltInputCharset;
string m_reason;
bool m_havedoc;
string m_udi; // May be set by creator as a hint
};
/**
* Return indexing handler object for the given mime type. The returned
* pointer should be passed to returnMimeHandler() for recycling, after use.
* @param mtyp input mime type, ie text/plain
* @param cfg the recoll config object to be used
* @param filtertypes decide if we should restrict to types in
* indexedmimetypes (if this is set at all).
*/
extern Dijon::Filter *getMimeHandler(const std::string &mtyp, RclConfig *cfg,
bool filtertypes=false);
/// Free up filter for reuse (you can also delete it)
extern void returnMimeHandler(Dijon::Filter *);
/// Clean up cache at the end of an indexing pass. For people who use
/// the GUI to index: avoid all those filter processes forever hanging
/// off recoll.
extern void clearMimeHandlerCache();
/// Can this mime type be interned ?
extern bool canIntern(const std::string mimetype, RclConfig *cfg);
#endif /* _MIMEHANDLER_H_INCLUDED_ */