Changeset 496

Show
Ignore:
Timestamp:
11/18/07 19:56:51 (1 year ago)
Author:
andrei
Message:

Scheduled for deprecation

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • candidate/phobos/std/bitarray.d

    r294 r496  
    22 
    33/*********************** 
     4 * Scheduled for deprecation. Use $(LINK2 
     5 * std_bitmanip.html,std.bitmanip) instead. 
     6 * 
    47 * Macros: 
    58 *  WIKI = StdBitarray 
    …… 
    710 
    811module std.bitarray; 
    9  
    10 //debug = bitarray;     // uncomment to turn on debugging printf's 
    11  
    12 private import std.intrinsic; 
    13  
    14 /** 
    15  * An array of bits. 
    16  */ 
    17  
    18 struct BitArray 
    19 { 
    20     size_t len; 
    21     uint* ptr; 
    22  
    23     size_t dim() 
    24     { 
    25     return (len + 31) / 32; 
    26     } 
    27  
    28     size_t length() 
    29     { 
    30     return len; 
    31     } 
    32  
    33     void length(size_t newlen) 
    34     { 
    35     if (newlen != len) 
    36     { 
    37         size_t olddim = dim(); 
    38         size_t newdim = (newlen + 31) / 32; 
    39  
    40         if (newdim != olddim) 
    41         { 
    42         // Create a fake array so we can use D's realloc machinery 
    43         uint[] b = ptr[0 .. olddim]; 
    44         b.length = newdim;      // realloc 
    45         ptr = b.ptr; 
    46         if (newdim & 31) 
    47         {   // Set any pad bits to 0 
    48             ptr[newdim - 1] &= ~(~0 << (newdim & 31)); 
    49         } 
    50         } 
    51  
    52         len = newlen; 
    53     } 
    54     } 
    55  
    56     /********************************************** 
    57      * Support for [$(I index)] operation for BitArray. 
    58      */ 
    59     bool opIndex(size_t i) 
    60     in 
    61     { 
    62     assert(i < len); 
    63     } 
    64     body 
    65     { 
    66     return cast(bool)bt(ptr, i); 
    67     } 
    68  
    69     /** ditto */ 
    70     bool opIndexAssign(bool b, size_t i) 
    71     in 
    72     { 
    73     assert(i < len); 
    74     } 
    75     body 
    76     { 
    77     if (b) 
    78         bts(ptr, i); 
    79     else 
    80         btr(ptr, i); 
    81     return b; 
    82     } 
    83  
    84     /********************************************** 
    85      * Support for array.dup property for BitArray. 
    86      */ 
    87     BitArray dup() 
    88     { 
    89     BitArray ba; 
    90  
    91     uint[] b = ptr[0 .. dim].dup; 
    92     ba.len = len; 
    93     ba.ptr = b.ptr; 
    94     return ba; 
    95     } 
    96  
    97     unittest 
    98     { 
    99     BitArray a; 
    100     BitArray b; 
    101     int i; 
    102  
    103     debug(bitarray) printf("BitArray.dup.unittest\n"); 
    104  
    105     a.length = 3; 
    106     a[0] = 1; a[1] = 0; a[2] = 1; 
    107     b = a.dup; 
    108     assert(b.length == 3); 
    109     for (i = 0; i < 3; i++) 
    110     {   debug(bitarray) printf("b[%d] = %d\n", i, b[i]); 
    111         assert(b[i] == (((i ^ 1) & 1) ? true : false)); 
    112     } 
    113     } 
    114  
    115     /********************************************** 
    116      * Support for foreach loops for BitArray. 
    117      */ 
    118     int opApply(int delegate(inout bool) dg) 
    119     { 
    120     int result; 
    121  
    122     for (size_t i = 0; i < len; i++) 
    123     {   bool b = opIndex(i); 
    124         result = dg(b); 
    125         (*this)[i] = b; 
    126         if (result) 
    127         break; 
    128     } 
    129     return result; 
    130     } 
    131  
    132     /** ditto */ 
    133     int opApply(int delegate(inout size_t, inout bool) dg) 
    134     { 
    135     int result; 
    136  
    137     for (size_t i = 0; i < len; i++) 
    138     {   bool b = opIndex(i); 
    139         result = dg(i, b); 
    140         (*this)[i] = b; 
    141         if (result) 
    142         break; 
    143     } 
    144     return result; 
    145     } 
    146  
    147     unittest 
    148     { 
    149     debug(bitarray) printf("BitArray.opApply unittest\n"); 
    150  
    151     static bool[] ba = [1,0,1]; 
    152  
    153     BitArray a; a.init(ba); 
    154  
    155     int i; 
    156     foreach (b;a) 
    157     { 
    158         switch (i) 
    159         {   case 0: assert(b == true); break; 
    160         case 1: assert(b == false); break; 
    161         case 2: assert(b == true); break; 
    162         default: assert(0); 
    163         } 
    164         i++; 
    165     } 
    166  
    167     foreach (j,b;a) 
    168     { 
    169         switch (j) 
    170         {   case 0: assert(b == true); break; 
    171         case 1: assert(b == false); break; 
    172         case 2: assert(b == true); break; 
    173         default: assert(0); 
    174         } 
    175     } 
    176     } 
    177  
    178  
    179     /********************************************** 
    180      * Support for array.reverse property for BitArray. 
    181      */ 
    182  
    183     BitArray reverse() 
    184     out (result) 
    185     { 
    186         assert(result == *this); 
    187     } 
    188     body 
    189     { 
    190         if (len >= 2) 
    191         { 
    192         bool t; 
    193         size_t lo, hi; 
    194  
    195         lo = 0; 
    196         hi = len - 1; 
    197         for (; lo < hi; lo++, hi--) 
    198         { 
    199             t = (*this)[lo]; 
    200             (*this)[lo] = (*this)[hi]; 
    201             (*this)[hi] = t; 
    202         } 
    203         } 
    204         return *this; 
    205     } 
    206  
    207     unittest 
    208     { 
    209     debug(bitarray) printf("BitArray.reverse.unittest\n"); 
    210  
    211     BitArray b; 
    212     static bool[5] data = [1,0,1,1,0]; 
    213     int i; 
    214  
    215     b.init(data); 
    216     b.reverse; 
    217     for (i = 0; i < data.length; i++) 
    218     { 
    219         assert(b[i] == data[4 - i]); 
    220     } 
    221     } 
    222  
    223  
    224     /********************************************** 
    225      * Support for array.sort property for BitArray. 
    226      */ 
    227  
    228     BitArray sort() 
    229     out (result) 
    230     { 
    231         assert(result == *this); 
    232     } 
    233     body 
    234     { 
    235         if (len >= 2) 
    236         { 
    237         size_t lo, hi; 
    238  
    239         lo = 0; 
    240         hi = len - 1; 
    241         while (1) 
    242         { 
    243             while (1) 
    244             { 
    245             if (lo >= hi) 
    246                 goto Ldone; 
    247             if ((*this)[lo] == true) 
    248                 break; 
    249             lo++; 
    250             } 
    251  
    252             while (1) 
    253             { 
    254             if (lo >= hi) 
    255                 goto Ldone; 
    256             if ((*this)[hi] == false) 
    257                 break; 
    258             hi--; 
    259             } 
    260  
    261             (*this)[lo] = false; 
    262             (*this)[hi] = true; 
    263  
    264             lo++; 
    265             hi--; 
    266         } 
    267         Ldone: 
    268         ; 
    269         } 
    270         return *this; 
    271     } 
    272  
    273     unittest 
    274     { 
    275     debug(bitarray) printf("BitArray.sort.unittest\n"); 
    276  
    277     static uint x = 0b1100011000; 
    278     static BitArray ba = { 10, &x }; 
    279     ba.sort; 
    280     for (size_t i = 0; i < 6; i++) 
    281         assert(ba[i] == false); 
    282     for (size_t i = 6; i < 10; i++) 
    283         assert(ba[i] == true); 
    284     } 
    285  
    286  
    287     /*************************************** 
    288      * Support for operators == and != for bit arrays. 
    289      */ 
    290  
    291     int opEquals(BitArray a2) 
    292     {   int i; 
    293  
    294     if (this.length != a2.length) 
    295         return 0;       // not equal 
    296     byte *p1 = cast(byte*)this.ptr; 
    297     byte *p2 = cast(byte*)a2.ptr; 
    298     uint n = this.length / 8; 
    299     for (i = 0; i < n; i++) 
    300     { 
    301         if (p1[i] != p2[i]) 
    302         return 0;       // not equal 
    303     } 
    304  
    305     ubyte mask; 
    306  
    307     n = this.length & 7; 
    308     mask = cast(ubyte)((1 << n) - 1); 
    309     //printf("i = %d, n = %d, mask = %x, %x, %x\n", i, n, mask, p1[i], p2[i]); 
    310     return (mask == 0) || (p1[i] & mask) == (p2[i] & mask); 
    311     } 
    312  
    313     unittest 
    314     { 
    315     debug(bitarray) printf("BitArray.opEquals unittest\n"); 
    316  
    317     static bool[] ba = [1,0,1,0,1]; 
    318     static bool[] bb = [1,0,1]; 
    319     static bool[] bc = [1,0,1,0,1,0,1]; 
    320     static bool[] bd = [1,0,1,1,1]; 
    321     static bool[] be = [1,0,1,0,1]; 
    322  
    323     BitArray a; a.init(ba); 
    324     BitArray b; b.init(bb); 
    325     BitArray c; c.init(bc); 
    326     BitArray d; d.init(bd); 
    327     BitArray e; e.init(be); 
    328  
    329     assert(a != b); 
    330     assert(a != c); 
    331     assert(a != d); 
    332     assert(a == e); 
    333     } 
    334  
    335     /*************************************** 
    336      * Implement comparison operators. 
    337      */ 
    338  
    339     int opCmp(BitArray a2) 
    340     { 
    341     uint len; 
    342     uint i; 
    343  
    344     len = this.length; 
    345     if (a2.length < len) 
    346         len = a2.length; 
    347     ubyte* p1 = cast(ubyte*)this.ptr; 
    348     ubyte* p2 = cast(ubyte*)a2.ptr; 
    349     uint n = len / 8; 
    350     for (i = 0; i < n; i++) 
    351     { 
    352         if (p1[i] != p2[i]) 
    353         break;      // not equal 
    354     } 
    355     for (uint j = i * 8; j < len; j++) 
    356     {   ubyte mask = cast(ubyte)(1 << j); 
    357         int c; 
    358  
    359         c = cast(int)(p1[i] & mask) - cast(int)(p2[i] & mask); 
    360         if (c) 
    361         return c; 
    362     } 
    363     return cast(int)this.len - cast(int)a2.length; 
    364     } 
    365  
    366     unittest 
    367     { 
    368     debug(bitarray) printf("BitArray.opCmp unittest\n"); 
    369  
    370     static bool[] ba = [1,0,1,0,1]; 
    371     static bool[] bb = [1,0,1]; 
    372     static bool[] bc = [1,0,1,0,1,0,1]; 
    373     static bool[] bd = [1,0,1,1,1]; 
    374     static bool[] be = [1,0,1,0,1]; 
    375  
    376     BitArray a; a.init(ba); 
    377     BitArray b; b.init(bb); 
    378     BitArray c; c.init(bc); 
    379     BitArray d; d.init(bd); 
    380     BitArray e; e.init(be); 
    381  
    382     assert(a >  b); 
    383     assert(a >= b); 
    384     assert(a <  c); 
    385     assert(a <= c); 
    386     assert(a <  d); 
    387     assert(a <= d); 
    388     assert(a == e); 
    389     assert(a <= e); 
    390     assert(a >= e); 
    391     } 
    392  
    393     /*************************************** 
    394      * Set BitArray to contents of ba[] 
    395      */ 
    396  
    397     void init(bool[] ba) 
    398     { 
    399     length = ba.length; 
    400     foreach (i, b; ba) 
    401     { 
    402         (*this)[i] = b; 
    403     } 
    404     } 
    405  
    406  
    407     /*************************************** 
    408      * Map BitArray onto v[], with numbits being the number of bits 
    409      * in the array. Does not copy the data. 
    410      * 
    411      * This is the inverse of opCast. 
    412      */ 
    413     void init(void[] v, size_t numbits) 
    414     in 
    415     { 
    416     assert(numbits <= v.length * 8); 
    417     assert((v.length & 3) == 0); 
    418     } 
    419     body 
    420     { 
    421     ptr = cast(uint*)v.ptr; 
    422     len = numbits; 
    423     } 
    424  
    425     unittest 
    426     { 
    427     debug(bitarray) printf("BitArray.init unittest\n"); 
    428  
    429     static bool[] ba = [1,0,1,0,1]; 
    430  
    431     BitArray a; a.init(ba); 
    432     BitArray b; 
    433     void[] v; 
    434  
    435     v = cast(void[])a; 
    436     b.init(v, a.length); 
    437  
    438     assert(b[0] == 1); 
    439     assert(b[1] == 0); 
    440     assert(b[2] == 1); 
    441     assert(b[3] == 0); 
    442     assert(b[4] == 1); 
    443  
    444     a[0] = 0; 
    445     assert(b[0] == 0); 
    446  
    447     assert(a == b); 
    448     } 
    449  
    450     /*************************************** 
    451      * Convert to void[]. 
    452      */ 
    453     void[] opCast() 
    454     { 
    455     return cast(void[])ptr[0 .. dim]; 
    456     } 
    457  
    458     unittest 
    459     { 
    460     debug(bitarray) printf("BitArray.opCast unittest\n"); 
    461  
    462     static bool[] ba = [1,0,1,0,1]; 
    463  
    464     BitArray a; a.init(ba); 
    465     void[] v = cast(void[])a; 
    466  
    467     assert(v.length == a.dim * uint.sizeof); 
    468     } 
    469  
    470     /*************************************** 
    471      * Support for unary operator ~ for bit arrays. 
    472      */ 
    473     BitArray opCom() 
    474     { 
    475     auto dim = this.dim(); 
    476  
    477     BitArray result; 
    478  
    479     result.length = len; 
    480     for (size_t i = 0; i < dim; i++) 
    481         result.ptr[i] = ~this.ptr[i]; 
    482     if (len & 31) 
    483         result.ptr[dim - 1] &= ~(~0 << (len & 31)); 
    484     return result; 
    485     } 
    486  
    487     unittest 
    488     { 
    489     debug(bitarray) printf("BitArray.opCom unittest\n"); 
    490  
    491     static bool[] ba = [1,0,1,0,1]; 
    492  
    493     BitArray a; a.init(ba); 
    494     BitArray b = ~a; 
    495  
    496     assert(b[0] == 0); 
    497     assert(b[1] == 1); 
    498     assert(b[2] == 0); 
    499     assert(b[3] == 1); 
    500     assert(b[4] == 0); 
    501     } 
    502  
    503  
    504     /*************************************** 
    505      * Support for binary operator & for bit arrays. 
    506      */ 
    507     BitArray opAnd(BitArray e2) 
    508     in 
    509     { 
    510     assert(len == e2.length); 
    511     } 
    512     body 
    513     { 
    514     auto dim = this.dim(); 
    515  
    516     BitArray result; 
    517  
    518     result.length = len; 
    519     for (size_t i = 0; i < dim; i++) 
    520         result.ptr[i] = this.ptr[i] & e2.ptr[i]; 
    521     return result; 
    522     } 
    523  
    524     unittest 
    525     { 
    526     debug(bitarray) printf("BitArray.opAnd unittest\n"); 
    527  
    528     static bool[] ba = [1,0,1,0,1]; 
    529     static bool[] bb = [1,0,1,1,0]; 
    530  
    531     BitArray a; a.init(ba); 
    532     BitArray b; b.init(bb); 
    533  
    534     BitArray c = a & b; 
    535  
    536     assert(c[0] == 1); 
    537     assert(c[1] == 0); 
    538     assert(c[2] == 1); 
    539     assert(c[3] == 0); 
    540     assert(c[4] == 0); 
    541     } 
    542  
    543  
    544     /*************************************** 
    545      * Support for binary operator | for bit arrays. 
    546      */ 
    547     BitArray opOr(BitArray e2) 
    548     in 
    549     { 
    550     assert(len == e2.length); 
    551     } 
    552     body 
    553     { 
    554     auto dim = this.dim(); 
    555  
    556     BitArray result; 
    557  
    558     result.length = len; 
    559     for (size_t i = 0; i < dim; i++) 
    560         result.ptr[i] = this.ptr[i] | e2.ptr[i]; 
    561     return result; 
    562     } 
    563  
    564     unittest 
    565     { 
    566     debug(bitarray) printf("BitArray.opOr unittest\n"); 
    567  
    568     static bool[] ba = [1,0,1,0,1]; 
    569     static bool[] bb = [1,0,1,1,0]; 
    570  
    571     BitArray a; a.init(ba); 
    572     BitArray b; b.init(bb); 
    573  
    574     BitArray c = a | b; 
    575  
    576     assert(c[0] == 1); 
    577     assert(c[1] == 0); 
    578     assert(c[2] == 1); 
    579     assert(c[3] == 1); 
    580     assert(c[4] == 1); 
    581     } 
    582  
    583  
    584     /*************************************** 
    585      * Support for binary operator ^ for bit arrays. 
    586      */ 
    587     BitArray opXor(BitArray e2) 
    588     in 
    589     { 
    590     assert(len == e2.length); 
    591     } 
    592     body 
    593     { 
    594     auto dim = this.dim(); 
    595  
    596     BitArray result; 
    597  
    598     result.length = len; 
    599     for (size_t i = 0; i < dim; i++) 
    600         result.ptr[i] = this.ptr[i] ^ e2.ptr[i]; 
    601     return result; 
    602     } 
    603  
    604     unittest 
    605     { 
    606     debug(bitarray) printf("BitArray.opXor unittest\n"); 
    607  
    608     static bool[] ba = [1,0,1,0,1]; 
    609     static bool[] bb = [1,0,1,1,0]; 
    610  
    611     BitArray a; a.init(ba); 
    612     BitArray b; b.init(bb); 
    613  
    614     BitArray c = a ^ b; 
    615  
    616     assert(c[0] == 0); 
    617     assert(c[1] == 0); 
    618     assert(c[2] == 0); 
    619     assert(c[3] == 1); 
    620     assert(c[4] == 1); 
    621     } 
    622  
    623  
    624     /*************************************** 
    625      * Support for binary operator - for bit arrays. 
    626      * 
    627      * $(I a - b) for BitArrays means the same thing as $(I a &amp; ~b). 
    628      */ 
    629     BitArray opSub(BitArray e2) 
    630     in 
    631     { 
    632     assert(len == e2.length); 
    633     } 
    634     body 
    635     { 
    636     auto dim = this.dim(); 
    637  
    638     BitArray result; 
    639  
    640     result.length = len; 
    641     for (size_t i = 0; i < dim; i++) 
    642         result.ptr[i] = this.ptr[i] & ~e2.ptr[i]; 
    643     return result; 
    644     } 
    645  
    646     unittest 
    647     { 
    648     debug(bitarray) printf("BitArray.opSub unittest\n"); 
    649  
    650     static bool[] ba = [1,0,1,0,1]; 
    651     static bool[] bb = [1,0,1,1,0]; 
    652  
    653     BitArray a; a.init(ba); 
    654     BitArray b; b.init(bb); 
    655  
    656     BitArray c = a - b; 
    657  
    658     assert(c[0] == 0); 
    659     assert(c[1] == 0); 
    660     assert(c[2] == 0); 
    661     assert(c[3] == 0); 
    662     assert(c[4] == 1); 
    663     } 
    664  
    665  
    666     /*************************************** 
    667      * Support for operator &= bit arrays. 
    668      */ 
    669     BitArray opAndAssign(BitArray e2) 
    670     in 
    671     { 
    672     assert(len == e2.length); 
    673     } 
    674     body 
    675     { 
    676     auto dim = this.dim(); 
    677  
    678     for (size_t i = 0; i < dim; i++) 
    679         ptr[i] &= e2.ptr[i]; 
    680     return *this; 
    681     } 
    682  
    683     unittest 
    684     { 
    685     debug(bitarray) printf("BitArray.opAndAssign unittest\n"); 
    686  
    687     static bool[] ba = [1,0,1,0,1]; 
    688     static bool[] bb = [1,0,1,1,0]; 
    689  
    690     BitArray a; a.init(ba); 
    691     BitArray b; b.init(bb); 
    692  
    693     a &= b; 
    694     assert(a[0] == 1); 
    695     assert(a[1] == 0); 
    696     assert(a[2] == 1); 
    697     assert(a[3] == 0); 
    698     assert(a[4] == 0); 
    699     } 
    700  
    701  
    702     /*************************************** 
    703      * Support for operator |= for bit arrays. 
    704      */ 
    705     BitArray opOrAssign(BitArray e2) 
    706     in 
    707     { 
    708     assert(len == e2.length); 
    709     } 
    710     body 
    711     { 
    712     auto dim = this.dim(); 
    713  
    714     for (size_t i = 0; i < dim; i++) 
    715         ptr[i] |= e2.ptr[i]; 
    716     return *this; 
    717     } 
    718  
    719     unittest 
    720     { 
    721     debug(bitarray) printf("BitArray.opOrAssign unittest\n"); 
    722  
    723     static bool[] ba = [1,0,1,0,1]; 
    724     static bool[] bb = [1,0,1,1,0]; 
    725  
    726     BitArray a; a.init(ba); 
    727     BitArray b; b.init(bb); 
    728  
    729     a |= b; 
    730     assert(a[0] == 1); 
    731     assert(a[1] == 0); 
    732     assert(a[2] == 1); 
    733     assert(a[3] == 1); 
    734     assert(a[4] == 1); 
    735     } 
    736  
    737     /*************************************** 
    738      * Support for operator ^= for bit arrays. 
    739      */ 
    740     BitArray opXorAssign(BitArray e2) 
    741     in 
    742     { 
    743     assert(len == e2.length); 
    744     } 
    745     body 
    746     { 
    747     auto dim = this.dim(); 
    748  
    749     for (size_t i = 0; i < dim; i++) 
    750         ptr[i] ^= e2.ptr[i]; 
    751     return *this; 
    752     } 
    753  
    754     unittest 
    755     { 
    756     debug(bitarray) printf("BitArray.opXorAssign unittest\n"); 
    757  
    758     static bool[] ba = [1,0,1,0,1]; 
    759     static bool[] bb = [1,0,1,1,0]; 
    760  
    761     BitArray a; a.init(ba); 
    762     BitArray b; b.init(bb); 
    763  
    764     a ^= b; 
    765     assert(a[0] == 0); 
    766     assert(a[1] == 0); 
    767     assert(a[2] == 0); 
    768     assert(a[3] == 1); 
    769     assert(a[4] == 1); 
    770     } 
    771  
    772     /*************************************** 
    773      * Support for operator -= for bit arrays. 
    774      * 
    775      * $(I a -= b) for BitArrays means the same thing as $(I a &amp;= ~b). 
    776      */ 
    777     BitArray opSubAssign(BitArray e2) 
    778     in 
    779     { 
    780     assert(len == e2.length); 
    781     } 
    782     body 
    783     { 
    784     auto dim = this.dim(); 
    785  
    786     for (size_t i = 0; i < dim; i++) 
    787         ptr[i] &= ~e2.ptr[i]; 
    788     return *this; 
    789     } 
    790  
    791     unittest 
    792     { 
    793     debug(bitarray) printf("BitArray.opSubAssign unittest\n"); 
    794  
    795     static bool[] ba = [1,0,1,0,1]; 
    796     static bool[] bb = [1,0,1,1,0]; 
    797  
    798     BitArray a; a.init(ba); 
    799     BitArray b; b.init(bb); 
    800  
    801     a -= b; 
    802     assert(a[0] == 0); 
    803     assert(a[1] == 0); 
    804     assert(a[2] == 0); 
    805     assert(a[3] == 0); 
    806     assert(a[4] == 1); 
    807     } 
    808  
    809     /*************************************** 
    810      * Support for operator ~= for bit arrays. 
    811      */ 
    812  
    813     BitArray opCatAssign(bool b) 
    814     { 
    815     length = len + 1; 
    816     (*this)[len - 1] = b; 
    817     return *this; 
    818     } 
    819  
    820     unittest 
    821     { 
    822     debug(bitarray) printf("BitArray.opCatAssign unittest\n"); 
    823  
    824     static bool[] ba = [1,0,1,0,1]; 
    825  
    826     BitArray a; a.init(ba); 
    827     BitArray b; 
    828  
    829     b = (a ~= true); 
    830     assert(a[0] == 1); 
    831     assert(a[1] == 0); 
    832     assert(a[2] == 1); 
    833     assert(a[3] == 0); 
    834     assert(a[4] == 1); 
    835     assert(a[5] == 1); 
    836  
    837     assert(b == a); 
    838     } 
    839  
    840     /*************************************** 
    841      * ditto 
    842      */ 
    843  
    844     BitArray opCatAssign(BitArray b) 
    845     { 
    846     auto istart = len; 
    847     length = len + b.length; 
    848     for (auto i = istart; i < len; i++) 
    849         (*this)[i] = b[i - istart]; 
    850     return *this; 
    851     } 
    852  
    853     unittest 
    854     { 
    855     debug(bitarray) printf("BitArray.opCatAssign unittest\n"); 
    856  
    857     static bool[] ba = [1,0]; 
    858     static bool[] bb = [0,1,0]; 
    859  
    860     BitArray a; a.init(ba); 
    861     BitArray b; b.init(bb); 
    862     BitArray c; 
    863  
    864     c = (a ~= b); 
    865     assert(a.length == 5); 
    866     assert(a[0] == 1); 
    867     assert(a[1] == 0); 
    868     assert(a[2] == 0); 
    869     assert(a[3] == 1); 
    870     assert(a[4] == 0); 
    871  
    872     assert(c == a); 
    873     } 
    874  
    875     /*************************************** 
    876      * Support for binary operator ~ for bit arrays. 
    877      */ 
    878     BitArray opCat(bool b) 
    879     { 
    880     BitArray r; 
    881  
    882     r = this.dup; 
    883     r.length = len + 1; 
    884     r[len] = b; 
    885     return r; 
    886     } 
    887  
    888     /** ditto */ 
    889     BitArray opCat_r(bool b) 
    890     { 
    891     BitArray r; 
    892  
    893     r.length = len + 1; 
    894     r[0] = b; 
    895     for (size_t i = 0; i < len; i++) 
    896         r[1 + i] = (*this)[i]; 
    897     return r; 
    898     } 
    899  
    900     /** ditto */ 
    901     BitArray opCat(BitArray b) 
    902     { 
    903     BitArray r; 
    904  
    905     r = this.dup(); 
    906     r ~= b; 
    907     return r; 
    908     } 
    909  
    910     unittest 
    911     { 
    912     debug(bitarray) printf("BitArray.opCat unittest\n"); 
    913  
    914     static bool[] ba = [1,0]; 
    915     static bool[] bb = [0,1,0]; 
    916  
    917     BitArray a; a.init(ba); 
    918     BitArray b; b.init(bb); 
    919     BitArray c; 
    920  
    921     c = (a ~ b); 
    922     assert(c.length == 5); 
    923     assert(c[0] == 1); 
    924     assert(c[1] == 0); 
    925     assert(c[2] == 0); 
    926     assert(c[3] == 1); 
    927     assert(c[4] == 0); 
    928  
    929     c = (a ~ true); 
    930     assert(c.length == 3); 
    931     assert(c[0] == 1); 
    932     assert(c[1] == 0); 
    933     assert(c[2] == 1); 
    934  
    935     c = (false ~ a); 
    936     assert(c.length == 3); 
    937     assert(c[0] == 0); 
    938     assert(c[1] == 1); 
    939     assert(c[2] == 0); 
    940     } 
    941 } 
     12public import std.bitmanip;