← Back to branch summary

~ubuntu-branches/ubuntu/trusty/digikam/trusty

« back to all changes in this revision

Viewing changes to core/utilities/advancedrename/common/parser.cpp

  • Committer: Package Import Robot
  • Author(s): Rohan Garg
  • Date: 2012-11-26 18:24:20 UTC
  • mfrom: (1.9.1) (3.1.23 experimental)
  • Revision ID: package-import@ubuntu.com-20121126182420-qoy6z0nx4ai0wzcl
Tags: 4:3.0.0~beta3-0ubuntu1
https://launchpad.net/bugs/890059
https://launchpad.net/bugs/1011211
https://launchpad.net/bugs/658047
* New upstream release
  - Add build-deps :  libhupnp-dev, libqtgstreamer-dev, libmagickcore-dev
* Merge from debian, remaining changes:
  - Make sure libqt4-opengl-dev, libgl1-mesa-dev and libglu1-mesa-dev only
    install on i386,amd64 and powerpc
  - Depend on libtiff-dev instead of libtiff4-dev
  - Drop digikam breaks/replaces kipi-plugins-common since we're past the
    LTS release now
  - digikam to recommend mplayerthumbs | ffmpegthumbs. We currently only
    have latter in the archives, even though former is also supposed to
    be part of kdemultimedia. (LP: #890059)
  - kipi-plugins to recommend www-browser rather than konqueror directly
    since 2.8 no direct usage of konqueror is present in the flickr
    plugin anymore (LP: #1011211)
  - Keep kubuntu_mysqld_executable_name.diff
  - Don't install libkipi translations
  - Keep deps on libcv-dev, libcvaux-dev
  - Keep split packaging of libraries
  - Replace icons from KDE 3 time in debian/xpm.d/*.xpm with the new
    versions (LP: #658047)
* Update debian/not-installed

Show diffs side-by-side

added added

removed removed

Lines of Context:
core/utilities/advancedrename/common/parser.cpp
6
6
 * Date        : 2009-08-11
7
7
 * Description : the main parser object for the AdvancedRename utility
8
8
 *
9
 
 * Copyright (C) 2009-2012 by Andi Clemens <andi dot clemens at googlemail dot com>
 
9
 * Copyright (C) 2009-2012 by Andi Clemens <andi dot clemens at gmail dot com>
10
10
 *
11
11
 * This program is free software; you can redistribute it
12
12
 * and/or modify it under the terms of the GNU General
52
52
namespace Digikam
53
53
{
54
54
 
55
 
class ParserPriv
 
55
class Parser::Private
56
56
{
57
57
public:
58
58
 
59
 
    ParserPriv()
 
59
    Private()
60
60
    {}
61
61
 
62
 
    OptionsList  options;
63
 
    ModifierList modifiers;
 
62
    RulesList  options;
 
63
    RulesList modifiers;
64
64
};
65
65
 
66
66
// --------------------------------------------------------
67
67
 
68
68
Parser::Parser()
69
 
    : d(new ParserPriv)
 
69
    : d(new Private)
70
70
{
71
71
    registerOption(new FilePropertiesOption());
72
72
    registerOption(new DirectoryNameOption());
103
103
 
104
104
void Parser::reset()
105
105
{
106
 
    foreach(Option* option, d->options)
 
106
    foreach(Rule* option, d->options)
107
107
    {
108
108
        option->reset();
109
109
    }
110
 
    foreach(Modifier* modifier, d->modifiers)
 
110
    foreach(Rule* modifier, d->modifiers)
111
111
    {
112
112
        modifier->reset();
113
113
    }
119
119
    return (!str.isEmpty() && !invalidString.exactMatch(str));
120
120
}
121
121
 
122
 
OptionsList Parser::options() const
 
122
RulesList Parser::options() const
123
123
{
124
124
    return d->options;
125
125
}
126
126
 
127
 
ModifierList Parser::modifiers() const
 
127
RulesList Parser::modifiers() const
128
128
{
129
129
    return d->modifiers;
130
130
}
131
131
 
132
 
void Parser::registerOption(Option* option)
 
132
void Parser::registerOption(Rule* option)
133
133
{
134
134
    if (!option || !option->isValid())
135
135
    {
139
139
    d->options.append(option);
140
140
}
141
141
 
142
 
void Parser::unregisterOption(Option* option)
 
142
void Parser::unregisterOption(Rule* option)
143
143
{
144
144
    if (!option)
145
145
    {
146
146
        return;
147
147
    }
148
148
 
149
 
    for (OptionsList::iterator it = d->options.begin();
 
149
    for (RulesList::iterator it = d->options.begin();
150
150
         it != d->options.end();)
151
151
    {
152
152
        if (*it == option)
161
161
    }
162
162
}
163
163
 
164
 
void Parser::registerModifier(Modifier* modifier)
 
164
void Parser::registerModifier(Rule* modifier)
165
165
{
166
166
    if (!modifier || !modifier->isValid())
167
167
    {
171
171
    d->modifiers.append(modifier);
172
172
}
173
173
 
174
 
void Parser::unregisterModifier(Modifier* modifier)
 
174
void Parser::unregisterModifier(Rule* modifier)
175
175
{
176
176
    if (!modifier)
177
177
    {
178
178
        return;
179
179
    }
180
180
 
181
 
    for (ModifierList::iterator it = d->modifiers.begin();
 
181
    for (RulesList::iterator it = d->modifiers.begin();
182
182
         it != d->modifiers.end();)
183
183
    {
184
184
        if (*it == modifier)
195
195
 
196
196
ParseResults Parser::results(ParseSettings& settings)
197
197
{
198
 
    parse(settings);
199
 
    return settings.results;
 
198
    ParseResults results;
 
199
 
 
200
    foreach(Rule* option, d->options)
 
201
    {
 
202
        ParseResults r = option->parse(settings);
 
203
        results.append(r);
 
204
    }
 
205
 
 
206
    foreach(Rule* modifier, d->modifiers)
 
207
    {
 
208
        ParseResults r = modifier->parse(settings);
 
209
        results.append(r);
 
210
    }
 
211
 
 
212
    return results;
200
213
}
201
214
 
202
215
ParseResults Parser::invalidModifiers(ParseSettings& settings)
216
229
 
217
230
    ParseResults results;
218
231
 
219
 
    foreach(Option* option, d->options)
 
232
    foreach(Rule* option, d->options)
220
233
    {
221
234
        ParseResults r = option->parse(settings);
222
235
        results.append(r);
233
246
    settings.results = results;
234
247
 
235
248
    // remove invalid modifiers from the new name
236
 
    foreach(const Modifier* mod, d->modifiers)
 
249
    foreach(const Rule* mod, d->modifiers)
237
250
    {
238
251
        newName.remove(mod->regExp());
239
252
    }
251
264
    return newName;
252
265
}
253
266
 
254
 
bool Parser::tokenAtPosition(TokenType type, ParseSettings& settings, int pos)
 
267
bool Parser::tokenAtPosition(ParseSettings& settings, int pos)
255
268
{
256
269
    int start;
257
270
    int length;
258
 
    return tokenAtPosition(type, settings, pos, start, length);
 
271
    return tokenAtPosition(settings, pos, start, length);
259
272
}
260
273
 
261
 
bool Parser::tokenAtPosition(TokenType type, ParseSettings& settings, int pos, int& start, int& length)
 
274
bool Parser::tokenAtPosition(ParseSettings& settings, int pos, int& start, int& length)
262
275
{
263
276
    bool found = false;
264
277
 
265
 
    ParseResults r;
266
 
 
267
 
    switch (type)
268
 
    {
269
 
        case OptionToken:
270
 
            settings.applyModifiers = false;
271
 
            r = results(settings);
272
 
            break;
273
 
 
274
 
        case OptionModifiersToken:
275
 
            settings.applyModifiers = true;
276
 
            r = results(settings);
277
 
            break;
278
 
 
279
 
        default:
280
 
            break;
281
 
    }
 
278
    ParseResults r = results(settings);
282
279
 
283
280
    ParseResults::ResultsKey key = r.keyAtApproximatePosition(pos);
284
281
    start  = key.first;
309
306
    ParseResults modifierResults;
310
307
 
311
308
    // modifierMap maps the actual modifier objects to the entries in the modifierResults structure
312
 
    QMap<ParseResults::ResultsKey, Modifier*> modifierMap;
 
309
    QMap<ParseResults::ResultsKey, Rule*> modifierMap;
313
310
 
314
 
    foreach(Modifier* modifier, d->modifiers)
 
311
    foreach(Rule* modifier, d->modifiers)
315
312
    {
316
313
        QRegExp regExp = modifier->regExp();
317
314
        int pos = 0;
348
345
            if (modifierResults.hasKeyAtPosition(pos))
349
346
            {
350
347
                ParseResults::ResultsKey mkey = modifierResults.keyAtPosition(pos);
351
 
                Modifier* mod                 = modifierMap[mkey];
 
348
                Rule* mod                     = modifierMap[mkey];
352
349
                QString modToken              = modifierResults.token(mkey);
353
350
 
354
351
                QString token                 = results.token(key);
370
367
                }
371
368
 
372
369
                // update result
373
 
                ParseResults::ResultsKey   kResult = key;
374
 
                ParseResults::ResultsValue vResult(token, modResult);
375
 
                results.addEntry(kResult, vResult);
 
370
                ParseResults::ResultsKey   resultKey = key;
 
371
                ParseResults::ResultsValue resultValue(token, modResult);
 
372
                results.addEntry(resultKey, resultValue);
376
373
 
377
374
                // update modifier map
378
 
                ParseResults::ResultsKey kModifier = key;
379
 
                kModifier.second += diff;
380
 
                ParseResults::ResultsValue vModifier(modToken, modResult);
 
375
                ParseResults::ResultsKey modifierKey = key;
 
376
                modifierKey.second += diff;
 
377
                ParseResults::ResultsValue modifierValue(modToken, modResult);
381
378
 
382
 
                appliedModifiers.deleteEntry(kModifier);
383
 
                kModifier.second += modToken.count();
384
 
                appliedModifiers.addEntry(kModifier, vModifier);
 
379
                appliedModifiers.deleteEntry(modifierKey);
 
380
                modifierKey.second += modToken.count();
 
381
                appliedModifiers.addEntry(modifierKey, modifierValue);
385
382
 
386
383
                // set position to the next possible token
387
384
                pos  += mkey.second;