← Back to branch summary

~ubuntu-branches/ubuntu/precise/mp3diags/precise

« back to all changes in this revision

Viewing changes to src/Mp3TransformThread.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Alessio Treglia
  • Date: 2009-09-05 10:48:57 UTC
  • mfrom: (1.1.8 upstream)
  • Revision ID: james.westby@ubuntu.com-20090905104857-48aob98yoibqarh0
Tags: 0.99.05.033-0ubuntu1
https://launchpad.net/bugs/423812
New upstream release (FFe granted LP: #423812).

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/Mp3TransformThread.cpp
104
104
        CB_ASSERT(m_strOrigName.empty());
105
105
        m_strOrigName = strOrigName;
106
106
        char a [20];
 
107
 
107
108
        for (int i = 1; i < 1000; ++i)
108
109
        {
109
110
            sprintf(a, ".QQREN%03dREN", i);
116
117
        }
117
118
 
118
119
        CB_ASSERT (0 == a[0]); // not really correct to assert, but quite likely
119
 
        renameFile(strOrigName, m_strChangedName); // may throw but doesn't seem to make sense to catch
 
120
 
 
121
        try
 
122
        {
 
123
            renameFile(strOrigName, m_strChangedName);
 
124
        }
 
125
        catch (const CannotDeleteFile&)
 
126
        {
 
127
            revert();
 
128
            throw;
 
129
        }
 
130
        catch (const CannotRenameFile&)
 
131
        {
 
132
            revert();
 
133
            throw CannotDeleteFile();
 
134
        }
120
135
    }
121
136
 
122
137
    ~FileEraser()
123
138
    {
124
139
        if (m_strOrigName.empty() || m_strChangedName.empty()) { return; }
125
140
 
126
 
        renameFile(m_strChangedName, m_strOrigName); // may throw but doesn't seem to make sense to catch
 
141
        try
 
142
        {
 
143
            renameFile(m_strChangedName, m_strOrigName);
 
144
        }
 
145
        catch (...)
 
146
        { //ttt0 perhaps do something
 
147
        }
127
148
    }
128
149
 
129
150
    void finalize()
134
155
        m_strOrigName.clear();
135
156
        m_strChangedName.clear();
136
157
    }
 
158
 
 
159
private:
 
160
    void revert() // to be called on exceptions; assumes that the old file got copied but couldn't be deleted, so now the copy must be deleted
 
161
    {
 
162
        CB_ASSERT (!m_strChangedName.empty());
 
163
        try
 
164
        {
 
165
            deleteFile(m_strChangedName);
 
166
        }
 
167
        catch (const CannotDeleteFile&)
 
168
        { // nothing
 
169
        }
 
170
        m_strChangedName.clear();
 
171
    }
137
172
};
138
173
 
139
174
 
256
291
            string strNewOrigName;  // new name for the orig file; if this is empty, the original file wasn't changed; if it's "*", it was erased; if it's something else, it was renamed;
257
292
            string strProcName;     // name for the proc file; if this is empty, a proc file doesn't exist; if it's something else, it's the file name;
258
293
 
 
294
            bool bErrorInTransform (false);
 
295
 
259
296
            FileEraser fileEraser;
260
297
 
261
 
            //bool bChanged (true);
262
 
            if (pNewHndl.get() == pOrigHndl)
263
 
            { // nothing changed
264
 
                pNewHndl.release();
265
 
                switch (m_transfConfig.getUnprocOrigAction())
266
 
                {
267
 
                case TransfConfig::ORIG_DONT_CHANGE: break;
268
 
                case TransfConfig::ORIG_ERASE: { strNewOrigName = "*"; fileEraser.erase(strOrigName); } break; //ttt2 try ...
269
 
                case TransfConfig::ORIG_MOVE: { m_transfConfig.getUnprocOrigName(strOrigName, strNewOrigName); renameFile(strOrigName, strNewOrigName); } break;
270
 
                default: CB_ASSERT (false);
271
 
                }
272
 
            }
273
 
            else
274
 
            { // at least a processed file exists
275
 
                CB_ASSERT (!strTempName.empty());
276
 
 
277
 
                // first we have to handle the original file;
278
 
 
279
 
                switch (m_transfConfig.getProcOrigAction())
280
 
                {
281
 
                case TransfConfig::ORIG_DONT_CHANGE: break;
282
 
                case TransfConfig::ORIG_ERASE: { strNewOrigName = "*"; fileEraser.erase(strOrigName); } break; //ttt2 try ...
283
 
                case TransfConfig::ORIG_MOVE: { m_transfConfig.getProcOrigName(strOrigName, strNewOrigName); renameFile(strOrigName, strNewOrigName); } break;
284
 
                case TransfConfig::ORIG_MOVE_OR_ERASE:
285
 
                    {
286
 
                        m_transfConfig.getProcOrigName(strOrigName, strNewOrigName);
287
 
                        if (fileExists(strNewOrigName))
288
 
                        {
289
 
                            strNewOrigName = "*";
290
 
                            fileEraser.erase(strOrigName);
291
 
                        }
292
 
                        else
293
 
                        {
294
 
                            renameFile(strOrigName, strNewOrigName);
295
 
                        }
296
 
                    }
297
 
                    break;
298
 
                default: CB_ASSERT (false);
299
 
                }
300
 
 
301
 
                // the last processed file exists in the "temp" folder, its name is in strTempName, and we have to see what to do with it (erase, rename, or copy);
302
 
                switch (m_transfConfig.getProcessedAction())
303
 
                {
304
 
                case TransfConfig::TRANSF_DONT_CREATE: deleteFile(strTempName); break;
305
 
                case TransfConfig::TRANSF_CREATE:
306
 
                    {
307
 
                        m_transfConfig.getProcessedName(strOrigName, strProcName);
308
 
                        switch (m_transfConfig.getTempAction())
309
 
                        {
310
 
                        case TransfConfig::TRANSF_DONT_CREATE: renameFile(strTempName, strProcName); break;
311
 
                        case TransfConfig::TRANSF_CREATE: copyFile(strTempName, strProcName); break;
312
 
                        default: CB_ASSERT (false);
313
 
                        }
314
 
                    }
315
 
                    break;
316
 
 
317
 
                default: CB_ASSERT (false);
318
 
                }
319
 
            }
320
 
 
321
 
            fileEraser.finalize();
 
298
            try
 
299
            {
 
300
                //bool bChanged (true);
 
301
                if (pNewHndl.get() == pOrigHndl)
 
302
                { // nothing changed
 
303
                    pNewHndl.release();
 
304
                    switch (m_transfConfig.getUnprocOrigAction())
 
305
                    {
 
306
                    case TransfConfig::ORIG_DONT_CHANGE: break;
 
307
                    case TransfConfig::ORIG_ERASE: { strNewOrigName = "*"; fileEraser.erase(strOrigName); } break; //ttt2 try ...
 
308
                    case TransfConfig::ORIG_MOVE: { m_transfConfig.getUnprocOrigName(strOrigName, strNewOrigName); renameFile(strOrigName, strNewOrigName); } break;
 
309
                    default: CB_ASSERT (false);
 
310
                    }
 
311
                }
 
312
                else
 
313
                { // at least a processed file exists
 
314
                    CB_ASSERT (!strTempName.empty());
 
315
 
 
316
                    // first we have to handle the original file;
 
317
 
 
318
                    switch (m_transfConfig.getProcOrigAction())
 
319
                    {
 
320
                    case TransfConfig::ORIG_DONT_CHANGE: break;
 
321
                    case TransfConfig::ORIG_ERASE: { strNewOrigName = "*"; fileEraser.erase(strOrigName); } break; //ttt2 try ...
 
322
                    case TransfConfig::ORIG_MOVE: { m_transfConfig.getProcOrigName(strOrigName, strNewOrigName); renameFile(strOrigName, strNewOrigName); } break;
 
323
                    case TransfConfig::ORIG_MOVE_OR_ERASE:
 
324
                        {
 
325
                            m_transfConfig.getProcOrigName(strOrigName, strNewOrigName);
 
326
                            if (fileExists(strNewOrigName))
 
327
                            {
 
328
                                strNewOrigName = "*";
 
329
                                fileEraser.erase(strOrigName);
 
330
                            }
 
331
                            else
 
332
                            {
 
333
                                renameFile(strOrigName, strNewOrigName);
 
334
                            }
 
335
                        }
 
336
                        break;
 
337
                    default: CB_ASSERT (false);
 
338
                    }
 
339
 
 
340
                    // the last processed file exists in the "temp" folder, its name is in strTempName, and we have to see what to do with it (erase, rename, or copy);
 
341
                    switch (m_transfConfig.getProcessedAction())
 
342
                    {
 
343
                    case TransfConfig::TRANSF_DONT_CREATE: deleteFile(strTempName); break;
 
344
                    case TransfConfig::TRANSF_CREATE:
 
345
                        {
 
346
                            m_transfConfig.getProcessedName(strOrigName, strProcName);
 
347
                            switch (m_transfConfig.getTempAction())
 
348
                            {
 
349
                            case TransfConfig::TRANSF_DONT_CREATE: renameFile(strTempName, strProcName); break;
 
350
                            case TransfConfig::TRANSF_CREATE: copyFile(strTempName, strProcName); break;
 
351
                            default: CB_ASSERT (false);
 
352
                            }
 
353
                        }
 
354
                        break;
 
355
 
 
356
                    default: CB_ASSERT (false);
 
357
                    }
 
358
                }
 
359
 
 
360
                fileEraser.finalize();
 
361
            }
 
362
            catch (const CannotDeleteFile&)
 
363
            {
 
364
                bErrorInTransform = true;
 
365
            }
 
366
            catch (const CannotRenameFile&) //ttt1 perhaps also NameNotFound, AlreadyExists, ...
 
367
            {
 
368
                bErrorInTransform = true;
 
369
            }
 
370
            catch (const CannotCopyFile&) //ttt1 perhaps also NameNotFound, AlreadyExists, ...
 
371
            {
 
372
                CB_ASSERT(false);
 
373
                //bErrorInTransform = true;
 
374
            }
 
375
 
 
376
            if (bErrorInTransform)
 
377
            {
 
378
                if (!strProcName.empty())
 
379
                {
 
380
                    try
 
381
                    {
 
382
                        deleteFile(strProcName);
 
383
                    }
 
384
                    catch (...)
 
385
                    { //ttt0 not sure what to do
 
386
                    }
 
387
                }
 
388
                m_strErrorFile = strOrigName;
 
389
                m_bWriteError = false;
 
390
                return false;
 
391
            }
 
392
            //ttt1 perhaps do something similar to strNewOrigName
 
393
            //ttt1 review the whole thing
322
394
 
323
395
            if (!strNewOrigName.empty())
324
396
            {
345
417
    }
346
418
    catch (...)
347
419
    {
 
420
        qDebug("Caught unknown excption in Mp3TransformThread::transform()");
 
421
        traceToFile("Caught unknown excption in Mp3TransformThread::transform()", 0);
348
422
        throw; // !!! needed to restore "erased" files when errors occur, because when an exception is thrown the destructors only get called if that exception is caught; so catching and rethrowing is not a "no-op"
349
423
    }
350
424
 
389
463
        }
390
464
        else
391
465
        {
392
 
            QMessageBox::critical(pParent, "Error", "There was an error reading from the following file:\n\n" + toNativeSeparators(convStr(strErrorFile)) + "\n\nProbably the file was deleted or modified since the last scan, in which case you should reload / rescan your collection.\n\nProcessing aborted.");
 
466
            QMessageBox::critical(pParent, "Error", "There was an error processing the following file:\n\n" + toNativeSeparators(convStr(strErrorFile)) + "\n\nProbably the file was deleted or modified since the last scan, in which case you should reload / rescan your collection. Or it may be used by another program; if that's the case, you should stop the other program first.\n\nProcessing aborted.");
393
467
        }
394
468
    }
395
469
 
396
470
    return strErrorFile.empty();
397
471
}
398
472
 
399
 
//ttt0 message that shift works on selected files
 
473
 
400
474