Download Reference Manual
The Developer's Library for D
About Wiki Forums Source Search Contact

Ticket #1303: x86_64-4055.diff

File x86_64-4055.diff, 40.2 kB (added by Cyborg16, 4 years ago)

Updated; diff against r4055

  • tango/util/container/model/IContainer.d

    old new  
    2222 
    2323interface IContainer (V) 
    2424{ 
    25         uint size (); 
     25        size_t size (); 
    2626 
    2727        bool isEmpty (); 
    2828 
    …… 
    4040 
    4141        V[] toArray (V[] dst = null); 
    4242 
    43         uint remove (V element, bool all); 
     43        size_t remove (V element, bool all); 
    4444 
    4545        int opApply (int delegate(ref V value) dg); 
    4646 
    47         uint replace (V oldElement, V newElement, bool all); 
     47        size_t replace (V oldElement, V newElement, bool all); 
    4848} 
    4949 
    5050 

  • tango/util/container/SortedMap.d

    old new  
    4343        bool take (ref V v) 
    4444        bool take (K key, ref V v) 
    4545        bool removeKey (K key) 
    46         uint remove (V value, bool all) 
    47         uint remove (IContainer!(V) e, bool all) 
     46        size_t remove (V value, bool all) 
     47        size_t remove (IContainer!(V) e, bool all) 
    4848 
    4949        bool add (K key, V value) 
    50         uint replace (V oldElement, V newElement, bool all) 
     50        size_t replace (V oldElement, V newElement, bool all) 
    5151        bool replacePair (K key, V oldElement, V newElement) 
    5252        bool opIndexAssign (V element, K key) 
    5353        K    nearbyKey (K key, bool greater) 
    5454        V    opIndex (K key) 
    5555        V*   opIn_r (K key) 
    5656 
    57         uint size () 
     57        size_t size () 
    5858        bool isEmpty () 
    5959        V[] toArray (V[] dst) 
    6060        SortedMap dup () 
    …… 
    8686        private Comparator              cmp; 
    8787        private Compare!(V)             cmpElem; 
    8888 
    89         private int                     count, 
     89        private size_t                  count, 
    9090                                        mutation; 
    9191 
    9292 
    …… 
    107107                  
    108108        ***********************************************************************/ 
    109109 
    110         private this (Comparator c, int n) 
     110        private this (Comparator c, size_t n) 
    111111        {        
    112112                count = n; 
    113113                cmpElem = &compareElem; 
    …… 
    176176                 
    177177        ***********************************************************************/ 
    178178 
    179         final uint size () 
     179        final size_t size () 
    180180        { 
    181181                return count; 
    182182        } 
    …… 
    438438 
    439439        ************************************************************************/ 
    440440 
    441         final uint remove (IContainer!(V) e, bool all) 
     441        final size_t remove (IContainer!(V) e, bool all) 
    442442        { 
    443443                auto c = count; 
    444444                foreach (v; e) 
    …… 
    452452                  
    453453        ***********************************************************************/ 
    454454 
    455         final uint remove (V value, bool all = false) 
     455        final size_t remove (V value, bool all = false) 
    456456        {        
    457                 uint i = count; 
     457                size_t i = count; 
    458458                if (count) 
    459459                   { 
    460460                   auto p = tree.findAttribute (value, cmpElem); 
    …… 
    476476                  
    477477        ***********************************************************************/ 
    478478 
    479         final uint replace (V oldElement, V newElement, bool all = false) 
     479        final size_t replace (V oldElement, V newElement, bool all = false) 
    480480        { 
    481                 uint c; 
     481                size_t c; 
    482482 
    483483                if (count) 
    484484                   { 
    …… 
    636636                if (dst.length < count) 
    637637                    dst.length = count; 
    638638 
    639                 int i = 0; 
     639                size_t i = 0; 
    640640                foreach (k, v; this) 
    641641                         dst[i++] = v; 
    642642                return dst [0 .. count];                         
    …… 
    700700                  
    701701        ***********************************************************************/ 
    702702 
    703         private uint instances (V value) 
     703        private size_t instances (V value) 
    704704        { 
    705705                if (count is 0) 
    706706                     return 0; 
    …… 
    894894                Ref               node, 
    895895                                  prior; 
    896896                SortedMap         owner; 
    897                 uint              mutation; 
     897                size_t            mutation; 
    898898 
    899899                /*************************************************************** 
    900900 

  • tango/util/container/HashSet.d

    old new  
    3434        bool contains (V element) 
    3535        bool take (ref V element) 
    3636        bool remove (V element) 
    37         uint remove (IContainer!(V) e) 
     37        size_t remove (IContainer!(V) e) 
    3838        bool replace (V oldElement, V newElement) 
    3939 
    40         uint size () 
     40        size_t size () 
    4141        bool isEmpty () 
    4242        V[] toArray (V[] dst) 
    4343        HashSet dup () 
    4444        HashSet clear () 
    4545        HashSet reset () 
    4646 
    47         uint buckets () 
    48         void buckets (uint cap) 
     47        size_t buckets () 
     48        void buckets (size_t cap) 
    4949        float threshold () 
    5050        void threshold (float desired) 
    5151        --- 
    …… 
    6868        private Ref             table[]; 
    6969         
    7070        // number of elements contained 
    71         private uint            count; 
     71        private size_t          count; 
    7272 
    7373        // the threshold load factor 
    7474        private float           loadFactor; 
    …… 
    7777        private Alloc           heap; 
    7878         
    7979        // mutation tag updates on each change 
    80         private uint            mutation; 
     80        private size_t            mutation; 
    8181 
    8282        /*********************************************************************** 
    8383 
    …… 
    145145                 
    146146        ***********************************************************************/ 
    147147 
    148         final uint size () 
     148        final size_t size () 
    149149        { 
    150150                return count; 
    151151        } 
    …… 
    231231 
    232232        ***********************************************************************/ 
    233233 
    234         final uint remove (V element, bool all) 
     234        final size_t remove (V element, bool all) 
    235235        { 
    236236                return remove(element) ? 1 : 0; 
    237237        } 
    …… 
    287287                 
    288288        ***********************************************************************/ 
    289289 
    290         final uint replace (V oldElement, V newElement, bool all) 
     290        final size_t replace (V oldElement, V newElement, bool all) 
    291291        { 
    292292                return replace (oldElement, newElement) ? 1 : 0; 
    293293        } 
    …… 
    351351 
    352352        ************************************************************************/ 
    353353 
    354         public uint remove (IContainer!(V) e) 
     354        public size_t remove (IContainer!(V) e) 
    355355        { 
    356                 uint c; 
     356                size_t c; 
    357357                foreach (value; e) 
    358358                         if (remove (value)) 
    359359                             ++c; 
    …… 
    400400 
    401401        ***********************************************************************/ 
    402402 
    403         final uint buckets () 
     403        final size_t buckets () 
    404404        { 
    405405                return table ? table.length : 0; 
    406406        } 
    …… 
    413413 
    414414        ***********************************************************************/ 
    415415 
    416         final void buckets (uint cap) 
     416        final void buckets (size_t cap) 
    417417        { 
    418418                if (cap < Container.defaultInitialBuckets) 
    419419                    cap = Container.defaultInitialBuckets; 
    …… 
    468468                if (dst.length < count) 
    469469                    dst.length = count; 
    470470 
    471                 int i = 0; 
     471                size_t i = 0; 
    472472                foreach (v; this) 
    473473                         dst[i++] = v; 
    474474                return dst [0 .. count];                         
    …… 
    501501 
    502502                if (table) 
    503503                   { 
    504                    int c = 0; 
    505                    for (int i = 0; i < table.length; ++i) 
     504                   size_t c = 0; 
     505                   for (size_t i = 0; i < table.length; ++i) 
    506506                       { 
    507507                       for (auto p = table[i]; p; p = p.next) 
    508508                           { 
    …… 
    539539                float fc = count; 
    540540                float ft = table.length; 
    541541                if (fc / ft > loadFactor) 
    542                     resize (2 * cast(int)(fc / loadFactor) + 1); 
     542                    resize (2 * cast(size_t)(fc / loadFactor) + 1); 
    543543        } 
    544544 
    545545        /*********************************************************************** 
    …… 
    548548                 
    549549        ***********************************************************************/ 
    550550 
    551         private void resize (uint newCap) 
     551        private void resize (size_t newCap) 
    552552        { 
    553553                //Stdout.formatln ("resize {}", newCap); 
    554554                auto newtab = heap.allocate (newCap); 
    …… 
    579579                  
    580580        ***********************************************************************/ 
    581581 
    582         private bool remove (Ref node, uint row) 
     582        private bool remove (Ref node, size_t row) 
    583583        { 
    584584                auto hd = table[row]; 
    585585                auto trail = hd; 
    …… 
    683683 
    684684        private struct Iterator 
    685685        { 
    686                 uint    row; 
     686                size_t  row; 
    687687                Ref     cell, 
    688688                        prior; 
    689689                Ref[]   table; 
    690690                HashSet owner; 
    691                 uint    mutation; 
     691                size_t  mutation; 
    692692 
    693693                /*************************************************************** 
    694694 

  • tango/util/container/CircularList.d

    old new  
    2828 
    2929        --- 
    3030        Iterator iterator () 
    31         uint opApply (int delegate(ref V value) dg) 
     31        int opApply (int delegate(ref V value) dg) 
    3232 
    3333        CircularList add (V element) 
    34         CircularList addAt (uint index, V element) 
     34        CircularList addAt (size_t index, V element) 
    3535        CircularList append (V element) 
    3636        CircularList prepend (V element) 
    37         uint addAt (uint index, IContainer!(V) e) 
    38         uint append (IContainer!(V) e) 
    39         uint prepend (IContainer!(V) e) 
     37        size_t addAt (size_t index, IContainer!(V) e) 
     38        size_t append (IContainer!(V) e) 
     39        size_t prepend (IContainer!(V) e) 
    4040 
    4141        bool take (ref V v) 
    4242        bool contains (V element) 
    43         V get (uint index) 
    44         uint first (V element, uint startingIndex = 0) 
    45         uint last (V element, uint startingIndex = 0) 
     43        V get (size_t index) 
     44        size_t first (V element, size_t startingIndex = 0) 
     45        size_t last (V element, size_t startingIndex = 0) 
    4646 
    4747        V head () 
    4848        V tail () 
    …… 
    5151        V removeHead () 
    5252        V removeTail () 
    5353 
    54         bool removeAt (uint index) 
    55         uint remove (V element, bool all) 
    56         uint removeRange (uint fromIndex, uint toIndex) 
     54        bool removeAt (size_t index) 
     55        size_t remove (V element, bool all) 
     56        size_t removeRange (size_t fromIndex, size_t toIndex) 
    5757 
    58         uint replace (V oldElement, V newElement, bool all) 
    59         bool replaceAt (uint index, V element) 
     58        size_t replace (V oldElement, V newElement, bool all) 
     59        bool replaceAt (size_t index, V element) 
    6060 
    61         uint size () 
     61        size_t size () 
    6262        bool isEmpty () 
    6363        V[] toArray (V[] dst) 
    6464        CircularList dup () 
    65         CircularList subset (uint from, uint length) 
     65        CircularList subset (size_t from, size_t length) 
    6666        CircularList clear () 
    6767        CircularList reset () 
    6868        CircularList check () 
    …… 
    8282        private alias Heap!(Type) Alloc; 
    8383 
    8484        // number of elements contained 
    85         private uint            count; 
     85        private size_t          count; 
    8686 
    8787        // configured heap manager 
    8888        private Alloc           heap; 
    8989         
    9090        // mutation tag updates on each change 
    91         private uint            mutation; 
     91        private size_t          mutation; 
    9292 
    9393        // head of the list. Null if empty 
    9494        private Ref             list; 
    …… 
    111111 
    112112        ***********************************************************************/ 
    113113 
    114         protected this (Ref h, uint c) 
     114        protected this (Ref h, size_t c) 
    115115        { 
    116116                list = h; 
    117117                count = c; 
    …… 
    172172                 
    173173        ***********************************************************************/ 
    174174 
    175         final uint size () 
     175        final size_t size () 
    176176        { 
    177177                return count; 
    178178        } 
    …… 
    230230 
    231231        ***********************************************************************/ 
    232232 
    233         final V get (uint index) 
     233        final V get (size_t index) 
    234234        { 
    235235                return cellAt(index).value; 
    236236        } 
    …… 
    238238        /*********************************************************************** 
    239239 
    240240                Time complexity: O(n) 
     241                Returns size_t.max if no element found. 
    241242 
    242243        ***********************************************************************/ 
    243244 
    244         final uint first (V element, uint startingIndex = 0) 
     245        final size_t first (V element, size_t startingIndex = 0) 
    245246        { 
    246247                if (startingIndex < 0) 
    247248                    startingIndex = 0; 
    248249 
    249250                auto p = list; 
    250251                if (p is null) 
    251                     return uint.max; 
     252                    return size_t.max; 
    252253 
    253                 for (uint i = 0; true; ++i) 
     254                for (size_t i = 0; true; ++i) 
    254255                    { 
    255256                    if (i >= startingIndex && element == p.value) 
    256257                        return i; 
    …… 
    259260                    if (p is list) 
    260261                        break; 
    261262                    } 
    262                 return uint.max; 
     263                return size_t.max; 
    263264        } 
    264265 
    265266        /*********************************************************************** 
    266267                 
    267268                Time complexity: O(n) 
     269                Returns size_t.max if no element found. 
    268270 
    269271        ***********************************************************************/ 
    270272 
    271         final uint last (V element, uint startingIndex = 0) 
     273        final size_t last (V element, size_t startingIndex = 0) 
    272274        { 
    273275                if (count is 0) 
    274                     return uint.max; 
     276                    return size_t.max; 
    275277 
    276278                if (startingIndex >= count) 
    277279                    startingIndex = count - 1; 
    …… 
    280282                    startingIndex = 0; 
    281283 
    282284                auto p = cellAt (startingIndex); 
    283                 uint i = startingIndex; 
     285                size_t i = startingIndex; 
    284286                for (;;) 
    285287                    { 
    286288                    if (element == p.value) 
    …… 
    294296                          --i; 
    295297                          } 
    296298                    } 
    297                 return uint.max; 
     299                return size_t.max; 
    298300        } 
    299301 
    300302        /*********************************************************************** 
    …… 
    303305 
    304306        ***********************************************************************/ 
    305307 
    306         final CircularList subset (uint from, uint length) 
     308        final CircularList subset (size_t from, size_t length) 
    307309        { 
    308310                Ref newlist = null; 
    309311 
    …… 
    313315                   auto p = cellAt (from); 
    314316                   auto current = newlist = heap.allocate.set (p.value); 
    315317 
    316                    for (uint i = 1; i < length; ++i) 
     318                   for (size_t i = 1; i < length; ++i) 
    317319                       { 
    318320                       p = p.next; 
    319321                       if (p is null) 
    …… 
    496498 
    497499        ***********************************************************************/ 
    498500 
    499         final CircularList addAt (uint index, V element) 
     501        final CircularList addAt (size_t index, V element) 
    500502        { 
    501503                if (index is 0) 
    502504                    prepend (element); 
    …… 
    514516 
    515517        ***********************************************************************/ 
    516518 
    517         final CircularList replaceAt (uint index, V element) 
     519        final CircularList replaceAt (size_t index, V element) 
    518520        { 
    519521                cellAt(index).value = element; 
    520522                mutate; 
    …… 
    527529 
    528530        ***********************************************************************/ 
    529531 
    530         final CircularList removeAt (uint index) 
     532        final CircularList removeAt (size_t index) 
    531533        { 
    532534                if (index is 0) 
    533535                    removeHead; 
    …… 
    546548 
    547549        ***********************************************************************/ 
    548550 
    549         final uint remove (V element, bool all) 
     551        final size_t remove (V element, bool all) 
    550552        { 
    551553                auto c = count; 
    552554                if (list) 
    …… 
    591593 
    592594        ***********************************************************************/ 
    593595 
    594         final uint replace (V oldElement, V newElement, bool all) 
     596        final size_t replace (V oldElement, V newElement, bool all) 
    595597        { 
    596                 uint c; 
     598                size_t c; 
    597599                if (list) 
    598600                   { 
    599601                   auto p = list; 
    …… 
    618620 
    619621        ***********************************************************************/ 
    620622 
    621         final uint prepend (IContainer!(V) e) 
     623        final size_t prepend (IContainer!(V) e) 
    622624        { 
    623625                Ref hd = null; 
    624626                Ref current = null; 
    …… 
    661663 
    662664        ***********************************************************************/ 
    663665 
    664         final uint append (IContainer!(V) e) 
     666        final size_t append (IContainer!(V) e) 
    665667        { 
    666668                auto c = count; 
    667669                if (list is null) 
    …… 
    685687 
    686688        ***********************************************************************/ 
    687689 
    688         final uint addAt (uint index, IContainer!(V) e) 
     690        final size_t addAt (size_t index, IContainer!(V) e) 
    689691        { 
    690692                auto c = count; 
    691693                if (list is null || index is 0) 
    …… 
    709711 
    710712        ***********************************************************************/ 
    711713 
    712         final uint removeRange (uint fromIndex, uint toIndex) 
     714        final size_t removeRange (size_t fromIndex, size_t toIndex) 
    713715        { 
    714716                auto p = cellAt (fromIndex); 
    715717                auto last = list.prev; 
    716718                auto c = count; 
    717                 for (uint i = fromIndex; i <= toIndex; ++i) 
     719                for (size_t i = fromIndex; i <= toIndex; ++i) 
    718720                    { 
    719721                    auto n = p.next; 
    720722                    p.unlink; 
    …… 
    751753                if (dst.length < count) 
    752754                    dst.length = count; 
    753755 
    754                 int i = 0; 
     756                size_t i = 0; 
    755757                foreach (v; this) 
    756758                         dst[i++] = v; 
    757759                return dst [0 .. count];                         
    …… 
    782784 
    783785                if (list) 
    784786                   { 
    785                    uint c = 0; 
     787                   size_t c = 0; 
    786788                   auto p = list; 
    787789                   do { 
    788790                      assert(p.prev.next is p); 
    …… 
    803805 
    804806        ***********************************************************************/ 
    805807 
    806         private uint instances (V element) 
     808        private size_t instances (V element) 
    807809        { 
    808810                if (list) 
    809811                    return list.count (element); 
    …… 
    815817 
    816818        ***********************************************************************/ 
    817819 
    818         private void checkIndex (uint i) 
     820        private void checkIndex (size_t i) 
    819821        { 
    820822                if (i >= count) 
    821823                    throw new Exception ("out of range"); 
    …… 
    851853 
    852854        ***********************************************************************/ 
    853855 
    854         private Ref cellAt (uint index) 
     856        private Ref cellAt (size_t index) 
    855857        { 
    856858                checkIndex (index); 
    857859                return list.nth (index); 
    …… 
    933935                                  head, 
    934936                                  prior; 
    935937                CircularList      owner; 
    936                 uint              mutation; 
     938                size_t            mutation; 
    937939 
    938940                /*************************************************************** 
    939941 

  • tango/util/container/HashMap.d

    old new  
    4141        bool removeKey (K key) 
    4242        bool take (ref V element) 
    4343        bool take (K key, ref V element) 
    44         uint remove (V element, bool all) 
    45         uint remove (IContainer!(V) e, bool all) 
    46         uint replace (V oldElement, V newElement, bool all) 
     44        size_t remove (V element, bool all) 
     45        size_t remove (IContainer!(V) e, bool all) 
     46        size_t replace (V oldElement, V newElement, bool all) 
    4747        bool replacePair (K key, V oldElement, V newElement) 
    4848 
    4949        bool add (K key, V element) 
    …… 
    5151        V    opIndex (K key) 
    5252        V*   opIn_r (K key) 
    5353 
    54         uint size () 
     54        size_t size () 
    5555        bool isEmpty () 
    5656        V[] toArray (V[] dst) 
    5757        HashMap dup () 
    5858        HashMap clear () 
    5959        HashMap reset () 
    60         uint buckets () 
     60        size_t buckets () 
    6161        float threshold () 
    62         void buckets (uint cap) 
     62        void buckets (size_t cap) 
    6363        void threshold (float desired) 
    6464        Allocator allocator() 
    6565        --- 
    …… 
    8282        private Ref                table[]; 
    8383         
    8484        // number of elements contained 
    85         private uint               count; 
     85        private size_t             count; 
    8686 
    8787        // the threshold load factor 
    8888        private float              loadFactor; 
    …… 
    9191        private Alloc              heap; 
    9292         
    9393        // mutation tag updates on each change 
    94         private uint               mutation; 
     94        private size_t             mutation; 
    9595 
    9696        /*********************************************************************** 
    9797 
    …… 
    169169                 
    170170        ***********************************************************************/ 
    171171 
    172         final uint size () 
     172        final size_t size () 
    173173        { 
    174174                return count; 
    175175        } 
    …… 
    526526 
    527527        ************************************************************************/ 
    528528 
    529         final uint remove (IContainer!(V) e, bool all = false) 
     529        final size_t remove (IContainer!(V) e, bool all = false) 
    530530        { 
    531                 int i = count; 
     531                auto i = count; 
    532532                foreach (value; e) 
    533533                         remove (value, all); 
    534534                return i - count; 
    …… 
    543543         
    544544        ************************************************************************/ 
    545545 
    546         final uint remove (V element, bool all = false) 
     546        final size_t remove (V element, bool all = false) 
    547547        { 
    548548                auto i = count; 
    549549                 
    …… 
    592592                 
    593593        ************************************************************************/ 
    594594 
    595         final uint replace (V oldElement, V newElement, bool all = false) 
     595        final size_t replace (V oldElement, V newElement, bool all = false) 
    596596        { 
    597                 uint i; 
     597                size_t i; 
    598598                 
    599599                if (count && oldElement != newElement) 
    600600                    foreach (node; table) 
    …… 
    649649 
    650650        ***********************************************************************/ 
    651651 
    652         final uint buckets () 
     652        final size_t buckets () 
    653653        { 
    654654                return table ? table.length : 0; 
    655655        } 
    …… 
    665665 
    666666        ***********************************************************************/ 
    667667 
    668         final void buckets (uint cap) 
     668        final void buckets (size_t cap) 
    669669        { 
    670670                if (cap < Container.defaultInitialBuckets) 
    671671                    cap = Container.defaultInitialBuckets; 
    …… 
    683683 
    684684        ***********************************************************************/ 
    685685 
    686         final void buckets (uint cap, float threshold) 
     686        final void buckets (size_t cap, float threshold) 
    687687        { 
    688688                loadFactor = threshold; 
    689                 buckets (cast(int)(cap / threshold) + 1); 
     689                buckets (cast(size_t)(cap / threshold) + 1); 
    690690        } 
    691691 
    692692        /*********************************************************************** 
    …… 
    741741                if (dst.length < count) 
    742742                    dst.length = count; 
    743743 
    744                 int i = 0; 
     744                size_t i = 0; 
    745745                foreach (k, v; this) 
    746746                         dst[i++] = v; 
    747747                return dst [0 .. count];                         
    …… 
    774774 
    775775                if (table) 
    776776                   { 
    777                    int c = 0; 
    778                    for (int i=0; i < table.length; ++i) 
     777                   size_t c = 0; 
     778                   for (size_t i=0; i < table.length; ++i) 
    779779                        for (auto p = table[i]; p; p = p.next) 
    780780                            { 
    781781                            ++c; 
    …… 
    799799                 
    800800        ***********************************************************************/ 
    801801 
    802         private uint instances (V element) 
     802        private size_t instances (V element) 
    803803        { 
    804                 uint c = 0; 
     804                size_t c = 0; 
    805805                foreach (node; table) 
    806806                         if (node) 
    807807                             c += node.count (element); 
    …… 
    820820                float fc = count; 
    821821                float ft = table.length; 
    822822                if (fc / ft > loadFactor) 
    823                     resize (2 * cast(int)(fc / loadFactor) + 1); 
     823                    resize (2 * cast(size_t)(fc / loadFactor) + 1); 
    824824                return this; 
    825825        } 
    826826 
    …… 
    830830                 
    831831        ***********************************************************************/ 
    832832 
    833         private void resize (uint newCap) 
     833        private void resize (size_t newCap) 
    834834        { 
    835835                // Stdout.formatln ("resize {}", newCap); 
    836836                auto newtab = heap.allocate (newCap); 
    …… 
    955955 
    956956        private struct Iterator 
    957957        { 
    958                 uint    row; 
     958                size_t  row; 
    959959                Ref     cell, 
    960960                        prior; 
    961961                Ref[]   table; 
    962962                HashMap owner; 
    963                 uint    mutation; 
     963                size_t  mutation; 
    964964 
    965965                /*************************************************************** 
    966966 

  • tango/util/container/Container.d

    old new  
    3232 
    3333        ***********************************************************************/ 
    3434         
    35         static int defaultInitialBuckets = 31; 
     35        static size_t defaultInitialBuckets = 31; 
    3636 
    3737        /*********************************************************************** 
    3838 
    …… 
    6767 
    6868        ***********************************************************************/ 
    6969 
    70         static uint hash(K) (K k, uint length) 
     70        static size_t hash(K) (K k, size_t length) 
    7171        { 
    7272                static if (is(K : int) || is(K : uint) ||  
    7373                           is(K : long) || is(K : ulong) ||  
    7474                           is(K : short) || is(K : ushort) || 
    7575                           is(K : byte) || is(K : ubyte) || 
    7676                           is(K : char) || is(K : wchar) || is (K : dchar)) 
    77                            return cast(uint) (k % length); 
     77                           return cast(size_t) (k % length); 
    7878                else 
    7979                   return (typeid(K).getHash(&k) & 0x7FFFFFFF) % length; 
    8080        } 
    …… 
    104104                         
    105105                ***************************************************************/ 
    106106         
    107                 T*[] allocate (uint count) 
     107                T*[] allocate (size_t count) 
    108108                { 
    109109                        return new T*[count]; 
    110110                } 
    …… 
    191191                         
    192192                ***************************************************************/ 
    193193         
    194                 T*[] allocate (uint count) 
     194                T*[] allocate (size_t count) 
    195195                { 
    196196                        return (cast(T**) calloc(count, (T*).sizeof)) [0 .. count]; 
    197197                } 
    …… 
    268268        { 
    269269                private T[]     list; 
    270270                private T[][]   lists; 
    271                 private int     index; 
    272                 private int     freelists; 
    273                 private int     presize = 0; 
    274                 private int     chunks = 1000; 
     271                private size_t     index; 
     272                private size_t     freelists; 
     273                private size_t     presize = 0; 
     274                private size_t     chunks = 1000; 
    275275 
    276276                private struct Discarded 
    277277                { 
    …… 
    285285                         
    286286                ***************************************************************/ 
    287287         
    288                 void config (int chunks, int presize) 
     288                void config (size_t chunks, size_t presize) 
    289289                { 
    290290                        this.chunks = chunks; 
    291291                        this.presize = presize; 
    …… 
    322322                         
    323323                ***************************************************************/ 
    324324         
    325                 T*[] allocate (uint count) 
     325                T*[] allocate (size_t count) 
    326326                { 
    327327                        return (cast(T**) calloc(count, (T*).sizeof)) [0 .. count]; 
    328328                } 

  • tango/util/container/LinkedList.d

    old new  
    3838        V removeTail () 
    3939 
    4040        bool contains (V value) 
    41         uint first (V value, uint startingIndex = 0) 
    42         uint last (V value, uint startingIndex = 0) 
     41        size_t first (V value, size_t startingIndex = 0) 
     42        size_t last (V value, size_t startingIndex = 0) 
    4343 
    4444        LinkedList add (V value) 
    4545        LinkedList prepend (V value) 
    46         uint prepend (IContainer!(V) e) 
     46        size_t prepend (IContainer!(V) e) 
    4747        LinkedList append (V value) 
    48         uint append (IContainer!(V) e) 
    49         LinkedList addAt (uint index, V value) 
    50         uint addAt (uint index, IContainer!(V) e) 
     48        size_t append (IContainer!(V) e) 
     49        LinkedList addAt (size_t index, V value) 
     50        size_t addAt (size_t index, IContainer!(V) e) 
    5151 
    52         V get (uint index) 
     52        V get (size_t index) 
    5353        bool take (ref V v) 
    54         uint remove (V value, bool all) 
    55         bool removeAt (uint index) 
    56         uint removeRange (uint fromIndex, uint toIndex) 
    57         uint replace (V oldElement, V newElement, bool all) 
    58         bool replaceAt (uint index, V value) 
     54        size_t remove (V value, bool all) 
     55        bool removeAt (size_t index) 
     56        size_t removeRange (size_t fromIndex, size_t toIndex) 
     57        size_t replace (V oldElement, V newElement, bool all) 
     58        bool replaceAt (size_t index, V value) 
    5959 
    6060        LinkedList clear () 
    6161        LinkedList reset () 
    6262 
    63         LinkedList subset (uint from, uint length = int.max) 
     63        LinkedList subset (size_t from, size_t length = size_t.max) 
    6464        LinkedList dup () 
    6565 
    66         uint size () 
     66        size_t size () 
    6767        bool isEmpty () 
    6868        V[] toArray (V[] dst) 
    6969        LinkedList sort (Compare!(V) cmp) 
    …… 
    8585        private alias Heap!(Type) Alloc; 
    8686 
    8787        // number of elements contained 
    88         private uint            count; 
     88        private size_t          count; 
    8989 
    9090        // configured heap manager 
    9191        private Alloc           heap; 
    9292         
    9393        // mutation tag updates on each change 
    94         private uint            mutation; 
     94        private size_t          mutation; 
    9595 
    9696        // head of the list. Null if empty 
    9797        private Ref             list; 
    …… 
    113113 
    114114        ***********************************************************************/ 
    115115 
    116         protected this (Ref l, int c) 
     116        protected this (Ref l, size_t c) 
    117117        { 
    118118                list = l; 
    119119                count = c; 
    …… 
    173173                 
    174174        ***********************************************************************/ 
    175175 
    176         final uint size () 
     176        final size_t size () 
    177177        { 
    178178                return count; 
    179179        } 
    …… 
    232232 
    233233        ***********************************************************************/ 
    234234 
    235         final V get (uint index) 
     235        final V get (size_t index) 
    236236        { 
    237237                return cellAt(index).value; 
    238238        } 
    …… 
    240240        /*********************************************************************** 
    241241 
    242242                 Time complexity: O(n) 
     243                 Returns size_t.max if no element found. 
    243244 
    244245        ***********************************************************************/ 
    245246 
    246         final uint first (V value, uint startingIndex = 0) 
     247        final size_t first (V value, size_t startingIndex = 0) 
    247248        { 
    248249                if (list is null || startingIndex >= count) 
    249                     return uint.max; 
     250                    return size_t.max; 
    250251 
    251252                if (startingIndex < 0) 
    252253                    startingIndex = 0; 
    …… 
    258259                   if (i >= 0) 
    259260                       return i + startingIndex; 
    260261                   } 
    261                 return uint.max; 
     262                return size_t.max; 
    262263        } 
    263264 
    264265        /*********************************************************************** 
    265266 
    266267                 Time complexity: O(n) 
     268                 Returns size_t.max if no element found. 
    267269 
    268270        ***********************************************************************/ 
    269271 
    270         final uint last (V value, uint startingIndex = 0) 
     272        final size_t last (V value, size_t startingIndex = 0) 
    271273        { 
    272274                if (list is null) 
    273                     return uint.max; 
     275                    return size_t.max; 
    274276 
    275277                auto i = 0; 
    276278                if (startingIndex >= count) 
    277279                    startingIndex = count - 1; 
    278280 
    279                 auto index = uint.max; 
     281                auto index = size_t.max; 
    280282                auto p = list; 
    281283                while (i <= startingIndex && p) 
    282284                      { 
    …… 
    294296 
    295297        ***********************************************************************/ 
    296298 
    297         final LinkedList subset (uint from, uint length = int.max) 
     299        final LinkedList subset (size_t from, size_t length = size_t.max) 
    298300        { 
    299301                Ref newlist = null; 
    300302 
    …… 
    410412 
    411413        ***********************************************************************/ 
    412414 
    413         final uint remove (V value, bool all = false) 
     415        final size_t remove (V value, bool all = false) 
    414416        { 
    415417                auto c = count; 
    416418                if (c) 
    …… 
    453455 
    454456        ***********************************************************************/ 
    455457 
    456         final uint replace (V oldElement, V newElement, bool all = false) 
     458        final size_t replace (V oldElement, V newElement, bool all = false) 
    457459        { 
    458                 uint c; 
     460                size_t c; 
    459461                if (count && oldElement != newElement) 
    460462                   { 
    461463                   auto p = list.find (oldElement); 
    …… 
    566568 
    567569        ***********************************************************************/ 
    568570 
    569         final LinkedList addAt (uint index, V value) 
     571        final LinkedList addAt (size_t index, V value) 
    570572        { 
    571573                if (index is 0) 
    572574                    prepend (value); 
    …… 
    584586 
    585587        ***********************************************************************/ 
    586588 
    587         final LinkedList removeAt (uint index) 
     589        final LinkedList removeAt (size_t index) 
    588590        { 
    589591                if (index is 0) 
    590592                    removeHead; 
    …… 
    604606 
    605607        ***********************************************************************/ 
    606608 
    607         final LinkedList replaceAt (uint index, V value) 
     609        final LinkedList replaceAt (size_t index, V value) 
    608610        { 
    609611                cellAt(index).value = value; 
    610612                mutate; 
    …… 
    617619 
    618620        ***********************************************************************/ 
    619621 
    620         final uint prepend (IContainer!(V) e) 
     622        final size_t prepend (IContainer!(V) e) 
    621623        { 
    622624                auto c = count; 
    623625                splice_ (e, null, list); 
    …… 
    630632 
    631633        ***********************************************************************/ 
    632634 
    633         final uint append (IContainer!(V) e) 
     635        final size_t append (IContainer!(V) e) 
    634636        { 
    635637                auto c = count; 
    636638                if (list is null) 
    …… 
    646648 
    647649        ***********************************************************************/ 
    648650 
    649         final uint addAt (uint index, IContainer!(V) e) 
     651        final size_t addAt (size_t index, IContainer!(V) e) 
    650652        { 
    651653                auto c = count; 
    652654                if (index is 0) 
    …… 
    665667 
    666668        ***********************************************************************/ 
    667669 
    668         final uint removeRange (uint fromIndex, uint toIndex) 
     670        final size_t removeRange (size_t fromIndex, size_t toIndex) 
    669671        { 
    670672                auto c = count; 
    671673                if (fromIndex <= toIndex) 
    …… 
    673675                   if (fromIndex is 0) 
    674676                      { 
    675677                      auto p = firstCell; 
    676                       for (int i = fromIndex; i <= toIndex; ++i) 
     678                      for (size_t i = fromIndex; i <= toIndex; ++i) 
    677679                           p = p.next; 
    678680                      list = p; 
    679681                      } 
    …… 
    681683                      { 
    682684                      auto f = cellAt (fromIndex - 1); 
    683685                      auto p = f; 
    684                       for (int i = fromIndex; i <= toIndex; ++i) 
     686                      for (size_t i = fromIndex; i <= toIndex; ++i) 
    685687                           p = p.next; 
    686688                      f.next = p.next; 
    687689                      } 
    …… 
    709711                if (dst.length < count) 
    710712                    dst.length = count; 
    711713 
    712                 int i = 0; 
     714                size_t i = 0; 
    713715                foreach (v; this) 
    714716                         dst[i++] = v; 
    715717                return dst [0 .. count];                         
    …… 
    737739                assert(((count is 0) is (list is null))); 
    738740                assert((list is null || list.count is size)); 
    739741 
    740                 int c = 0; 
     742                size_t c = 0; 
    741743                for (Ref p = list; p; p = p.next) 
    742744                    { 
    743745                    assert(instances(p.value) > 0); 
    …… 
    754756 
    755757        ***********************************************************************/ 
    756758 
    757         private uint instances (V value) 
     759        private size_t instances (V value) 
    758760        { 
    759761                if (count is 0) 
    760762                    return 0; 
    …… 
    786788 
    787789        ***********************************************************************/ 
    788790 
    789         private Ref cellAt (uint index) 
     791        private Ref cellAt (size_t index) 
    790792        { 
    791793                checkIndex (index); 
    792794                return list.nth (index); 
    …… 
    796798 
    797799        ***********************************************************************/ 
    798800 
    799         private void checkIndex (uint index) 
     801        private void checkIndex (size_t index) 
    800802        { 
    801803                if (index >= count) 
    802804                    throw new Exception ("out of range"); 
    …… 
    915917                Ref*            hook, 
    916918                                prior; 
    917919                LinkedList      owner; 
    918                 uint            mutation; 
     920                size_t          mutation; 
    919921 
    920922                /*************************************************************** 
    921923 
Roadmap Timeline Tickets New Ticket Help / Guide About Trac
Login  |  
Trac dsource.org
RSS
Copyright © 2006-2012 Tango. All Rights Reserved. | Page Width: Static or Dynamic