Note: This website is archived. For up-to-date information about D projects and development, please visit wiki.dlang.org.

Changeset 758

Show
Ignore:
Timestamp:
06/24/08 21:33:15 (16 years ago)
Author:
Bartosz
Message:

de-tabified

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/phobos/internal/object.d

    r664 r758  
    355355 
    356356 
    357357/** 
    358358 * Runtime type information about a type. 
    359359 * Can be retrieved for any type using a 
    360360 * <a href="../expression.html#typeidexpression">TypeidExpression</a>. 
    361361 */ 
    362362class TypeInfo 
    363363{ 
    364364    override hash_t toHash() 
    365     {   hash_t hash; 
    366  
    367     foreach (char c; this.toString()) 
    368         hash = hash * 9 + c; 
    369     return hash; 
     365    { 
     366        hash_t hash; 
     367 
     368        foreach (char c; this.toString()) 
     369            hash = hash * 9 + c; 
     370        return hash; 
    370371    } 
    371372 
    372373    override int opCmp(Object o) 
    373374    { 
    374375    if (this is o) 
    375376        return 0; 
    376377    TypeInfo ti = cast(TypeInfo)o; 
    377378    if (ti is null) 
    378379        return 1; 
    379380    return std.string.cmp(this.toString(), ti.toString()); 
     
    503504    else 
    504505        return 0; 
    505506    } 
    506507 
    507508    override size_t tsize() 
    508509    { 
    509510    return (void*).sizeof; 
    510511    } 
    511512 
    512513    override void swap(void *p1, void *p2) 
    513     {   void* tmp; 
    514     tmp = *cast(void**)p1; 
    515     *cast(void**)p1 = *cast(void**)p2; 
    516     *cast(void**)p2 = tmp; 
     514    { 
     515        void* tmp; 
     516        tmp = *cast(void**)p1; 
     517        *cast(void**)p1 = *cast(void**)p2; 
     518        *cast(void**)p2 = tmp; 
    517519    } 
    518520 
    519521    override TypeInfo next() { return m_next; } 
    520522    override uint flags() { return 1; } 
    521523 
    522524    TypeInfo m_next; 
    523525} 
    524526 
    525527class TypeInfo_Array : TypeInfo 
    526528{ 
     
    529531    override int opEquals(Object o) 
    530532    {   TypeInfo_Array c; 
    531533 
    532534    return cast(int) 
    533535           (this is o || 
    534536        ((c = cast(TypeInfo_Array)o) !is null && 
    535537         this.value == c.value)); 
    536538    } 
    537539 
    538540    override hash_t getHash(in void *p) 
    539     {   size_t sz = value.tsize(); 
    540     hash_t hash = 0; 
    541     void[] a = *cast(void[]*)p; 
    542     for (size_t i = 0; i < a.length; i++) 
    543         hash += value.getHash(a.ptr + i * sz); 
     541    { 
     542        size_t sz = value.tsize(); 
     543        hash_t hash = 0; 
     544        void[] a = *cast(void[]*)p; 
     545        for (size_t i = 0; i < a.length; i++) 
     546            hash += value.getHash(a.ptr + i * sz); 
    544547        return hash; 
    545548    } 
    546549 
    547550    override int equals(in void *p1, in void *p2) 
    548551    { 
    549552    void[] a1 = *cast(void[]*)p1; 
    550553    void[] a2 = *cast(void[]*)p2; 
    551554    if (a1.length != a2.length) 
    552555        return 0; 
    553556    size_t sz = value.tsize(); 
     
    576579        } 
    577580        return cast(int)a1.length - cast(int)a2.length; 
    578581    } 
    579582 
    580583    override size_t tsize() 
    581584    { 
    582585    return (void[]).sizeof; 
    583586    } 
    584587 
    585588    override void swap(void *p1, void *p2) 
    586     {   void[] tmp; 
    587     tmp = *cast(void[]*)p1; 
    588     *cast(void[]*)p1 = *cast(void[]*)p2; 
    589     *cast(void[]*)p2 = tmp; 
     589    { 
     590        void[] tmp; 
     591        tmp = *cast(void[]*)p1; 
     592        *cast(void[]*)p1 = *cast(void[]*)p2; 
     593        *cast(void[]*)p2 = tmp; 
    590594    } 
    591595 
    592596    TypeInfo value; 
    593597 
    594598    override TypeInfo next() 
    595599    { 
    596600    return value; 
    597601    } 
    598602 
    599603    override uint flags() { return 1; } 
     
    611615    {   TypeInfo_StaticArray c; 
    612616 
    613617    return cast(int) 
    614618           (this is o || 
    615619        ((c = cast(TypeInfo_StaticArray)o) !is null && 
    616620         this.len == c.len && 
    617621         this.value == c.value)); 
    618622    } 
    619623 
    620624    override hash_t getHash(in void *p) 
    621     {   size_t sz = value.tsize(); 
    622     hash_t hash = 0; 
    623     for (size_t i = 0; i < len; i++) 
    624         hash += value.getHash(p + i * sz); 
     625    { 
     626        size_t sz = value.tsize(); 
     627        hash_t hash = 0; 
     628        for (size_t i = 0; i < len; i++) 
     629            hash += value.getHash(p + i * sz); 
    625630        return hash; 
    626631    } 
    627632 
    628633    override int equals(in void *p1, in void *p2) 
    629634    { 
    630635    size_t sz = value.tsize(); 
    631636 
    632637        for (size_t u = 0; u < len; u++) 
    633638        { 
    634639        if (!value.equals(p1 + u * sz, p2 + u * sz)) 
     
    649654        } 
    650655        return 0; 
    651656    } 
    652657 
    653658    override size_t tsize() 
    654659    { 
    655660    return len * value.tsize(); 
    656661    } 
    657662 
    658663    override void swap(void *p1, void *p2) 
    659     {   void* tmp; 
    660     size_t sz = value.tsize(); 
    661     ubyte[16] buffer; 
    662     void* pbuffer; 
    663  
    664     if (sz < buffer.sizeof) 
    665         tmp = buffer.ptr; 
    666     else 
    667         tmp = pbuffer = (new void[sz]).ptr; 
    668  
    669     for (size_t u = 0; u < len; u += sz) 
    670     {   size_t o = u * sz; 
    671         memcpy(tmp, p1 + o, sz); 
    672         memcpy(p1 + o, p2 + o, sz); 
    673         memcpy(p2 + o, tmp, sz); 
    674     } 
    675     if (pbuffer) 
    676         delete pbuffer; 
     664    { 
     665        void* tmp; 
     666        size_t sz = value.tsize(); 
     667        ubyte[16] buffer; 
     668        void* pbuffer; 
     669 
     670        if (sz < buffer.sizeof) 
     671            tmp = buffer.ptr; 
     672        else 
     673            tmp = pbuffer = (new void[sz]).ptr; 
     674 
     675        for (size_t u = 0; u < len; u += sz) 
     676        {   size_t o = u * sz; 
     677            memcpy(tmp, p1 + o, sz); 
     678            memcpy(p1 + o, p2 + o, sz); 
     679            memcpy(p2 + o, tmp, sz); 
     680        } 
     681        if (pbuffer) 
     682            delete pbuffer; 
    677683    } 
    678684 
    679685    override void[] init() { return value.init(); } 
    680686    override TypeInfo next() { return value; } 
    681687    override uint flags() { return value.flags(); } 
    682688 
    683689    override void destroy(void *p) 
    684690    { 
    685691    auto sz = value.tsize(); 
    686692    p += sz * len; 
     
    771777    {   TypeInfo_Delegate c; 
    772778 
    773779    return this is o || 
    774780        ((c = cast(TypeInfo_Delegate)o) !is null && 
    775781         this.next == c.next); 
    776782    } 
    777783 
    778784    // BUG: need to add the rest of the functions 
    779785 
    780786    override size_t tsize() 
    781     {   alias int delegate() dg; 
    782     return dg.sizeof; 
     787    { 
     788        alias int delegate() dg; 
     789        return dg.sizeof; 
    783790    } 
    784791 
    785792    override uint flags() { return 1; } 
    786793 
    787794    TypeInfo next;  // delegate return type 
    788795} 
    789796 
    790797class TypeInfo_Class : TypeInfo 
    791798{ 
    792799    override string toString() { return info.name; } 
     
    808815    override int equals(in void *p1, in void *p2) 
    809816    { 
    810817    Object o1 = *cast(Object*)p1; 
    811818    Object o2 = *cast(Object*)p2; 
    812819 
    813820    return (o1 is o2) || (o1 && o1.opEquals(o2)); 
    814821    } 
    815822 
    816823    override int compare(in void *p1, in void *p2) 
    817824    { 
    818     Object o1 = *cast(Object*)p1; 
    819     Object o2 = *cast(Object*)p2; 
    820     int c = 0; 
    821  
    822     // Regard null references as always being "less than" 
    823     if (o1 !is o2) 
    824     { 
    825         if (o1) 
    826         {   if (!o2) 
    827             c = 1; 
    828         else 
    829             c = o1.opCmp(o2); 
    830         } 
    831         else 
    832         c = -1; 
    833     } 
    834     return c; 
     825        Object o1 = *cast(Object*)p1; 
     826        Object o2 = *cast(Object*)p2; 
     827        int c = 0; 
     828 
     829        // Regard null references as always being "less than" 
     830        if (o1 !is o2) 
     831        { 
     832            if (o1) 
     833            { 
     834                if (!o2) 
     835                    c = 1; 
     836                else 
     837                    c = o1.opCmp(o2); 
     838            } 
     839            else 
     840                c = -1; 
     841        } 
     842        return c; 
    835843    } 
    836844 
    837845    override size_t tsize() 
    838846    { 
    839847    return Object.sizeof; 
    840848    } 
    841849 
    842850    override uint flags() { return 1; } 
    843851 
    844852    override OffsetTypeInfo[] offTi() 
     
    874882    Interface* pi = **cast(Interface ***)*cast(void**)p1; 
    875883    Object o1 = cast(Object)(*cast(void**)p1 - pi.offset); 
    876884    pi = **cast(Interface ***)*cast(void**)p2; 
    877885    Object o2 = cast(Object)(*cast(void**)p2 - pi.offset); 
    878886 
    879887    return o1 == o2 || (o1 && o1.opCmp(o2) == 0); 
    880888    } 
    881889 
    882890    override int compare(in void *p1, in void *p2) 
    883891    { 
    884     Interface* pi = **cast(Interface ***)*cast(void**)p1; 
    885     Object o1 = cast(Object)(*cast(void**)p1 - pi.offset); 
    886     pi = **cast(Interface ***)*cast(void**)p2; 
    887     Object o2 = cast(Object)(*cast(void**)p2 - pi.offset); 
    888     int c = 0; 
    889  
    890     // Regard null references as always being "less than" 
    891     if (o1 != o2) 
    892     { 
    893         if (o1) 
    894         {   if (!o2) 
    895             c = 1; 
    896         else 
    897             c = o1.opCmp(o2); 
    898         } 
    899         else 
    900         c = -1; 
    901     } 
    902     return c; 
     892        Interface* pi = **cast(Interface ***)*cast(void**)p1; 
     893        Object o1 = cast(Object)(*cast(void**)p1 - pi.offset); 
     894        pi = **cast(Interface ***)*cast(void**)p2; 
     895        Object o2 = cast(Object)(*cast(void**)p2 - pi.offset); 
     896        int c = 0; 
     897 
     898        // Regard null references as always being "less than" 
     899        if (o1 != o2) 
     900        { 
     901            if (o1) 
     902            { 
     903                if (!o2) 
     904                    c = 1; 
     905                else 
     906                    c = o1.opCmp(o2); 
     907            } 
     908            else 
     909                c = -1; 
     910        } 
     911        return c; 
    903912    } 
    904913 
    905914    override size_t tsize() 
    906915    { 
    907916    return Object.sizeof; 
    908917    } 
    909918 
    910919    override uint flags() { return 1; } 
    911920 
    912921    ClassInfo info; 
     
    919928    override int opEquals(Object o) 
    920929    {   TypeInfo_Struct s; 
    921930 
    922931    return this is o || 
    923932        ((s = cast(TypeInfo_Struct)o) !is null && 
    924933         this.name == s.name && 
    925934         this.init.length == s.init.length); 
    926935    } 
    927936 
    928937    override hash_t getHash(in void *p) 
    929     {   hash_t h; 
    930  
    931     assert(p); 
    932     if (xtoHash) 
    933     {   //printf("getHash() using xtoHash\n"); 
    934         h = (*xtoHash)(p); 
    935     } 
    936     else 
    937     { 
    938         //printf("getHash() using default hash\n"); 
    939         // A sorry hash algorithm. 
    940         // Should use the one for strings. 
    941         // BUG: relies on the GC not moving objects 
    942         auto q = cast(const(ubyte)*)p; 
    943         for (size_t i = 0; i < init.length; i++) 
    944         {   h = h * 9 + *q; 
    945         q++; 
    946         } 
    947     } 
    948     return h; 
     938    { 
     939        hash_t h; 
     940 
     941        assert(p); 
     942        if (xtoHash) 
     943        {   //printf("getHash() using xtoHash\n"); 
     944            h = (*xtoHash)(p); 
     945        } 
     946        else 
     947        { 
     948            //printf("getHash() using default hash\n"); 
     949            // A sorry hash algorithm. 
     950            // Should use the one for strings. 
     951            // BUG: relies on the GC not moving objects 
     952            auto q = cast(const(ubyte)*)p; 
     953            for (size_t i = 0; i < init.length; i++) 
     954            { 
     955                h = h * 9 + *q; 
     956                q++; 
     957            } 
     958        } 
     959        return h; 
    949960    } 
    950961 
    951962    override int equals(in void *p2, in void *p1) 
    952     {   int c; 
    953  
    954     if (p1 == p2) 
    955         c = 1; 
    956     else if (!p1 || !p2) 
    957         c = 0; 
    958     else if (xopEquals) 
    959         c = (*xopEquals)(p1, p2); 
    960     else 
    961         // BUG: relies on the GC not moving objects 
    962         c = (memcmp(p1, p2, init.length) == 0); 
    963     return c; 
     963    { 
     964        int c; 
     965 
     966        if (p1 == p2) 
     967            c = 1; 
     968        else if (!p1 || !p2) 
     969            c = 0; 
     970        else if (xopEquals) 
     971            c = (*xopEquals)(p1, p2); 
     972        else 
     973            // BUG: relies on the GC not moving objects 
     974            c = (memcmp(p1, p2, init.length) == 0); 
     975        return c; 
    964976    } 
    965977 
    966978    override int compare(in void *p2, in void *p1) 
    967979    { 
    968     int c = 0; 
    969  
    970     // Regard null references as always being "less than" 
    971     if (p1 != p2) 
    972     { 
    973         if (p1) 
    974         {   if (!p2) 
    975             c = 1; 
    976         else if (xopCmp) 
    977             c = (*xopCmp)(p1, p2); 
    978         else 
    979             // BUG: relies on the GC not moving objects 
    980             c = memcmp(p1, p2, init.length); 
    981         } 
    982         else 
    983         c = -1; 
    984     } 
    985     return c; 
     980        int c = 0; 
     981 
     982        // Regard null references as always being "less than" 
     983        if (p1 != p2) 
     984        { 
     985            if (p1) 
     986            { 
     987                if (!p2) 
     988                    c = 1; 
     989                else if (xopCmp) 
     990                    c = (*xopCmp)(p1, p2); 
     991                else 
     992                    // BUG: relies on the GC not moving objects 
     993                    c = memcmp(p1, p2, init.length); 
     994            } 
     995            else 
     996                c = -1; 
     997        } 
     998        return c; 
    986999    } 
    9871000 
    9881001    override size_t tsize() 
    9891002    { 
    9901003    return init.length; 
    9911004    } 
    9921005 
    9931006    override void[] init() { return m_init; } 
    9941007 
    9951008    override uint flags() { return m_flags; }