← Back to branch summary

~ubuntu-branches/ubuntu/quantal/psi/quantal

« back to all changes in this revision

Viewing changes to src/eventdb.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Jan Niehusmann
  • Date: 2006-01-20 00:20:36 UTC
  • mfrom: (1.2.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20060120002036-7nw6yo6totip0ee5
Tags: 0.10-2
http://bugs.debian.org/327748
http://bugs.debian.org/204416
* Added upstream changelog (Closes: Bug#327748)
* Mention --no-gpg and --no-gpg-agent in manpage (Closes: Bug#204416)

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/eventdb.cpp
293
293
        int eventId;
294
294
        QString findStr;
295
295
        PsiEvent *event;
 
296
 
 
297
        typedef enum Type {
 
298
                Type_getLatest = 0,
 
299
                Type_getOldest,
 
300
                Type_get,
 
301
                Type_append,
 
302
                Type_find
 
303
        };
296
304
};
297
305
 
298
306
class EDBFlatFile::Private
323
331
{
324
332
        item_file_req *r = new item_file_req;
325
333
        r->j = j;
326
 
        r->type = 0;
 
334
        r->type = item_file_req::Type_getLatest;
327
335
        r->len = len < 1 ? 1: len;
328
336
        r->id = genUniqueId();
329
337
        d->rlist.append(r);
336
344
{
337
345
        item_file_req *r = new item_file_req;
338
346
        r->j = j;
339
 
        r->type = 1;
 
347
        r->type = item_file_req::Type_getOldest;
340
348
        r->len = len < 1 ? 1: len;
341
349
        r->id = genUniqueId();
342
350
        d->rlist.append(r);
349
357
{
350
358
        item_file_req *r = new item_file_req;
351
359
        r->j = j;
352
 
        r->type = 2;
 
360
        r->type = item_file_req::Type_get;
353
361
        r->len = len < 1 ? 1: len;
354
362
        r->dir = direction;
355
363
        r->eventId = id.toInt();
364
372
{
365
373
        item_file_req *r = new item_file_req;
366
374
        r->j = j;
367
 
        r->type = 4;
 
375
        r->type = item_file_req::Type_find;
368
376
        r->len = 1;
369
377
        r->dir = direction;
370
378
        r->findStr = str;
380
388
{
381
389
        item_file_req *r = new item_file_req;
382
390
        r->j = j;
383
 
        r->type = 3;
384
 
        if(e->type() == PsiEvent::Message)
385
 
                r->event = new MessageEvent(*(MessageEvent *)e);
386
 
        else if(e->type() == PsiEvent::Auth)
387
 
                r->event = new AuthEvent(*(AuthEvent *)e);
 
391
        r->type = item_file_req::Type_append;
 
392
        r->event = e->copy();
 
393
        if ( !r->event ) {
 
394
                qWarning("EDBFlatFile::append(): Attempted to append incompatible type.");
 
395
                delete r;
 
396
                return 0;
 
397
        }
388
398
        r->id = genUniqueId();
389
399
        d->rlist.append(r);
390
400
 
423
433
 
424
434
        File *f = ensureFile(r->j);
425
435
        int type = r->type;
426
 
        if(type >= 0 && type <= 2) {
 
436
        if(type >= item_file_req::Type_getLatest && type <= item_file_req::Type_get) {
427
437
                int id, direction;
428
438
 
429
 
                if(type == 0) {
 
439
                if(type == item_file_req::Type_getLatest) {
430
440
                        direction = Backward;
431
441
                        id = f->total()-1;
432
442
                }
433
 
                else if(type == 1) {
 
443
                else if(type == item_file_req::Type_getOldest) {
434
444
                        direction = Forward;
435
445
                        id = 0;
436
446
                }
437
 
                else {
 
447
                else if(type == item_file_req::Type_get) {
438
448
                        direction = r->dir;
439
449
                        id = r->eventId;
440
450
                }
 
451
                else {
 
452
                        qWarning("EDBFlatFile::performRequests(): Invalid type.");
 
453
                        return;
 
454
                }
441
455
 
442
456
                int len;
443
457
                if(direction == Forward) {
474
488
                }
475
489
                resultReady(r->id, result);
476
490
        }
477
 
        else if(type == 3) {
 
491
        else if(type == item_file_req::Type_append) {
478
492
                writeFinished(r->id, f->append(r->event));
479
493
                delete r->event;
480
494
        }
481
 
        else if(type == 4) {
 
495
        else if(type == item_file_req::Type_find) {
482
496
                int id = r->eventId;
483
497
                EDBResult *result = new EDBResult;
484
498
                result->setAutoDelete(true);
531
545
        Private() {}
532
546
 
533
547
        QValueVector<int> index;
 
548
        bool indexed;
534
549
};
535
550
 
536
551
EDBFlatFile::File::File(const Jid &_j)
537
552
{
538
553
        d = new Private;
 
554
        d->indexed = false;
539
555
 
540
556
        j = _j;
541
557
        valid = false;
547
563
        fname = getHistoryDir() + "/" + qstrlower(jidEncode(s)) + ".history";
548
564
        f.setName(fname);
549
565
        valid = f.open(IO_ReadWrite);
550
 
        if(valid) {
 
566
 
 
567
        touch();
 
568
}
 
569
 
 
570
EDBFlatFile::File::~File()
 
571
{
 
572
        if(valid)
 
573
                f.close();
 
574
        //printf("[EDB closing -- %s]\n", j.full().latin1());
 
575
 
 
576
        delete d;
 
577
}
 
578
 
 
579
void EDBFlatFile::File::ensureIndex()
 
580
{
 
581
        if ( valid && !d->indexed ) {
 
582
                f.reset(); // go to beginning
 
583
                d->index.clear();
 
584
 
551
585
                //printf(" file: %s\n", fname.latin1());
552
586
                // build index
553
587
                while(1) {
570
604
                        d->index.resize(oldsize+1);
571
605
                        d->index[oldsize] = at;
572
606
                }
 
607
 
 
608
                d->indexed = true;
573
609
        }
574
610
        else {
575
611
                //printf(" file: can't open\n");
576
612
        }
577
613
 
578
614
        //printf(" messages: %d\n\n", d->index.size());
579
 
        touch();
580
 
}
581
 
 
582
 
EDBFlatFile::File::~File()
583
 
{
584
 
        if(valid)
585
 
                f.close();
586
 
        //printf("[EDB closing -- %s]\n", j.full().latin1());
587
 
 
588
 
        delete d;
589
615
}
590
616
 
591
617
int EDBFlatFile::File::total() const
592
618
{
 
619
        ((EDBFlatFile::File *)this)->ensureIndex();
593
620
        return d->index.size();
594
621
}
595
622
 
610
637
        if(!valid)
611
638
                return 0;
612
639
 
 
640
        ensureIndex();
613
641
        if(id < 0 || id > (int)d->index.size())
614
642
                return 0;
615
643
 
645
673
        t.unsetDevice();
646
674
        f.flush();
647
675
 
648
 
        int oldsize = d->index.size();
649
 
        d->index.resize(oldsize+1);
650
 
        d->index[oldsize] = at;
 
676
        if ( d->indexed ) {
 
677
                int oldsize = d->index.size();
 
678
                d->index.resize(oldsize+1);
 
679
                d->index[oldsize] = at;
 
680
        }
651
681
 
652
682
        return true;
653
683
}