Changeset 9

Show
Ignore:
Timestamp:
06/19/04 02:05:09 (4 years ago)
Author:
DenisG
Message:

[AprSharp] Change IsNull? from method to property

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/AprSharp/dev/src/AprAllocator.cs

    r6 r9  
    2626        } 
    2727         
    28         public bool IsNull() 
     28        public bool IsNull 
    2929        { 
    30             return( mAllocator == IntPtr.Zero ); 
     30            get 
     31            { 
     32                return( mAllocator == IntPtr.Zero ); 
     33            } 
    3134        } 
    3235 
    3336        private void CheckPtr() 
    3437        { 
    35             if( IsNull() ) 
     38            if( IsNull ) 
    3639                throw new AprNullReferenceException();  
    3740        } 

  • trunk/AprSharp/dev/src/AprArray.cs

    r6 r9  
    4141        } 
    4242         
    43         public bool IsNull() 
    44         { 
    45             return( mArray == null ); 
     43        public bool IsNull 
     44        { 
     45            get 
     46            { 
     47                return( mArray == null ); 
     48            } 
    4649        } 
    4750 

  • trunk/AprSharp/dev/src/AprHash.cs

    r6 r9  
    2626        } 
    2727         
    28         public bool IsNull() 
    29         { 
    30             return( mHash == IntPtr.Zero ); 
     28        public bool IsNull 
     29        { 
     30            get 
     31            { 
     32                return( mHash == IntPtr.Zero ); 
     33            } 
    3134        } 
    3235 
    3336        private void CheckPtr() 
    3437        { 
    35             if( IsNull() ) 
     38            if( IsNull ) 
    3639                throw new AprNullReferenceException();  
    3740        } 
    …… 
    329332            set 
    330333            { 
    331                 if( mPool.IsNull() ) 
     334                if( mPool.IsNull ) 
    332335                    throw new AprNullReferenceException();  
    333336                mKey = AprString.Duplicate(mPool, value); 
    …… 
    344347            set 
    345348            { 
    346                 if( mPool.IsNull() ) 
     349                if( mPool.IsNull ) 
    347350                    throw new AprNullReferenceException();  
    348351                mValue = AprString.Duplicate(mPool, value); 
    …… 
    381384                reset = false; 
    382385            } 
    383             else if(!mHashIndex.IsNull()) 
     386            else if(!mHashIndex.IsNull) 
    384387            { 
    385388                mHashIndex.Next(); 
    386389            } 
    387             return(!mHashIndex.IsNull()); 
     390            return(!mHashIndex.IsNull); 
    388391        } 
    389392         

  • trunk/AprSharp/dev/src/AprHashIndex.cs

    r6 r9  
    2626        } 
    2727         
    28         public bool IsNull() 
     28        public bool IsNull 
    2929        { 
    30             return( mHashIndex == IntPtr.Zero ); 
     30            get 
     31            { 
     32                return( mHashIndex == IntPtr.Zero ); 
     33            } 
    3134        } 
    3235 
    3336        private void CheckPtr() 
    3437        { 
    35             if( IsNull() ) 
     38            if( IsNull ) 
    3639                throw new AprNullReferenceException();  
    3740        } 

  • trunk/AprSharp/dev/src/AprMemNode.cs

    r1 r9  
    4141        } 
    4242         
    43         public bool IsNull() 
    44         { 
    45             return( mMemNode == null ); 
     43        public bool IsNull 
     44        { 
     45            get 
     46            { 
     47                return( mMemNode == null ); 
     48            } 
    4649        } 
    4750 

  • trunk/AprSharp/dev/src/AprPool.cs

    r6 r9  
    2525        } 
    2626         
    27         public bool IsNull() 
     27        public bool IsNull 
    2828        { 
    29             return( mPool == IntPtr.Zero ); 
     29            get 
     30            { 
     31                return( mPool == IntPtr.Zero ); 
     32            } 
    3033        } 
    3134 
    3235        private void CheckPtr() 
    3336        { 
    34             if( IsNull() ) 
     37            if( IsNull ) 
    3538                throw new AprNullReferenceException();  
    3639        } 

  • trunk/AprSharp/dev/src/AprString.cs

    r1 r9  
    2525        } 
    2626         
    27         public bool IsNull() 
     27        public bool IsNull 
    2828        { 
    29             return( mString == IntPtr.Zero ); 
     29            get 
     30            { 
     31                return( mString == IntPtr.Zero ); 
     32            } 
    3033        } 
    3134 
    3235        private void CheckPtr() 
    3336        { 
    34             if( IsNull() ) 
     37            if( IsNull ) 
    3538                throw new AprNullReferenceException();  
    3639        } 

  • trunk/AprSharp/dev/src/AprThreadMutex.cs

    r1 r9  
    3232        } 
    3333         
    34         public bool IsNull() 
     34        public bool IsNull 
    3535        { 
    36             return( mThreadMutex == IntPtr.Zero ); 
     36            get 
     37            { 
     38                return( mThreadMutex == IntPtr.Zero ); 
     39            } 
    3740        } 
    3841 
    3942        private void CheckPtr() 
    4043        { 
    41             if( IsNull() ) 
     44            if( IsNull ) 
    4245                throw new AprNullReferenceException();  
    4346        } 

  • trunk/AprSharp/dev/src/AprTimeExp.cs

    r1 r9  
    5353        } 
    5454         
    55         public bool IsNull() 
    56         { 
    57             return( mTimeExp == null ); 
     55        public bool IsNull 
     56        { 
     57            get 
     58            { 
     59                return( mTimeExp == null ); 
     60            } 
    5861        } 
    5962 

  • trunk/AprSharp/test/src/AprAllocatorTest.cs

    r5 r9  
    2929        { 
    3030            AprAllocator a = new AprAllocator(); 
    31             Assert.IsTrue(a.IsNull(),"#A01"); 
     31            Assert.IsTrue(a.IsNull,"#A01"); 
    3232             
    3333            a = AprAllocator.Create(); 
    34             Assert.IsFalse(a.IsNull(),"#A02"); 
     34            Assert.IsFalse(a.IsNull,"#A02"); 
    3535             
    3636            a.Destroy(); 
    37             Assert.IsTrue(a.IsNull(),"#A03"); 
     37            Assert.IsTrue(a.IsNull,"#A03"); 
    3838        } 
    3939 
    …… 
    4141        { 
    4242            AprMemNode m = a.Alloc(size); 
    43             Assert.IsFalse(m.IsNull(),test+"a"); 
     43            Assert.IsFalse(m.IsNull,test+"a"); 
    4444            if( (size+24) <= 8192 ) { 
    4545                Assert.AreEqual(1,m.NativeIndex,test+"c"); 
    …… 
    5656        { 
    5757            AprAllocator a = AprAllocator.Create(); 
    58             Assert.IsFalse(a.IsNull(),"#B01"); 
     58            Assert.IsFalse(a.IsNull,"#B01"); 
    5959 
    6060            AprMemNode m = AllocHelper(a,256,"#B02"); 
    …… 
    6262             
    6363            a.Destroy(); 
    64             Assert.IsTrue(a.IsNull(),"#B03"); 
     64            Assert.IsTrue(a.IsNull,"#B03"); 
    6565        } 
    6666         
    …… 
    7070        { 
    7171            AprAllocator a = AprAllocator.Create(); 
    72             Assert.IsFalse(a.IsNull(),"#C01"); 
     72            Assert.IsFalse(a.IsNull,"#C01"); 
    7373 
    7474            AprMemNode m = AllocHelper(a,256,"#C02"); 
    …… 
    9696 
    9797            a.Destroy(); 
    98             Assert.IsTrue(a.IsNull(),"#C08"); 
     98            Assert.IsTrue(a.IsNull,"#C08"); 
    9999        } 
    100100         
    …… 
    103103        { 
    104104            AprAllocator a = AprAllocator.Create(); 
    105             Assert.IsFalse(a.IsNull(),"#D000001"); 
     105            Assert.IsFalse(a.IsNull,"#D000001"); 
    106106 
    107107            int adrChange = 0; 
    …… 
    123123             
    124124            a.Destroy(); 
    125             Assert.IsTrue(a.IsNull(),"#D000003"); 
     125            Assert.IsTrue(a.IsNull,"#D000003"); 
    126126        } 
    127127 
    …… 
    130130        { 
    131131            AprAllocator a = AprAllocator.Create(); 
    132             Assert.IsFalse(a.IsNull(),"#E000001"); 
     132            Assert.IsFalse(a.IsNull,"#E000001"); 
    133133            a.MaxFree = 81920; 
    134134             
    …… 
    151151 
    152152            a.Destroy(); 
    153             Assert.IsTrue(a.IsNull(),"#E000003"); 
     153            Assert.IsTrue(a.IsNull,"#E000003"); 
    154154        } 
    155155    } 

  • trunk/AprSharp/test/src/AprMutexTest.cs

    r5 r9  
    2929        { 
    3030            AprPool p = AprPool.Create(); 
    31             Assert.IsFalse(p.IsNull(),"#A01"); 
     31            Assert.IsFalse(p.IsNull,"#A01"); 
    3232         
    3333            AprThreadMutex m = new AprThreadMutex(); 
    34             Assert.IsTrue(m.IsNull(),"#A02"); 
     34            Assert.IsTrue(m.IsNull,"#A02"); 
    3535             
    3636            m = AprThreadMutex.Create(p); 
    37             Assert.IsFalse(m.IsNull(),"#A03"); 
     37            Assert.IsFalse(m.IsNull,"#A03"); 
    3838            Assert.AreEqual(((IntPtr)p).ToInt32(),((IntPtr)(m.Pool)).ToInt32(),"#A04"); 
    3939 
    4040            m.Destroy(); 
    41             Assert.IsTrue(m.IsNull(),"#A05"); 
     41            Assert.IsTrue(m.IsNull,"#A05"); 
    4242             
    4343            p.Destroy(); 
    44             Assert.IsTrue(p.IsNull(),"#A06"); 
     44            Assert.IsTrue(p.IsNull,"#A06"); 
    4545        } 
    4646 
    …… 
    4949        { 
    5050            AprPool p = AprPool.Create(); 
    51             Assert.IsFalse(p.IsNull(),"#B01"); 
     51            Assert.IsFalse(p.IsNull,"#B01"); 
    5252         
    5353            AprThreadMutex m = AprThreadMutex.Create(p); 
    54             Assert.IsFalse(m.IsNull(),"#B02"); 
     54            Assert.IsFalse(m.IsNull,"#B02"); 
    5555            Assert.AreEqual(((IntPtr)p).ToInt32(),((IntPtr)(m.Pool)).ToInt32(),"#B03"); 
    5656 
    …… 
    6767         
    6868            p.Destroy(); 
    69             Assert.IsTrue(p.IsNull(),"#A06"); 
     69            Assert.IsTrue(p.IsNull,"#A06"); 
    7070        }            
    7171             
    …… 
    7474        { 
    7575            AprAllocator a = AprAllocator.Create(); 
    76             Assert.IsFalse(a.IsNull(),"#C01"); 
     76            Assert.IsFalse(a.IsNull,"#C01"); 
    7777 
    7878            AprPool p = AprPool.Create(a); 
    79             Assert.IsFalse(p.IsNull(),"#C02"); 
     79            Assert.IsFalse(p.IsNull,"#C02"); 
    8080            Assert.AreEqual(((IntPtr)a).ToInt32(),((IntPtr)(p.Allocator)).ToInt32(),"#C03"); 
    8181             
    …… 
    8484             
    8585            AprThreadMutex m = AprThreadMutex.Create(p); 
    86             Assert.IsFalse(m.IsNull(),"#C05"); 
     86            Assert.IsFalse(m.IsNull,"#C05"); 
    8787            Assert.AreEqual(((IntPtr)p).ToInt32(),((IntPtr)(m.Pool)).ToInt32(),"#C06"); 
    8888 
    …… 
    9191             
    9292            p.Destroy(); 
    93             Assert.IsTrue(p.IsNull(),"#C08"); 
     93            Assert.IsTrue(p.IsNull,"#C08"); 
    9494        }        
    9595    } 

  • trunk/AprSharp/test/src/AprPoolTest.cs

    r5 r9  
    3030        { 
    3131            AprPool p = new AprPool(); 
    32             Assert.IsTrue(p.IsNull(),"#A01"); 
    33              
    34             p = AprPool.Create(); 
    35             Assert.IsFalse(p.IsNull(),"#A02"); 
    36              
    37             p.Destroy(); 
    38             Assert.IsTrue(p.IsNull(),"#A03"); 
     32            Assert.IsTrue(p.IsNull,"#A01"); 
     33             
     34            p = AprPool.Create(); 
     35            Assert.IsFalse(p.IsNull,"#A02"); 
     36             
     37            p.Destroy(); 
     38            Assert.IsTrue(p.IsNull,"#A03"); 
    3939        } 
    4040 
    …… 
    4343        { 
    4444            AprPool p = new AprPool(); 
    45             Assert.IsTrue(p.IsNull(),"#B01"); 
    46              
    47             p = AprPool.Create(); 
    48             Assert.IsFalse(p.IsNull(),"#B02"); 
     45            Assert.IsTrue(p.IsNull,"#B01"); 
     46             
     47            p = AprPool.Create(); 
     48            Assert.IsFalse(p.IsNull,"#B02"); 
    4949 
    5050            AprPool sp = AprPool.Create(p); 
    51             Assert.IsFalse(sp.IsNull(),"#B03"); 
     51            Assert.IsFalse(sp.IsNull,"#B03"); 
    5252            Assert.AreEqual(((IntPtr)p).ToInt32(),((IntPtr)(sp.Parent)).ToInt32(),"#B04"); 
    5353             
    5454            sp.Destroy(); 
    55             Assert.IsTrue(sp.IsNull(),"#B05"); 
    56              
    57             p.Destroy(); 
    58             Assert.IsTrue(p.IsNull(),"#B06"); 
     55            Assert.IsTrue(sp.IsNull,"#B05"); 
     56             
     57            p.Destroy(); 
     58            Assert.IsTrue(p.IsNull,"#B06"); 
    5959        } 
    6060         
    …… 
    6363        { 
    6464            AprAllocator a = AprAllocator.Create(); 
    65             Assert.IsFalse(a.IsNull(),"#C01"); 
     65            Assert.IsFalse(a.IsNull,"#C01"); 
    6666 
    6767            AprPool p = AprPool.Create(a); 
    68             Assert.IsFalse(p.IsNull(),"#C02"); 
     68            Assert.IsFalse(p.IsNull,"#C02"); 
    6969            Assert.AreEqual(((IntPtr)a).ToInt32(),((IntPtr)(p.Allocator)).ToInt32(),"#C03"); 
    7070             
    …… 
    7373             
    7474            p.Destroy(); 
    75             Assert.IsTrue(p.IsNull(),"#C05"); 
     75            Assert.IsTrue(p.IsNull,"#C05"); 
    7676        } 
    7777 
    …… 
    8080        { 
    8181            AprPool p = new AprPool(); 
    82             Assert.IsTrue(p.IsNull(),"#D01"); 
    83              
    84             p = AprPool.Create(); 
    85             Assert.IsFalse(p.IsNull(),"#D02"); 
     82            Assert.IsTrue(p.IsNull,"#D01"); 
     83             
     84            p = AprPool.Create(); 
     85            Assert.IsFalse(p.IsNull,"#D02"); 
    8686 
    8787            AprAllocator a = AprAllocator.Create(); 
    88             Assert.IsFalse(a.IsNull(),"#D03"); 
     88            Assert.IsFalse(a.IsNull,"#D03"); 
    8989 
    9090            AprPool sp = AprPool.Create(p,a); 
    91             Assert.IsFalse(sp.IsNull(),"#D04"); 
     91            Assert.IsFalse(sp.IsNull,"#D04"); 
    9292            Assert.AreEqual(((IntPtr)p).ToInt32(),((IntPtr)(sp.Parent)).ToInt32(),"#D05"); 
    9393            Assert.AreEqual(((IntPtr)a).ToInt32(),((IntPtr)(sp.Allocator)).ToInt32(),"#D06"); 
    …… 
    9797             
    9898            sp.Destroy(); 
    99             Assert.IsTrue(sp.IsNull(),"#D08"); 
    100              
    101             p.Destroy(); 
    102             Assert.IsTrue(p.IsNull(),"#D09"); 
     99            Assert.IsTrue(sp.IsNull,"#D08"); 
     100             
     101            p.Destroy(); 
     102            Assert.IsTrue(p.IsNull,"#D09"); 
    103103        } 
    104104         
    …… 
    107107        { 
    108108            AprPool p = new AprPool(); 
    109             Assert.IsTrue(p.IsNull(),"#E01"); 
    110              
    111             p = AprPool.Create(); 
    112             Assert.IsFalse(p.IsNull(),"#E02"); 
     109            Assert.IsTrue(p.IsNull,"#E01"); 
     110             
     111            p = AprPool.Create(); 
     112            Assert.IsFalse(p.IsNull,"#E02"); 
    113113             
    114114            Assert.IsTrue(p.Alloc(128).ToInt32() != 0,"#E03"); 
    …… 
    124124             
    125125            p.Destroy(); 
    126             Assert.IsTrue(p.IsNull(),"#E13"); 
     126            Assert.IsTrue(p.IsNull,"#E13"); 
    127127        } 
    128128 
    …… 
    131131        { 
    132132            AprPool p = new AprPool(); 
    133             Assert.IsTrue(p.IsNull(),"#F01"); 
    134              
    135             p = AprPool.Create(); 
    136             Assert.IsFalse(p.IsNull(),"#F02"); 
     133            Assert.IsTrue(p.IsNull,"#F01"); 
     134             
     135            p = AprPool.Create(); 
     136            Assert.IsFalse(p.IsNull,"#F02"); 
    137137             
    138138            IntPtr m = p.CAlloc(256); 
    …… 
    141141             
    142142            p.Destroy(); 
    143             Assert.IsTrue(p.IsNull(),"#F04"); 
     143            Assert.IsTrue(p.IsNull,"#F04"); 
    144144        } 
    145145         
    …… 
    148148        { 
    149149            AprPool p = new AprPool(); 
    150             Assert.IsTrue(p.IsNull(),"#G000001"); 
    151              
    152             p = AprPool.Create(); 
    153             Assert.IsFalse(p.IsNull(),"#G000002"); 
     150            Assert.IsTrue(p.IsNull,"#G000001"); 
     151             
     152            p = AprPool.Create(); 
     153            Assert.IsFalse(p.IsNull,"#G000002"); 
    154154             
    155155            for(int i=24;i<4096;i+=24) 
    …… 
    159159 
    160160            p.Destroy(); 
    161             Assert.IsTrue(p.IsNull(),"#G000004"); 
     161            Assert.IsTrue(p.IsNull,"#G000004"); 
    162162        } 
    163163 
    …… 
    166166        { 
    167167            AprPool p = new AprPool(); 
    168             Assert.IsTrue(p.IsNull(),"#H000001"); 
    169              
    170             p = AprPool.Create(); 
    171             Assert.IsFalse(p.IsNull(),"#H000002"); 
     168            Assert.IsTrue(p.IsNull,"#H000001"); 
     169             
     170            p = AprPool.Create(); 
     171            Assert.IsFalse(p.IsNull,"#H000002"); 
    172172 
    173173            for(int i=24;i<4096;i+=24) 
    …… 
    180180 
    181181            p.Destroy(); 
    182             Assert.IsTrue(p.IsNull(),"#H000004"); 
     182            Assert.IsTrue(p.IsNull,"#H000004"); 
    183183        } 
    184184         
    …… 
    187187        { 
    188188            AprPool p = AprPool.Create(); 
    189             Assert.IsFalse(p.IsNull(),"#I01"); 
     189            Assert.IsFalse(p.IsNull,"#I01"); 
    190190 
    191191            AprPool sp = AprPool.Create(p); 
    192             Assert.IsFalse(sp.IsNull(),"#I02"); 
     192            Assert.IsFalse(sp.IsNull,"#I02"); 
    193193            Assert.AreEqual(((IntPtr)p).ToInt32(),((IntPtr)(sp.Parent)).ToInt32(),"#I03"); 
    194194 
    195195            AprPool ssp = AprPool.Create(sp); 
    196             Assert.IsFalse(ssp.IsNull(),"#I05"); 
     196            Assert.IsFalse(ssp.IsNull,"#I05"); 
    197197            Assert.AreEqual(((IntPtr)sp).ToInt32(),((IntPtr)(ssp.Parent)).ToInt32(),"#I06"); 
    198198             
    …… 
    205205             
    206206            p.Destroy(); 
    207             Assert.IsTrue(p.IsNull(),"#I14"); 
     207            Assert.IsTrue(p.IsNull,"#I14"); 
    208208        } 
    209209 

  • trunk/AprSharp/test/src/AprTest.prjx

    r5 r9  
    55    <File name="./AprAllocatorTest.cs" subtype="Code" buildaction="Compile" dependson="" data="" /> 
    66    <File name="./AprMutexTest.cs" subtype="Code" buildaction="Compile" dependson="" data="" /> 
     7    <File name="./AprTimeTest.cs" subtype="Code" buildaction="Compile" dependson="" data="" /> 
    78  </Contents> 
    89  <References>