← Back to branch summary

~ubuntu-branches/debian/squeeze/erlang/squeeze

« back to all changes in this revision

Viewing changes to lib/tv/src/tv_db.erl

  • Committer: Bazaar Package Importer
  • Author(s): Erlang Packagers, Sergei Golovan
  • Date: 2006-12-03 17:07:44 UTC
  • mfrom: (2.1.11 feisty)
  • Revision ID: james.westby@ubuntu.com-20061203170744-rghjwupacqlzs6kv
Tags: 1:11.b.2-4
[ Sergei Golovan ]
Fixed erlang-base and erlang-base-hipe prerm scripts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/tv/src/tv_db.erl
273
273
    DbList    = dblist2list(DbData#db_data.db),
274
274
    ListAsStr = ProcVars#process_variables.lists_as_strings,
275
275
    case catch tv_db_search:get_input_and_search(DbList, RegExp, ListAsStr) of
276
 
        {'EXIT', Reason} ->
 
276
        {'EXIT', _Reason} ->
277
277
            tv_db_search:reset_window(true),
278
278
            [];
279
279
        List ->
325
325
                case catch tv_db_search:update_search(SearchWinCreated, 
326
326
                                                      NewDbList, RegExp,
327
327
                                                      ListAsStr) of
328
 
                    {'EXIT', Reason} ->
 
328
                    {'EXIT', _Reason} ->
329
329
                        tv_db_search:reset_window(true),
330
330
                        [];
331
331
                    List ->
345
345
sort_db_list(DbList, Sort, Sort, Rev, Rev, KeyNo, KeyNo) ->
346
346
       % Already sorted!
347
347
    DbList;
348
 
sort_db_list(DbList, false, OldSort, Rev, OldRev, KeyNo, OldKeyNo) ->
 
348
sort_db_list(DbList, false, _OldSort, _Rev, _OldRev, _KeyNo, _OldKeyNo) ->
349
349
       % No sorting, i.e., the old list order suffices!
350
350
    DbList;
351
 
sort_db_list(DbList, Sort, OldSort, Rev, OldRev, KeyNo, OldKeyNo) ->
 
351
sort_db_list(DbList, _Sort, _OldSort, Rev, _OldRev, KeyNo, _OldKeyNo) ->
352
352
    tv_db_sort:mergesort(KeyNo, DbList, Rev).
353
353
    
354
354
 
405
405
 
406
406
 
407
407
 
408
 
get_requested_row_data(undefined, DbList) ->
 
408
get_requested_row_data(undefined, _DbList) ->
409
409
    [];
410
 
get_requested_row_data(RowNo, []) ->
 
410
get_requested_row_data(_RowNo, []) ->
411
411
    [];
412
412
get_requested_row_data(RowNo, DbList) ->
413
413
    case catch lists:nth(RowNo, DbList) of
414
 
        {'EXIT', Reason} ->
 
414
        {'EXIT', _Reason} ->
415
415
            [];
416
416
        RowData ->
417
417
            [RowData]
435
435
update_db(NewList, ListOfKeys, ProcVars) ->
436
436
    DbData = ProcVars#process_variables.db_data,
437
437
    #db_data{db            = OldDbList,
438
 
             db_size       = DbSize,
439
438
             max_elem_size = MaxElemSize,
440
439
             deleted       = DelList,
441
440
             ets_type      = EtsType,
480
479
    #process_variables{db_data     = DbData,
481
480
                       etsread_pid = EtsreadPid}  = ProcVars,
482
481
    
483
 
    #db_data{db            = DbList,
484
 
             db_size       = DbSize,
485
 
             key_no        = KeyNo} = DbData,
 
482
    #db_data{key_no        = KeyNo} = DbData,
486
483
 
487
484
       %% Don't update if there are no changes!
488
485
    case OldObj of
555
552
    #process_variables{db_data = DbData}  = ProcVars,
556
553
    
557
554
    #db_data{db            = DbList,
558
 
             db_size       = DbSize,
559
555
             ets_type      = EtsType,     %% 'bag', 'set', 'ordered_set' or 
560
556
                                          %% 'duplicate_bag'
561
557
             max_elem_size = MaxElemSize,
579
575
                    OldKey ->
580
576
                        fun({Data,Color}, {Replaced,AccDb}) when element(KeyNo,Data) /= Key ->
581
577
                                {Replaced, [{Data,Color} | AccDb]};
582
 
                           ({Data,Color}, {Replaced,AccDb}) when Replaced == false,
 
578
                           ({_Data,Color}, {Replaced,AccDb}) when Replaced == false,
583
579
                                                                 OldColor == ?BLACK,
584
580
                                                                 Color == ?BLACK ->
585
581
                                {true, [{Obj,?RED1} | AccDb]};
586
 
                           ({Data,Color}, {Replaced,AccDb}) when Replaced == false,
 
582
                           ({_Data,Color}, {Replaced,AccDb}) when Replaced == false,
587
583
                                                                 OldColor /= ?BLACK,
588
584
                                                                 Color /= ?BLACK ->
589
585
                                {true, [{Obj,?GREEN1} | AccDb]};
590
 
                           ({Data,Color}, {Replaced,AccDb}) ->
 
586
                           ({_Data,_Color}, {Replaced,AccDb}) ->
591
587
                                {Replaced, AccDb}
592
588
                        end;
593
 
                    NewKey ->
 
589
                    _NewKey ->
594
590
                        fun({Data,Color}, {Replaced,AccDb}) ->
595
591
                                ElemKey = element(KeyNo,Data),
596
592
                                case ElemKey of
615
611
            bag ->
616
612
                case Key of
617
613
                    OldKey ->
618
 
                        fun({Data,Color}, {Replaced,AccDb}) when Data == Obj ->
 
614
                        fun({Data,_Color}, {Replaced,AccDb}) when Data == Obj ->
619
615
                                {Replaced, AccDb};
620
616
                           ({Data,Color}, {Replaced,AccDb}) when Data /= OldObj ->
621
617
                                {Replaced, [{Data,Color} | AccDb]};
622
618
                              %% Clauses when Data == OldObj.
623
 
                           ({Data,Color}, {Replaced,AccDb}) when Replaced == false,
 
619
                           ({_Data,Color}, {Replaced,AccDb}) when Replaced == false,
624
620
                                                                 OldColor == ?BLACK,
625
621
                                                                 Color == ?BLACK ->
626
622
                                {true, [{Obj,?RED1} | AccDb]};
627
 
                           ({Data,Color}, {Replaced,AccDb}) when Replaced == false,
 
623
                           ({_Data,Color}, {Replaced,AccDb}) when Replaced == false,
628
624
                                                                 OldColor /= ?BLACK,
629
625
                                                                 Color /= ?BLACK ->
630
626
                                {true, [{Obj,Color} | AccDb]};
631
 
                           ({Data,Color}, {Replaced,AccDb}) ->
 
627
                           ({_Data,_Color}, {Replaced,AccDb}) ->
632
628
                                {Replaced, AccDb}
633
629
                        end;
634
 
                    NewKey ->
 
630
                    _NewKey ->
635
631
                        fun({Data,Color}, {Replaced,AccDb}) when Data == OldObj,
636
632
                                                                 Replaced == false,
637
633
                                                                 OldColor == ?BLACK,
642
638
                                                                 OldColor /= ?BLACK,
643
639
                                                                 Color /= ?BLACK ->
644
640
                                {true, [{Obj,?GREEN1} | AccDb]};
645
 
                           ({Data,Color}, {Replaced,AccDb}) when Data == OldObj ->
 
641
                           ({Data,_Color}, {Replaced,AccDb}) when Data == OldObj ->
646
642
                                {Replaced, AccDb};
647
 
                           ({Data,Color}, {Replaced,AccDb}) when Data == Obj ->
 
643
                           ({Data,_Color}, {Replaced,AccDb}) when Data == Obj ->
648
644
                                {Replaced, AccDb};
649
645
                           ({Data,Color}, {Replaced,AccDb}) ->
650
646
                                {Replaced, [{Data,Color} | AccDb]}
660
656
                                {Replaced, [{Data,Color} | AccDb]};
661
657
                           ({Data,Color}, {Replaced,AccDb}) when Data /= OldObj ->
662
658
                                {Replaced, [{Data,Color} | AccDb]};
663
 
                           ({Data,Color}, {Replaced,AccDb}) when Replaced == false,
 
659
                           ({_Data,Color}, {Replaced,AccDb}) when Replaced == false,
664
660
                                                                 OldColor == ?BLACK,
665
661
                                                                 Color == ?BLACK ->
666
662
                                {true, [{Obj,?RED1} | AccDb]};
667
 
                           ({Data,Color}, {Replaced,AccDb}) when Replaced == false,
 
663
                           ({_Data,Color}, {Replaced,AccDb}) when Replaced == false,
668
664
                                                                 OldColor /= ?BLACK,
669
665
                                                                 Color /= ?BLACK ->
670
666
                                {true, [{Obj,Color} | AccDb]};
671
667
                           ({Data,Color}, {Replaced,AccDb}) ->
672
668
                                {Replaced, [{Data,Color} | AccDb]}
673
669
                        end;
674
 
                    NewKey ->
 
670
                    _NewKey ->
675
671
                        fun({Data,Color}, {Replaced,AccDb}) when Data == OldObj,
676
672
                                                                 Replaced == false,
677
673
                                                                 OldColor == ?BLACK,
746
742
 
747
743
 
748
744
 
749
 
delete_object(Obj, ?BLACK, _ObjNo, ProcVars) ->
 
745
delete_object(_Obj, ?BLACK, _ObjNo, ProcVars) ->
750
746
       %% Don't delete already deleted objects!!!
751
747
    {false, ProcVars};
752
748
delete_object(undefined, undefined, _ObjNo, ProcVars) ->
756
752
                       etsread_pid = EtsreadPid}  = ProcVars,
757
753
    
758
754
    #db_data{db            = DbList,
759
 
             db_size       = DbSize,
760
 
             max_elem_size = MaxElemSize,
761
 
             ets_type      = EtsType,     %% 'bag', 'set' or 'duplicate_bag'
762
 
             deleted       = OldDeleted,
763
 
             sorting       = Sorting,
764
 
             rev_sorting   = RevSorting,
765
 
             sort_key_no   = SortKeyNo,
766
 
             key_no        = KeyNo} = DbData,
 
755
             deleted       = OldDeleted} = DbData,
767
756
    
768
757
       %% Before we try to update the internal database, we have to check to see
769
758
       %% whether the ETS/Mnesia update is allowed!
800
789
               %% once, but we only want to remove it once!
801
790
            {Repl, TmpList} =
802
791
                case split(ObjNo, DbList) of
803
 
                    {L1, [{Obj,Color} | T]} ->
 
792
                    {L1, [{Obj,_Color} | T]} ->
804
793
                        {true, L1 ++ [{Obj,?BLACK} | T]};
805
794
                    {L1, L2} ->
806
795
                        {false, L1 ++ L2}
813
802
                        Fun = fun({Data,TmpColor}, 
814
803
                                  {Removed,AccDb}) when Data /= Obj ->
815
804
                                      {Removed, [{Data,TmpColor} | AccDb]};
816
 
                                 ({Data,TmpColor}, 
 
805
                                 ({_Data,TmpColor}, 
817
806
                                  {Removed,AccDb}) when Removed == false, TmpColor /= ?BLACK ->
818
807
                                      {true, [{Obj,?BLACK} | AccDb]};
819
808
                                 ({Data,TmpColor}, 
837
826
                       etsread_pid = EtsreadPid}  = ProcVars,
838
827
    
839
828
    #db_data{db            = DbList,
840
 
             db_size       = DbSize,
841
829
             max_elem_size = MaxElemSize,
842
830
             ets_type      = EtsType,     %% 'bag', 'set' or 'duplicate_bag'
843
831
             sorting       = Sorting,
902
890
                                                         Color /= ?BLACK,
903
891
                                                         Data /= Obj->
904
892
                        {true, [{Obj,?GREEN1} | AccDb]};
905
 
                   ({Data,Color}, {Replaced,AccDb}) when Replaced == false, 
 
893
                   ({_Data,Color}, {Replaced,AccDb}) when Replaced == false, 
906
894
                                                         Color /= ?BLACK ->
907
895
                        {true, [{Obj,Color} | AccDb]};
908
 
                   ({Data,Color}, {Replaced,AccDb}) when Replaced == false, 
 
896
                   ({_Data,Color}, {Replaced,AccDb}) when Replaced == false, 
909
897
                                                         Color == ?BLACK ->
910
898
                        {true, [{Obj, ?RED1} | AccDb]};
911
 
                   ({Data,Color}, {Replaced,AccDb}) when Replaced == true, 
 
899
                   ({_Data,Color}, {Replaced,AccDb}) when Replaced == true, 
912
900
                                                         Color == ?BLACK ->
913
901
                        {false, AccDb};
914
 
                   ({Data,Color}, {Replaced,AccDb}) ->
 
902
                   ({_Data,_Color}, {Replaced,AccDb}) ->
915
903
                        {Replaced, AccDb}
916
904
                end;
917
905
            bag ->
918
906
                fun({Data,Color}, {Replaced,AccDb}) when Data /= Obj ->
919
907
                        {Replaced, [{Data,Color} | AccDb]};
920
 
                   ({Data,Color}, {Replaced,AccDb}) when Replaced == false, 
 
908
                   ({_Data,Color}, {Replaced,AccDb}) when Replaced == false, 
921
909
                                                         Color /= ?BLACK ->
922
910
                        {true, [{Obj,Color} | AccDb]};
923
 
                   ({Data,Color}, {Replaced,AccDb}) when Replaced == true, 
 
911
                   ({_Data,Color}, {Replaced,AccDb}) when Replaced == true, 
924
912
                                                         Color /= ?BLACK ->
925
913
                        {true, AccDb};
926
 
                   ({Data,Color}, {Replaced,AccDb}) when Replaced == true, 
 
914
                   ({_Data,Color}, {Replaced,AccDb}) when Replaced == true, 
927
915
                                                         Color == ?BLACK ->
928
916
                        {true, AccDb};
929
 
                   ({Data,Color}, {Replaced,AccDb}) when Replaced == false, 
 
917
                   ({_Data,Color}, {Replaced,AccDb}) when Replaced == false, 
930
918
                                                         Color == ?BLACK ->
931
919
                        {true, [{Obj, ?RED1} | AccDb]};
932
 
                   ({Data,Color}, {Replaced,AccDb}) ->
 
920
                   ({_Data,_Color}, {Replaced,AccDb}) ->
933
921
                        {Replaced, AccDb}
934
922
                end;
935
923
            duplicate_bag ->
943
931
                        lists:foldl(Fun, Acc0, L)
944
932
                end,
945
933
    
946
 
    {Replaced, TmpDbList} = 
 
934
    {_Replaced, TmpDbList} = 
947
935
        case EtsType of
948
936
            duplicate_bag ->
949
937
                {false, DbList};
983
971
        true ->
984
972
            max_size(T, CurrMax)
985
973
    end;
986
 
max_size([H | T], CurrMax) ->
 
974
max_size([_H | T], CurrMax) ->
987
975
    Size = 1,
988
976
    if
989
977
        Size >= CurrMax ->
996
984
 
997
985
 
998
986
 
999
 
add_elements(KeyNo, Inserted, List, false, _RevSorting, _SortKeyNo) ->
 
987
add_elements(_KeyNo, Inserted, List, false, _RevSorting, _SortKeyNo) ->
1000
988
       % Remember that the order of the original list has to be preserved!
1001
989
    List ++ list2dblist(Inserted, ?RED1);
1002
 
add_elements(_KeyNo, Inserted, List, Sorting, RevSorting, SortKeyNo) ->
 
990
add_elements(_KeyNo, Inserted, List, _Sorting, RevSorting, SortKeyNo) ->
1003
991
       % The original list is already sorted - sort the new elements, and
1004
992
       % just merge the two lists together!
1005
993
    SortedInsertedList = tv_db_sort:mergesort(SortKeyNo, 
1029
1017
 
1030
1018
 
1031
1019
 
1032
 
mark_one_element_deleted(_KeyNo, _KeyValue, Data, [], Acc) ->
 
1020
mark_one_element_deleted(_KeyNo, _KeyValue, _Data, [], Acc) ->
1033
1021
    Acc;
1034
1022
mark_one_element_deleted(KeyNo, {tuple, KeyValue}, 
1035
1023
                         Data, [{DataTuple, Color} | Tail], Acc) ->
1086
1074
            replace_one_element(KeyNo, {tuple, Key1}, Data, Tail, 
1087
1075
                                Acc ++ [{DataTuple, Color}])
1088
1076
    end;
1089
 
replace_one_element(KeyNo, _KeyValue, Data, [{DataTuple, Color} | Tail], Acc) ->
 
1077
replace_one_element(_KeyNo, _KeyValue, _Data, [{DataTuple, Color} | Tail], Acc) ->
1090
1078
       % Can't replace an element with no key!
1091
1079
    Acc ++ [{DataTuple, Color} | Tail].
1092
1080
    
1105
1093
       %% Since the ETS table is of duplicate_bag type, no element can be updated, i.e.,
1106
1094
       %% it can only be deleted and re-inserted, otherwise a new element will be added.
1107
1095
    {Inserted, Deleted, []};
1108
 
group_difflists(set, KeyNo, [], Deleted) ->
 
1096
group_difflists(set, _KeyNo, [], Deleted) ->
1109
1097
       %% Updated elements have to be present in both lists, i.e., if one list is empty,
1110
1098
       %% the other contains no updated elements - they are either inserted or deleted!
1111
1099
    {[], Deleted, []};
1112
 
group_difflists(set, KeyNo, Inserted, []) ->
 
1100
group_difflists(set, _KeyNo, Inserted, []) ->
1113
1101
    {Inserted, [], []};
1114
1102
group_difflists(set, KeyNo, InsOrUpd, DelOrUpd) ->
1115
1103
    match_difflists(KeyNo, InsOrUpd, DelOrUpd, [], []).    
1170
1158
 
1171
1159
dblist2list([]) ->
1172
1160
    [];
1173
 
dblist2list([{Data, Color} | T]) ->
 
1161
dblist2list([{Data, _Color} | T]) ->
1174
1162
    [Data | dblist2list(T)].
1175
1163
    
1176
1164
    
1179
1167
 
1180
1168
 
1181
1169
 
1182
 
list2dblist([], Color) ->    
 
1170
list2dblist([], _Color) ->    
1183
1171
    [];
1184
1172
list2dblist([Data | T], Color) ->
1185
1173
    [{Data, Color} | list2dblist(T, Color)].
1237
1225
    ElapsedHours   = get_time_diff(hours, H1, H2),
1238
1226
    ElapsedMinutes = get_time_diff(minutes, M1, M2),
1239
1227
    ElapsedSeconds = get_time_diff(seconds, S1, S2),
1240
 
    (ElapsedHours * 3600) + (ElapsedHours * 60) + ElapsedSeconds + 1.
 
1228
    (ElapsedHours * 3600) + (ElapsedMinutes * 60) + ElapsedSeconds + 1.
1241
1229
 
1242
1230
 
1243
1231
 
1257
1245
 
1258
1246
 
1259
1247
 
1260
 
split(N, []) ->
 
1248
split(_N, []) ->
1261
1249
    {[], []};
1262
1250
split(0, List) ->
1263
1251
    {[], List};
1268
1256
 
1269
1257
split2(Ctr, N, Acc, [H | T]) when Ctr < N ->
1270
1258
    split2(Ctr + 1, N, [H | Acc], T);
1271
 
split2(Ctr, N, Acc, []) ->
 
1259
split2(_Ctr, _N, Acc, []) ->
1272
1260
    {lists:reverse(Acc), []};
1273
 
split2(Ctr, N, Acc, List) ->
 
1261
split2(_Ctr, _N, Acc, List) ->
1274
1262
    {lists:reverse(Acc), List}.
1275
1263
 
1276
1264
basetype(ordered_set) ->