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

Changeset 5064

Show
Ignore:
Timestamp:
11/08/09 20:13:46 (3 years ago)
Author:
kris
Message:

fixes #1303 :: x86_64 corrections for util.container

Kudos to Cyborg16

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • branches/kris/combine/tango/util/container/CircularList.d

    r4397 r5064  
    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 () 
    …… 
    5252        V removeTail () 
    5353 
    54         bool removeAt (uint index) 
    55         uint remove (V element, bool all) 
    56         uint removeRange (uint fromIndex, uint toIndex) 
    57  
    58         uint replace (V oldElement, V newElement, bool all) 
    59         bool replaceAt (uint index, V element) 
    60  
    61         uint size () 
     54        bool removeAt (size_t index) 
     55        size_t remove (V element, bool all) 
     56        size_t removeRange (size_t fromIndex, size_t toIndex) 
     57 
     58        size_t replace (V oldElement, V newElement, bool all) 
     59        bool replaceAt (size_t index, V element) 
     60 
     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 () 
    …… 
    8383 
    8484        // number of elements contained 
    85         private uint            count; 
     85        private size_t          count; 
    8686 
    8787        // configured heap manager 
    …… 
    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 
    …… 
    112112        ***********************************************************************/ 
    113113 
    114         protected this (Ref h, uint c) 
     114        protected this (Ref h, size_t c) 
    115115        { 
    116116                list = h; 
    …… 
    175175        ***********************************************************************/ 
    176176 
    177         final uint size () 
     177        final size_t size () 
    178178        { 
    179179                return count; 
    …… 
    233233        ***********************************************************************/ 
    234234 
    235         final V get (uint index) 
     235        final V get (size_t index) 
    236236        { 
    237237                return cellAt(index).value; 
    …… 
    241241 
    242242                Time complexity: O(n) 
    243  
    244         ***********************************************************************/ 
    245  
    246         final uint first (V element, uint startingIndex = 0) 
     243                Returns size_t.max if no element found. 
     244 
     245        ***********************************************************************/ 
     246 
     247        final size_t first (V element, size_t startingIndex = 0) 
    247248        { 
    248249                if (startingIndex < 0) 
    …… 
    251252                auto p = list; 
    252253                if (p is null) 
    253                     return uint.max; 
    254  
    255                 for (uint i = 0; true; ++i) 
     254                    return size_t.max; 
     255 
     256                for (size_t i = 0; true; ++i) 
    256257                    { 
    257258                    if (i >= startingIndex && element == p.value) 
    …… 
    262263                        break; 
    263264                    } 
    264                 return uint.max; 
    265         } 
    266  
    267         /*********************************************************************** 
    268                  
    269                 Time complexity: O(n) 
    270  
    271         ***********************************************************************/ 
    272  
    273         final uint last (V element, uint startingIndex = 0) 
     265                return size_t.max; 
     266        } 
     267 
     268        /*********************************************************************** 
     269                 
     270                Time complexity: O(n) 
     271                Returns size_t.max if no element found. 
     272 
     273        ***********************************************************************/ 
     274 
     275        final size_t last (V element, size_t startingIndex = 0) 
    274276        { 
    275277                if (count is 0) 
    276                     return uint.max; 
     278                    return size_t.max; 
    277279 
    278280                if (startingIndex >= count) 
    …… 
    283285 
    284286                auto p = cellAt (startingIndex); 
    285                 uint i = startingIndex; 
     287                size_t i = startingIndex; 
    286288                for (;;) 
    287289                    { 
    …… 
    297299                          } 
    298300                    } 
    299                 return uint.max; 
     301                return size_t.max; 
    300302        } 
    301303 
    …… 
    306308        ***********************************************************************/ 
    307309 
    308         final CircularList subset (uint from, uint length) 
     310        final CircularList subset (size_t from, size_t length) 
    309311        { 
    310312                Ref newlist = null; 
    …… 
    316318                   auto current = newlist = heap.allocate.set (p.value); 
    317319 
    318                    for (uint i = 1; i < length; ++i) 
     320                   for (size_t i = 1; i < length; ++i) 
    319321                       { 
    320322                       p = p.next; 
    …… 
    499501        ***********************************************************************/ 
    500502 
    501         final CircularList addAt (uint index, V element) 
     503        final CircularList addAt (size_t index, V element) 
    502504        { 
    503505                if (index is 0) 
    …… 
    517519        ***********************************************************************/ 
    518520 
    519         final CircularList replaceAt (uint index, V element) 
     521        final CircularList replaceAt (size_t index, V element) 
    520522        { 
    521523                cellAt(index).value = element; 
    …… 
    530532        ***********************************************************************/ 
    531533 
    532         final CircularList removeAt (uint index) 
     534        final CircularList removeAt (size_t index) 
    533535        { 
    534536                if (index is 0) 
    …… 
    549551        ***********************************************************************/ 
    550552 
    551         final uint remove (V element, bool all) 
     553        final size_t remove (V element, bool all) 
    552554        { 
    553555                auto c = count; 
    …… 
    594596        ***********************************************************************/ 
    595597 
    596         final uint replace (V oldElement, V newElement, bool all) 
    597         { 
    598                 uint c; 
     598        final size_t replace (V oldElement, V newElement, bool all) 
     599        { 
     600                size_t c; 
    599601                if (list) 
    600602                   { 
    …… 
    621623        ***********************************************************************/ 
    622624 
    623         final uint prepend (IContainer!(V) e) 
     625        final size_t prepend (IContainer!(V) e) 
    624626        { 
    625627                Ref hd = null; 
    …… 
    664666        ***********************************************************************/ 
    665667 
    666         final uint append (IContainer!(V) e) 
     668        final size_t append (IContainer!(V) e) 
    667669        { 
    668670                auto c = count; 
    …… 
    688690        ***********************************************************************/ 
    689691 
    690         final uint addAt (uint index, IContainer!(V) e) 
     692        final size_t addAt (size_t index, IContainer!(V) e) 
    691693        { 
    692694                auto c = count; 
    …… 
    712714        ***********************************************************************/ 
    713715 
    714         final uint removeRange (uint fromIndex, uint toIndex) 
     716        final size_t removeRange (size_t fromIndex, size_t toIndex) 
    715717        { 
    716718                auto p = cellAt (fromIndex); 
    717719                auto last = list.prev; 
    718720                auto c = count; 
    719                 for (uint i = fromIndex; i <= toIndex; ++i) 
     721                for (size_t i = fromIndex; i <= toIndex; ++i) 
    720722                    { 
    721723                    auto n = p.next; 
    …… 
    754756                    dst.length = count; 
    755757 
    756                 int i = 0; 
     758                size_t i = 0; 
    757759                foreach (v; this) 
    758760                         dst[i++] = v; 
    …… 
    785787                if (list) 
    786788                   { 
    787                    uint c = 0; 
     789                   size_t c = 0; 
    788790                   auto p = list; 
    789791                   do { 
    …… 
    806808        ***********************************************************************/ 
    807809 
    808         private uint instances (V element) 
     810        private size_t instances (V element) 
    809811        { 
    810812                if (list) 
    …… 
    818820        ***********************************************************************/ 
    819821 
    820         private void checkIndex (uint i) 
     822        private void checkIndex (size_t i) 
    821823        { 
    822824                if (i >= count) 
    …… 
    854856        ***********************************************************************/ 
    855857 
    856         private Ref cellAt (uint index) 
     858        private Ref cellAt (size_t index) 
    857859        { 
    858860                checkIndex (index); 
    …… 
    936938                                  prior; 
    937939                CircularList      owner; 
    938                 uint              mutation; 
     940                size_t            mutation; 
    939941 
    940942                /*************************************************************** 

  • branches/kris/combine/tango/util/container/Container.d

    r4312 r5064  
    3535        ***********************************************************************/ 
    3636         
    37         static int defaultInitialBuckets = 31; 
     37        static size_t defaultInitialBuckets = 31; 
    3838 
    3939        /*********************************************************************** 
    …… 
    7070        ***********************************************************************/ 
    7171 
    72         static uint hash(K) (K k, uint length) 
     72        static size_t hash(K) (K k, size_t length) 
    7373        { 
    7474                static if (is(K : int) || is(K : uint) ||  
    …… 
    7777                           is(K : byte) || is(K : ubyte) || 
    7878                           is(K : char) || is(K : wchar) || is (K : dchar)) 
    79                            return cast(uint) (k % length); 
     79                           return cast(size_t) (k % length); 
    8080                else 
    8181                   return (typeid(K).getHash(&k) & 0x7FFFFFFF) % length; 
    …… 
    107107                ***************************************************************/ 
    108108         
    109                 T*[] allocate (uint count) 
     109                T*[] allocate (size_t count) 
    110110                { 
    111111                        return new T*[count]; 
    …… 
    194194                ***************************************************************/ 
    195195         
    196                 T*[] allocate (uint count) 
     196                T*[] allocate (size_t count) 
    197197                { 
    198198                        return (cast(T**) calloc(count, (T*).sizeof)) [0 .. count]; 
    …… 
    273273                private T[]     list; 
    274274                private T[][]   lists; 
    275                 private int     index; 
    276                 private int     freelists; 
    277                 private int     presize = 0; 
    278                 private int     chunks = 1000; 
     275                private size_t     index; 
     276                private size_t     freelists; 
     277                private size_t     presize = 0; 
     278                private size_t     chunks = 1000; 
    279279 
    280280                private struct Discarded 
    …… 
    290290                ***************************************************************/ 
    291291         
    292                 void config (int chunks, int presize) 
     292                void config (size_t chunks, size_t presize) 
    293293                { 
    294294                        this.chunks = chunks; 
    …… 
    327327                ***************************************************************/ 
    328328         
    329                 T*[] allocate (uint count) 
     329                T*[] allocate (size_t count) 
    330330                { 
    331331                        return (cast(T**) calloc(count, (T*).sizeof)) [0 .. count]; 

  • branches/kris/combine/tango/util/container/HashMap.d

    r4312 r5064  
    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 
    …… 
    5252        V*   opIn_r (K key) 
    5353 
    54         uint size () 
     54        size_t size () 
    5555        bool isEmpty () 
    5656        V[] toArray (V[] dst) 
    …… 
    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() 
    …… 
    8383         
    8484        // number of elements contained 
    85         private uint               count; 
     85        private size_t             count; 
    8686 
    8787        // the threshold load factor 
    …… 
    9292         
    9393        // mutation tag updates on each change 
    94         private uint               mutation; 
     94        private size_t             mutation; 
    9595 
    9696        /*********************************************************************** 
    …… 
    170170        ***********************************************************************/ 
    171171 
    172         final uint size () 
     172        final size_t size () 
    173173        { 
    174174                return count; 
    …… 
    577577        ************************************************************************/ 
    578578 
    579         final uint remove (IContainer!(V) e, bool all = false) 
    580         { 
    581                 int i = count; 
     579        final size_t remove (IContainer!(V) e, bool all = false) 
     580        { 
     581                auto i = count; 
    582582                foreach (value; e) 
    583583                         remove (value, all); 
    …… 
    594594        ************************************************************************/ 
    595595 
    596         final uint remove (V element, bool all = false) 
     596        final size_t remove (V element, bool all = false) 
    597597        { 
    598598                auto i = count; 
    …… 
    643643        ************************************************************************/ 
    644644 
    645         final uint replace (V oldElement, V newElement, bool all = false) 
    646         { 
    647                 uint i; 
     645        final size_t replace (V oldElement, V newElement, bool all = false) 
     646        { 
     647                size_t i; 
    648648                 
    649649                if (count && oldElement != newElement) 
    …… 
    700700        ***********************************************************************/ 
    701701 
    702         final uint buckets () 
     702        final size_t buckets () 
    703703        { 
    704704                return table ? table.length : 0; 
    …… 
    716716        ***********************************************************************/ 
    717717 
    718         final void buckets (uint cap) 
     718        final void buckets (size_t cap) 
    719719        { 
    720720                if (cap < Container.defaultInitialBuckets) 
    …… 
    734734        ***********************************************************************/ 
    735735 
    736         final void buckets (uint cap, float threshold) 
     736        final void buckets (size_t cap, float threshold) 
    737737        { 
    738738                loadFactor = threshold; 
    739                 buckets (cast(int)(cap / threshold) + 1); 
     739                buckets (cast(size_t)(cap / threshold) + 1); 
    740740        } 
    741741 
    …… 
    792792                    dst.length = count; 
    793793 
    794                 int i = 0; 
     794                size_t i = 0; 
    795795                foreach (k, v; this) 
    796796                         dst[i++] = v; 
    …… 
    825825                if (table) 
    826826                   { 
    827                    int c = 0; 
    828                    for (int i=0; i < table.length; ++i) 
     827                   size_t c = 0; 
     828                   for (size_t i=0; i < table.length; ++i) 
    829829                        for (auto p = table[i]; p; p = p.next) 
    830830                            { 
    …… 
    850850        ***********************************************************************/ 
    851851 
    852         private uint instances (V element) 
    853         { 
    854                 uint c = 0; 
     852        private size_t instances (V element) 
     853        { 
     854                size_t c = 0; 
    855855                foreach (node; table) 
    856856                         if (node) 
    …… 
    871871                float ft = table.length; 
    872872                if (fc / ft > loadFactor) 
    873                     resize (2 * cast(int)(fc / loadFactor) + 1); 
     873                    resize (2 * cast(size_t)(fc / loadFactor) + 1); 
    874874                return this; 
    875875        } 
    …… 
    881881        ***********************************************************************/ 
    882882 
    883         private void resize (uint newCap) 
     883        private void resize (size_t newCap) 
    884884        { 
    885885                // Stdout.formatln ("resize {}", newCap); 
    …… 
    10061006        private struct Iterator 
    10071007        { 
    1008                 uint    row; 
     1008                size_t  row; 
    10091009                Ref     cell, 
    10101010                        prior; 
    10111011                Ref[]   table; 
    10121012                HashMap owner; 
    1013                 uint    mutation; 
     1013                size_t  mutation; 
    10141014 
    10151015                /*************************************************************** 

  • branches/kris/combine/tango/util/container/HashSet.d

    r4312 r5064  
    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) 
    …… 
    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) 
    …… 
    6969         
    7070        // number of elements contained 
    71         private uint            count; 
     71        private size_t          count; 
    7272 
    7373        // the threshold load factor 
    …… 
    7878         
    7979        // mutation tag updates on each change 
    80         private uint            mutation; 
     80        private size_t            mutation; 
    8181 
    8282        /*********************************************************************** 
    …… 
    146146        ***********************************************************************/ 
    147147 
    148         final uint size () 
     148        final size_t size () 
    149149        { 
    150150                return count; 
    …… 
    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; 
    …… 
    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; 
    …… 
    352352        ************************************************************************/ 
    353353 
    354         public uint remove (IContainer!(V) e) 
    355         { 
    356                 uint c; 
     354        public size_t remove (IContainer!(V) e) 
     355        { 
     356                size_t c; 
    357357                foreach (value; e) 
    358358                         if (remove (value)) 
    …… 
    401401        ***********************************************************************/ 
    402402 
    403         final uint buckets () 
     403        final size_t buckets () 
    404404        { 
    405405                return table ? table.length : 0; 
    …… 
    414414        ***********************************************************************/ 
    415415 
    416         final void buckets (uint cap) 
     416        final void buckets (size_t cap) 
    417417        { 
    418418                if (cap < Container.defaultInitialBuckets) 
    …… 
    469469                    dst.length = count; 
    470470 
    471                 int i = 0; 
     471                size_t i = 0; 
    472472                foreach (v; this) 
    473473                         dst[i++] = v; 
    …… 
    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) 
    …… 
    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 
    …… 
    549549        ***********************************************************************/ 
    550550 
    551         private void resize (uint newCap) 
     551        private void resize (size_t newCap) 
    552552        { 
    553553                //Stdout.formatln ("resize {}", newCap); 
    …… 
    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]; 
    …… 
    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                /*************************************************************** 

  • branches/kris/combine/tango/util/container/LinkedList.d

    r4312 r5064  
    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) 
    51  
    52         V get (uint index) 
     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) 
     51 
     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) 
    …… 
    8686 
    8787        // number of elements contained 
    88         private uint            count; 
     88        private size_t          count; 
    8989 
    9090        // configured heap manager 
    …… 
    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 
    …… 
    114114        ***********************************************************************/ 
    115115 
    116         protected this (Ref l, int c) 
     116        protected this (Ref l, size_t c) 
    117117        { 
    118118                list = l; 
    …… 
    174174        ***********************************************************************/ 
    175175 
    176         final uint size () 
     176        final size_t size () 
    177177        { 
    178178                return count; 
    …… 
    233233        ***********************************************************************/ 
    234234 
    235         final V get (uint index) 
     235        final V get (size_t index) 
    236236        { 
    237237                return cellAt(index).value; 
    …… 
    241241 
    242242                 Time complexity: O(n) 
    243  
    244         ***********************************************************************/ 
    245  
    246         final uint first (V value, uint startingIndex = 0) 
     243                 Returns size_t.max if no element found. 
     244 
     245        ***********************************************************************/ 
     246 
     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) 
    …… 
    259260                       return i + startingIndex; 
    260261                   } 
    261                 return uint.max; 
     262                return size_t.max; 
    262263        } 
    263264 
    …… 
    265266 
    266267                 Time complexity: O(n) 
    267  
    268         ***********************************************************************/ 
    269  
    270         final uint last (V value, uint startingIndex = 0) 
     268                 Returns size_t.max if no element found. 
     269 
     270        ***********************************************************************/ 
     271 
     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; 
    …… 
    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) 
    …… 
    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; 
    …… 
    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; 
    …… 
    454456        ***********************************************************************/ 
    455457 
    456         final uint replace (V oldElement, V newElement, bool all = false) 
    457         { 
    458                 uint c; 
     458        final size_t replace (V oldElement, V newElement, bool all = false) 
     459        { 
     460                size_t c; 
    459461                if (count && oldElement != newElement) 
    460462                   { 
    …… 
    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) 
    …… 
    585587        ***********************************************************************/ 
    586588 
    587         final LinkedList removeAt (uint index) 
     589        final LinkedList removeAt (size_t index) 
    588590        { 
    589591                if (index is 0) 
    …… 
    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; 
    …… 
    618620        ***********************************************************************/ 
    619621 
    620         final uint prepend (IContainer!(V) e) 
     622        final size_t prepend (IContainer!(V) e) 
    621623        { 
    622624                auto c = count; 
    …… 
    631633        ***********************************************************************/ 
    632634 
    633         final uint append (IContainer!(V) e) 
     635        final size_t append (IContainer!(V) e) 
    634636        { 
    635637                auto c = count; 
    …… 
    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; 
    …… 
    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; 
    …… 
    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; 
    …… 
    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; 
    …… 
    710712                    dst.length = count; 
    711713 
    712                 int i = 0; 
     714                size_t i = 0; 
    713715                foreach (v; this) 
    714716                         dst[i++] = v; 
    …… 
    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                    { 
    …… 
    755757        ***********************************************************************/ 
    756758 
    757         private uint instances (V value) 
     759        private size_t instances (V value) 
    758760        { 
    759761                if (count is 0) 
    …… 
    787789        ***********************************************************************/ 
    788790 
    789         private Ref cellAt (uint index) 
     791        private Ref cellAt (size_t index) 
    790792        { 
    791793                checkIndex (index); 
    …… 
    797799        ***********************************************************************/ 
    798800 
    799         private void checkIndex (uint index) 
     801        private void checkIndex (size_t index) 
    800802        { 
    801803                if (index >= count) 
    …… 
    916918                                prior; 
    917919                LinkedList      owner; 
    918                 uint            mutation; 
     920                size_t          mutation; 
    919921 
    920922                /*************************************************************** 

  • branches/kris/combine/tango/util/container/SortedMap.d

    r4312 r5064  
    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) 
    …… 
    5555        V*   opIn_r (K key) 
    5656 
    57         uint size () 
     57        size_t size () 
    5858        bool isEmpty () 
    5959        V[] toArray (V[] dst) 
    …… 
    8787        private Compare!(V)             cmpElem; 
    8888 
    89         private int                     count, 
     89        private size_t                  count, 
    9090                                        mutation; 
    9191 
    …… 
    108108        ***********************************************************************/ 
    109109 
    110         private this (Comparator c, int n) 
     110        private this (Comparator c, size_t n) 
    111111        {        
    112112                count = n; 
    …… 
    177177        ***********************************************************************/ 
    178178 
    179         final uint size () 
     179        final size_t size () 
    180180        { 
    181181                return count; 
    …… 
    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; 
    …… 
    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                   { 
    …… 
    477477        ***********************************************************************/ 
    478478 
    479         final uint replace (V oldElement, V newElement, bool all = false) 
    480         { 
    481                 uint c; 
     479        final size_t replace (V oldElement, V newElement, bool all = false) 
     480        { 
     481                size_t c; 
    482482 
    483483                if (count) 
    …… 
    637637                    dst.length = count; 
    638638 
    639                 int i = 0; 
     639                size_t i = 0; 
    640640                foreach (k, v; this) 
    641641                         dst[i++] = v; 
    …… 
    701701        ***********************************************************************/ 
    702702 
    703         private uint instances (V value) 
     703        private size_t instances (V value) 
    704704        { 
    705705                if (count is 0) 
    …… 
    895895                                  prior; 
    896896                SortedMap         owner; 
    897                 uint              mutation; 
     897                size_t            mutation; 
    898898 
    899899                /*************************************************************** 

  • branches/kris/combine/tango/util/container/model/IContainer.d

    r4008 r5064  
    2323interface IContainer (V) 
    2424{ 
    25         uint size (); 
     25        size_t size (); 
    2626 
    2727        bool isEmpty (); 
    …… 
    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 
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