← Back to branch summary

~ubuntu-branches/ubuntu/wily/torrus/wily-proposed

« back to all changes in this revision

Viewing changes to perllib/Torrus/DB.pm

  • Committer: Package Import Robot
  • Author(s): Marc Haber
  • Date: 2011-11-06 17:15:40 UTC
  • mto: (6.1.1 experimental) (1.3.1)
  • mto: This revision was merged to the branch mainline in revision 7.
  • Revision ID: package-import@ubuntu.com-20111106171540-myc0auwqqio8bmhl
Tags: upstream-2.01
Import upstream version 2.01

Show diffs side-by-side

added added

removed removed

Lines of Context:
perllib/Torrus/DB.pm
14
14
#  along with this program; if not, write to the Free Software
15
15
#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
16
16
 
17
 
# $Id: DB.pm,v 1.9 2008/11/23 20:52:00 ssinyagin Exp $
 
17
# $Id$
18
18
# Stanislav Sinyagin <ssinyagin@yahoo.com>
19
19
 
20
20
package Torrus::DB;
172
172
        $self->trunc();
173
173
    }
174
174
 
 
175
    if( $options{'-Delayed'} )
 
176
    {
 
177
        $self->{'delay_list_commit'} = 1;
 
178
    }
 
179
 
175
180
    return $self;
176
181
}
177
182
 
313
318
}
314
319
 
315
320
 
 
321
sub delay
 
322
{
 
323
    my $self = shift;
 
324
    $self->{'delay_list_commit'} = 1;
 
325
}
 
326
 
 
327
    
 
328
 
316
329
sub trunc
317
330
{
318
331
    my $self = shift;
418
431
}
419
432
 
420
433
 
 
434
sub c_close
 
435
{
 
436
    my $self = shift;
 
437
    my $cursor = shift;
 
438
    $cursor->c_close();
 
439
}
 
440
 
421
441
 
422
442
# Btree best match. We assume that the searchKey is longer or equal
423
443
# than the matched key in the database.
569
589
 
570
590
# Comma-separated list manipulation
571
591
 
 
592
sub _populateListCache
 
593
{
 
594
    my $self = shift;
 
595
    my $key = shift;
 
596
 
 
597
    if( not exists( $self->{'listcache'}{$key} ) )
 
598
    {
 
599
        my $ref = {};        
 
600
        my $values = $self->get($key);
 
601
        if( defined( $values ) )
 
602
        {
 
603
            foreach my $val (split(/,/o, $values))
 
604
            {
 
605
                $ref->{$val} = 1;
 
606
            }
 
607
        }
 
608
        $self->{'listcache'}{$key} = $ref;
 
609
    }
 
610
}
 
611
 
 
612
 
 
613
sub _storeListCache
 
614
{
 
615
    my $self = shift;
 
616
    my $key = shift;
 
617
 
 
618
    if( not $self->{'delay_list_commit'} )
 
619
    {
 
620
        $self->put($key, join(',', keys %{$self->{'listcache'}{$key}}));
 
621
    }
 
622
}
 
623
 
 
624
    
572
625
sub addToList
573
626
{
574
627
    my $self = shift;
575
628
    my $key = shift;
576
 
    my $newname = shift;
577
 
    my $must_unique = shift;
578
 
 
579
 
    my $prefix;
580
 
    my $list;
581
 
    if( exists( $self->{'listcache'}{$key} ) )
582
 
    {
583
 
        $list = $self->{'listcache'}{$key};
584
 
    }
585
 
    else
586
 
    {
587
 
        $list = $self->get($key);
588
 
        $self->{'listcache'}{$key} = $list;
589
 
    }
590
 
 
591
 
    if( defined($list) and length($list) > 0 )
592
 
    {
593
 
        $prefix = ',';
594
 
        if( grep {$newname eq $_} split(',', $list) )
595
 
        {
596
 
            # This name is already in the list
597
 
            return $must_unique ? 0:1;
598
 
        }
599
 
    }
600
 
    else
601
 
    {
602
 
        $prefix = '';
603
 
    }
604
 
    $list .= $prefix.$newname;
605
 
 
606
 
    $self->{'listcache'}{$key} = $list;
607
 
    $self->put($key, $list);
 
629
    my $newval = shift;
 
630
 
 
631
    $self->_populateListCache($key);
 
632
    
 
633
    $self->{'listcache'}{$key}{$newval} = 1;
 
634
    
 
635
    $self->_storeListCache($key);
608
636
}
609
637
 
610
638
 
614
642
    my $key = shift;
615
643
    my $name = shift;
616
644
 
617
 
    my $list;
618
 
    if( exists( $self->{'listcache'}{$key} ) )
619
 
    {
620
 
        $list = $self->{'listcache'}{$key};
621
 
    }
622
 
    else
623
 
    {
624
 
        $list = $self->get($key);
625
 
        $self->{'listcache'}{$key} = $list;
626
 
    }
627
 
 
628
 
    if( defined($list) and length($list) > 0 )
629
 
    {
630
 
        if( grep {$name eq $_} split(',', $list) )
631
 
        {
632
 
            return 1;
633
 
        }
634
 
    }
635
 
    return 0;
 
645
    $self->_populateListCache($key);
 
646
    return $self->{'listcache'}{$key}{$name};
636
647
}
637
648
 
 
649
 
638
650
sub delFromList
639
651
{
640
652
    my $self = shift;
641
653
    my $key = shift;
642
654
    my $name = shift;
643
655
 
644
 
    my $list;
645
 
    if( exists( $self->{'listcache'}{$key} ) )
646
 
    {
647
 
        $list = $self->{'listcache'}{$key};
648
 
    }
649
 
    else
650
 
    {
651
 
        $list = $self->get($key);
652
 
        $self->{'listcache'}{$key} = $list;
653
 
    }
654
 
 
655
 
    if( defined($list) and length($list) > 0 )
656
 
    {
657
 
        my @array = split(',', $list);
658
 
        my $found = 0;
659
 
        foreach my $index (0 .. $#array)
660
 
        {
661
 
            if( $array[$index] eq $name )
662
 
            {
663
 
                splice( @array, $index, 1 );
664
 
                $found = 1;
665
 
                last;
666
 
            }
667
 
        }
668
 
        if( $found )
669
 
        {
670
 
            if( scalar(@array) > 0 )
671
 
            {
672
 
                $list = join(',', @array);
673
 
                $self->{'listcache'}{$key} = $list;
674
 
                $self->put($key, $list);
675
 
            }
676
 
            else
677
 
            {
678
 
                $self->del($key);
679
 
                delete $self->{'listcache'}{$key};
680
 
            }
681
 
            return 1;
682
 
        }
683
 
        else
684
 
        {
685
 
            return 0;
686
 
        }
687
 
    }
688
 
    return 0;
689
 
}
690
 
 
691
 
 
 
656
    $self->_populateListCache($key);
 
657
    if( $self->{'listcache'}{$key}{$name} )
 
658
    {
 
659
        delete $self->{'listcache'}{$key}{$name};
 
660
    }
 
661
    
 
662
    $self->_storeListCache($key);
 
663
}
 
664
 
 
665
 
 
666
sub getListItems
 
667
{
 
668
    my $self = shift;
 
669
    my $key = shift;
 
670
 
 
671
    $self->_populateListCache($key);
 
672
    return keys %{$self->{'listcache'}{$key}};
 
673
}
 
674
 
 
675
    
692
676
 
693
677
sub deleteList
694
678
{
700
684
}
701
685
 
702
686
 
 
687
sub commit
 
688
{
 
689
    my $self = shift;
 
690
    
 
691
    if( $self->{'delay_list_commit'} and
 
692
        defined( $self->{'listcache'} ) )
 
693
    {
 
694
        while( my($key, $list) = each %{$self->{'listcache'}} )
 
695
        {
 
696
            $self->put($key, join(',', keys %{$list}));
 
697
        }
 
698
    }
 
699
}
 
700
            
 
701
 
 
702
 
703
703
1;
704
704
 
705
705