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

Changeset 2838

Show
Ignore:
Timestamp:
11/09/07 23:42:40 (1 year ago)
Author:
schveiguy
Message:

Array had issues with arrays of delegates being casted to const

Variant is updated to use const

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • branches/experimental/D2.0/tango/core/Array.d

    r2836 r2838  
    5353        alias typeof(T[0]) ElemTypeOf; 
    5454    } 
     55 
     56    // 
     57    // this was added to fix issue with delegates.  A delegate is the one type 
     58    // which cannot be converted to a const delegate, because the signatures 
     59    // are different. 
     60    // 
     61    template ConstArrayOf( T ) 
     62    { 
     63        static if( is( T == delegate ) ) 
     64          alias T[] ConstArrayOf; 
     65        else 
     66          alias const(T)[] ConstArrayOf; 
     67    } 
    5568} 
    5669 
    …… 
    107120        static assert( isCallableType!(Pred) ); 
    108121 
    109  
    110         size_t fn( const(Elem)[] buf, Elem pat, Pred pred = Pred.init ) 
     122        alias ConstArrayOf!(Elem) EA; 
     123 
     124 
     125        size_t fn( EA buf, Elem pat, Pred pred = Pred.init ) 
    111126        { 
    112127            foreach( size_t pos, Elem cur; buf ) 
    …… 
    119134 
    120135 
    121         size_t fn( const(Elem)[] buf, const(Elem)[] pat, Pred pred = Pred.init ) 
     136        size_t fn( EA buf, EA pat, Pred pred = Pred.init ) 
    122137        { 
    123138            if( buf.length == 0 || 
    …… 
    256271        static assert( isCallableType!(Pred) ); 
    257272 
    258  
    259         size_t fn( const(Elem)[] buf, Elem pat, Pred pred = Pred.init ) 
     273        alias ConstArrayOf!(Elem) EA; 
     274 
     275        size_t fn( EA buf, Elem pat, Pred pred = Pred.init ) 
    260276        { 
    261277            if( buf.length == 0 ) 
    …… 
    273289 
    274290 
    275         size_t fn( const(Elem)[] buf, const(Elem)[] pat, Pred pred = Pred.init ) 
     291        size_t fn( EA buf, EA pat, Pred pred = Pred.init ) 
    276292        { 
    277293            if( buf.length == 0 || 
    …… 
    420436        static assert( isCallableType!(Pred) ); 
    421437 
    422  
    423         size_t fn( const(Elem)[] buf, Elem pat, Pred pred = Pred.init ) 
     438        alias ConstArrayOf!(Elem) EA; 
     439 
     440        size_t fn( EA buf, Elem pat, Pred pred = Pred.init ) 
    424441        { 
    425442            foreach( size_t pos, Elem cur; buf ) 
    …… 
    432449 
    433450 
    434         size_t fn( const(Elem)[] buf, const(Elem)[] pat, Pred pred = Pred.init ) 
     451        size_t fn( EA buf, EA pat, Pred pred = Pred.init ) 
    435452        { 
    436453            if( buf.length == 0 || 
    …… 
    602619        static assert( isCallableType!(Pred) ); 
    603620 
    604  
    605         size_t fn( const(Elem)[] buf, Elem pat, Pred pred = Pred.init ) 
     621        alias ConstArrayOf!(Elem) EA; 
     622 
     623        size_t fn( EA buf, Elem pat, Pred pred = Pred.init ) 
    606624        { 
    607625            if( buf.length == 0 ) 
    …… 
    619637 
    620638 
    621         size_t fn( const(Elem)[] buf, const(Elem)[] pat, Pred pred = Pred.init ) 
     639        size_t fn( EA buf, EA pat, Pred pred = Pred.init ) 
    622640        { 
    623641            if( buf.length == 0 || 
    …… 
    760778        static assert( isCallableType!(Pred) ); 
    761779 
    762  
    763         size_t fn( const(Elem)[] buf, Pred pred ) 
     780        alias ConstArrayOf!(Elem) EA; 
     781 
     782        size_t fn( EA buf, Pred pred ) 
    764783        { 
    765784            foreach( size_t pos, Elem cur; buf ) 
    …… 
    825844        static assert( isCallableType!(Pred) ); 
    826845 
    827  
    828         size_t fn( const(Elem)[] buf, Pred pred ) 
     846        alias ConstArrayOf!(Elem) EA; 
     847 
     848        size_t fn( EA buf, Pred pred ) 
    829849        { 
    830850            if( buf.length == 0 ) 
    …… 
    898918        static assert( isCallableType!(Pred) ); 
    899919 
    900  
    901         size_t fn( const(Elem)[] buf, Pred pred = Pred.init ) 
     920        alias ConstArrayOf!(Elem) EA; 
     921 
     922        size_t fn( EA buf, Pred pred = Pred.init ) 
    902923        { 
    903924            if( buf.length < 2 ) 
    …… 
    10811102        static assert( isCallableType!(Pred) ); 
    10821103 
    1083  
    1084         size_t fn( const(Elem)[] bufA, const(Elem)[] bufB, Pred pred = Pred.init ) 
     1104        alias ConstArrayOf!(Elem) EA; 
     1105 
     1106        size_t fn( EA bufA, EA bufB, Pred pred = Pred.init ) 
    10851107        { 
    10861108            size_t  posA = 0, 
    …… 
    11691191        static assert( isCallableType!(Pred) ); 
    11701192 
    1171  
    1172         size_t fn( const(Elem)[] buf, Elem pat, Pred pred = Pred.init ) 
     1193        alias ConstArrayOf!(Elem) EA; 
     1194 
     1195        size_t fn( EA buf, Elem pat, Pred pred = Pred.init ) 
    11731196        { 
    11741197            size_t cnt = 0; 
    …… 
    12451268        static assert( isCallableType!(Pred) ); 
    12461269 
    1247  
    1248         size_t fn( const(Elem)[] buf, Pred pred ) 
     1270        alias ConstArrayOf!(Elem) EA; 
     1271 
     1272        size_t fn( EA buf, Pred pred ) 
    12491273        { 
    12501274            size_t cnt = 0; 
    …… 
    13151339        static assert( isCallableType!(Pred) ); 
    13161340 
    1317  
    1318         size_t fn( const(Elem)[] buf, Elem pat, Elem val, Pred pred = Pred.init ) 
     1341        alias ConstArrayOf!(Elem) EA; 
     1342 
     1343        size_t fn( EA buf, Elem pat, Elem val, Pred pred = Pred.init ) 
    13191344        { 
    13201345            size_t cnt = 0; 
    …… 
    13951420        static assert( isCallableType!(Pred) ); 
    13961421 
    1397  
    1398         size_t fn( const(Elem)[] buf, Elem val, Pred pred ) 
     1422        alias ConstArrayOf!(Elem) EA; 
     1423 
     1424        size_t fn( EA buf, Elem val, Pred pred ) 
    13991425        { 
    14001426            size_t cnt = 0; 
    …… 
    14631489     *  The number of elements that do not match pat. 
    14641490     */ 
    1465     size_t remove( const(Elem)[] buf, Elem pat, Pred2E pred = Pred2E.init ); 
     1491    size_t remove( Elem[] buf, Elem pat, Pred2E pred = Pred2E.init ); 
    14661492} 
    14671493else 
    …… 
    15631589     *  The number of elements that do not satisfy pred. 
    15641590     */ 
    1565     size_t removeIf( const(Elem)[] buf, Pred1E pred ); 
     1591    size_t removeIf( Elem[] buf, Pred1E pred ); 
    15661592} 
    15671593else 
    …… 
    15701596    { 
    15711597        static assert( isCallableType!(Pred) ); 
    1572  
    15731598 
    15741599        size_t fn( Elem[] buf, Pred pred ) 
    …… 
    16561681     *  The number of unique elements in buf. 
    16571682     */ 
    1658     size_t unique( const(Elem)[] buf, Pred2E pred = Pred2E.init ); 
     1683    size_t unique( Elem[] buf, Pred2E pred = Pred2E.init ); 
    16591684} 
    16601685else 
    …… 
    17631788     *  The number of elements that satisfy pred. 
    17641789     */ 
    1765     size_t partition( const(Elem)[] buf, Pred1E pred ); 
     1790    size_t partition( Elem[] buf, Pred1E pred ); 
    17661791} 
    17671792else 
    …… 
    18741899     *  buf.length. 
    18751900     */ 
    1876     size_t select( const(Elem)[] buf, Num num, Pred2E pred = Pred2E.init ); 
     1901    size_t select( Elem[] buf, Num num, Pred2E pred = Pred2E.init ); 
    18771902} 
    18781903else 
    …… 
    19882013     *         callable type. 
    19892014     */ 
    1990     void sort( const(Elem)[] buf, Pred2E pred = Pred2E.init ); 
     2015    void sort( Elem[] buf, Pred2E pred = Pred2E.init ); 
    19912016} 
    19922017else 
    …… 
    21582183        static assert( isCallableType!(Pred) ); 
    21592184 
    2160  
    2161         size_t fn( const(Elem)[] buf, Elem pat, Pred pred = Pred.init ) 
     2185        alias ConstArrayOf!(Elem) EA; 
     2186 
     2187        size_t fn( EA buf, Elem pat, Pred pred = Pred.init ) 
    21622188        { 
    21632189            size_t  beg   = 0, 
    …… 
    22422268        static assert( isCallableType!(Pred) ); 
    22432269 
    2244  
    2245         size_t fn( const(Elem)[] buf, Elem pat, Pred pred = Pred.init ) 
     2270        alias ConstArrayOf!(Elem) EA; 
     2271 
     2272        size_t fn( EA buf, Elem pat, Pred pred = Pred.init ) 
    22462273        { 
    22472274            size_t  beg   = 0, 
    …… 
    23232350        static assert( isCallableType!(Pred) ); 
    23242351 
    2325  
    2326         bool fn( const(Elem)[] buf, Elem pat, Pred pred = Pred.init ) 
     2352        alias ConstArrayOf!(Elem) EA; 
     2353 
     2354        bool fn( EA buf, Elem pat, Pred pred = Pred.init ) 
    23272355        { 
    23282356            size_t pos = lbound( buf, pat, pred ); 
    …… 
    24002428        static assert( isCallableType!(Pred ) ); 
    24012429 
    2402  
    2403         bool fn( const(Elem)[] setA, const(Elem)[] setB, Pred pred = Pred.init ) 
     2430        alias ConstArrayOf!(Elem) EA; 
     2431 
     2432        bool fn( EA setA, EA setB, Pred pred = Pred.init ) 
    24042433        { 
    24052434            size_t  posA = 0, 
    …… 
    24892518        static assert( isCallableType!(Pred ) ); 
    24902519 
    2491  
    2492         Elem[] fn( const(Elem)[] setA, const(Elem)[] setB, Pred pred = Pred.init ) 
     2520        alias ConstArrayOf!(Elem) EA; 
     2521 
     2522        Elem[] fn( EA setA, EA setB, Pred pred = Pred.init ) 
    24932523        { 
    24942524            size_t  posA = 0, 
    …… 
    25752605        static assert( isCallableType!(Pred ) ); 
    25762606 
    2577  
    2578         Elem[] fn( const(Elem)[] setA, const(Elem)[] setB, Pred pred = Pred.init ) 
     2607        alias ConstArrayOf!(Elem) EA; 
     2608 
     2609        Elem[] fn( EA setA, EA setB, Pred pred = Pred.init ) 
    25792610        { 
    25802611            size_t  posA = 0, 
    …… 
    26572688        static assert( isCallableType!(Pred ) ); 
    26582689 
    2659  
    2660         Elem[] fn( const(Elem)[] setA, const(Elem)[] setB, Pred pred = Pred.init ) 
     2690        alias ConstArrayOf!(Elem) EA; 
     2691 
     2692        Elem[] fn( EA setA, EA setB, Pred pred = Pred.init ) 
    26612693        { 
    26622694            size_t  posA = 0, 
    …… 
    27442776        static assert( isCallableType!(Pred ) ); 
    27452777 
    2746  
    2747         Elem[] fn( const(Elem)[] setA, const(Elem)[] setB, Pred pred = Pred.init ) 
     2778        alias ConstArrayOf!(Elem) EA; 
     2779 
     2780        Elem[] fn( EA setA, EA setB, Pred pred = Pred.init ) 
    27482781        { 
    27492782            size_t  posA = 0, 
    …… 
    28222855     *         callable type. 
    28232856     */ 
    2824     void makeHeap( const(Elem)[] buf, Pred2E pred = Pred2E.init ); 
     2857    void makeHeap( Elem[] buf, Pred2E pred = Pred2E.init ); 
    28252858} 
    28262859else 
    …… 
    29512984     *         callable type. 
    29522985     */ 
    2953     void pushHeap( ref const(Elem)[] buf, Elem val, Pred2E pred = Pred2E.init ); 
     2986    void pushHeap( ref Elem[] buf, Elem val, Pred2E pred = Pred2E.init ); 
    29542987} 
    29552988else 
    …… 
    30723105     *         callable type. 
    30733106     */ 
    3074     void popHeap( ref const(Elem)[] buf, Pred2E pred = Pred2E.init ); 
     3107    void popHeap( ref Elem[] buf, Pred2E pred = Pred2E.init ); 
    30753108} 
    30763109else 
    …… 
    31973230     *         callable type. 
    31983231     */ 
    3199     void sortHeap( const(Elem)[] buf, Pred2E pred = Pred2E.init ); 
     3232    void sortHeap( Elem[] buf, Pred2E pred = Pred2E.init ); 
    32003233} 
    32013234else 

  • branches/experimental/D2.0/tango/core/Variant.d

    r2810 r2838  
    135135    template isStaticArray( T ) 
    136136    { 
    137         static if( is( typeof(T.init)[(T).sizeof / typeof(T.init).sizeof] == T ) ) 
     137        static if( __traits(isStaticArray, T) ) 
    138138            const isStaticArray = true; 
    139139        else 
    …… 
    226226 
    227227 
     228    template isInvariant( T ) 
     229    { 
     230      static if( is(invariant(T) : T) ) 
     231        const isInvariant = true; 
     232      else 
     233        const isInvariant = false; 
     234    } 
     235 
    228236    template storageT( T ) 
    229237    { 
    230238        static if( isStaticArray!(T) ) 
     239        { 
     240          static if( isInvariant!(T) ) 
     241            alias typeof(T.idup) storageT; 
     242          else 
    231243            alias typeof(T.dup) storageT; 
     244        } 
    232245        else 
    233246            alias T storageT; 
    …… 
    411424        else static if( isArray!(T) ) 
    412425        { 
     426          static if( isInvariant!(T) ) 
     427            return (cast(invariant(typeof(T[0])*))this.value.arr.ptr)[0 .. this.value.arr.length]; 
     428          else 
    413429            return (cast(typeof(T[0])*)this.value.arr.ptr)[0 .. this.value.arr.length]; 
    414430        } 
Roadmap Timeline Tickets New Ticket Help / Guide About Trac
Login  |  
Trac dsource.org
RSS
Copyright © 2006-2008 Tango. All Rights Reserved. | Page Width: Static or Dynamic