Changeset 29

Timestamp:

06/25/04 02:04:10 (4 years ago)

Author:

DenisG

Message:

[AprSharp] Makes AprArray? type-safe, IEnumerable and ICollection

• New AprInvalidOperationException?
  
• Remove useless reference to Softec namespace in ...Exception
  
• Embed a type in AprArray? to type the stored value. Type other than
  primitive type should be castable to IntPtr? and provide a ctor(IntPtr?)
  
• Create an AprArrayEnumerator? that is able to enumerate typed array.
  
• Allow Push(Object) and PopObject?
  
• Add a properties to set the type
  

Files:

• trunk/AprSharp/dev/src/AprArgumentException.cs (modified) (1 diff)
• trunk/AprSharp/dev/src/AprArgumentNullException.cs (modified) (1 diff)
• trunk/AprSharp/dev/src/AprArgumentOutOfRangeException.cs (modified) (1 diff)
• trunk/AprSharp/dev/src/AprArray.cs (modified) (16 diffs)
• trunk/AprSharp/dev/src/AprInvalidOperationException.cs (added)
• trunk/AprSharp/dev/src/AprNullReferenceException.cs (modified) (1 diff)
• trunk/AprSharp/dev/src/AprSharp.prjx (modified) (1 diff)
• trunk/AprSharp/test/src/AprArrayTest.cs (modified) (2 diffs)

trunk/AprSharp/dev/src/AprArgumentException.cs

@@ -12 +12 @@
-using System;
-using System.Runtime.Serialization;
-using Softec;
-
-namespace Softec.AprSharp

trunk/AprSharp/dev/src/AprArgumentNullException.cs

@@ -12 +12 @@
-using System;
-using System.Runtime.Serialization;
-using Softec;
-
-namespace Softec.AprSharp

trunk/AprSharp/dev/src/AprArgumentOutOfRangeException.cs

@@ -12 +12 @@
-using System;
-using System.Runtime.Serialization;
-using Softec;
-
-namespace Softec.AprSharp

trunk/AprSharp/dev/src/AprArray.cs

@@ -11 +11 @@
-using System;
-using System.Diagnostics;
+using System.Reflection;
-using System.Runtime.InteropServices;
-using System.Collections;
@@ -16 +17 @@
-namespace Softec.AprSharp
-{
-
+ : IEnumerable
-    {
-        private apr_array_header_t *mArray;
+        private Type mEltsType;
-
-        [StructLayout( LayoutKind.Sequential )]
@@ -27 +29 @@
-            public int nelts;
-            public int nalloc;
-byte *
+IntPtr 
-        }
-
@@ -34 +36 @@
-        {
-            mArray = ptr;
+            mEltsType = null;
-        }
-
@@ -39 +42 @@
-        {
-            mArray = (apr_array_header_t *)ptr.ToPointer();
+            mEltsType = null;
+        }
+
+        public AprArray(IntPtr ptr, Type eltsType)
+        {
+            mArray = (apr_array_header_t *)ptr.ToPointer();
+            mEltsType = null;
+            if( eltsType != null )
+                ElementType = eltsType;
-        }
-        
@@ -58 +70 @@
-        {
-            mArray = null;
+            mEltsType = null;
-        }
-
@@ -74 +87 @@
-            return("[apr_array_header_t:"+(new IntPtr(mArray)).ToInt32().ToString("X")+"]");
-        }
+        
+        public Type ElementType
+        {
+            get
+            {
+                return(mEltsType);
+            }
+            set
+            {
+                if( (value.IsPrimitive && Marshal.SizeOf(value) != mArray->elt_size)
+                  ||(!value.IsPrimitive && Marshal.SizeOf(typeof(IntPtr)) != mArray->elt_size) )
+                        throw new AprArgumentException("Type does not match element size.");
+                        
+                if( value.IsPrimitive )
+                    mEltsType = value;
+                else {
+                    if( value.GetConstructor(new Type[] {typeof(IntPtr)}) == null )
+                        throw new AprInvalidOperationException("Type is not primitive and cannot be constructed from an IntPtr.");
+                    mEltsType = value;
+                }
+            }
+        }
-        #endregion
-        
-        #region Methods wrappers
+        public static AprArray Make(AprPool pool, int nElts, Type eltsType )
+        {
+            if(eltsType.IsPrimitive)
+                return(new AprArray(Make(pool, nElts, Marshal.SizeOf(eltsType)),eltsType));
+            else
+                return(new AprArray(Make(pool, nElts, Marshal.SizeOf(typeof(IntPtr))),eltsType));
+        }
+
-        public static AprArray Make(AprPool pool, int nElts, int eltSize )
-        {
@@ -101 +144 @@
-            Debug.WriteLine(String.Format("Done({0:X})",((Int32)ptr)));
-
-ptr
+new AprArray(ptr,mEltsType)
-        }
-
@@ -115 +158 @@
-            Debug.WriteLine(String.Format("Done({0:X})",((Int32)ptr)));
-
-ptr
+new AprArray(ptr,mEltsType)
-        }
-
@@ -121 +164 @@
-        {
-            IntPtr ptr;
-
-
+
+
+
+
+
+
+
+
+
+
-            Debug.Write(String.Format("apr_array_append({0},{1},{2})...",pool,array,this));
-            ptr = Apr.apr_array_append(pool,(IntPtr)mArray,array);
@@ -129 +180 @@
-            Debug.WriteLine(String.Format("Done({0:X})",((Int32)ptr)));
-
-ptr
+new AprArray(ptr,arrType)
-        }
-
-        public void Cat(AprArray array)
-        {
-
+
+
+
+
+
+
+
+
+
-            Debug.WriteLine(String.Format("apr_array_cat({0},{1})",this,array));
-            Apr.apr_array_cat((IntPtr)mArray,array);
@@ -149 +208 @@
-            
-            CheckPtr();
+            if(mEltsType != null && mEltsType != typeof(AprString))
+                throw new AprInvalidOperationException("Not an AprString array.");
+                
-            Debug.Write(String.Format("apr_array_pstrcat({0},{1},{2})...",pool,this,sep));
-            ptr = Apr.apr_array_pstrcat(pool,new IntPtr(mArray),sep);
@@ -158 +220 @@
-        }        
-
+        public void Push(byte o)
+        {
+            CheckPtr();
+            Marshal.WriteByte(Push(),o);
+        }
+
+        public void Push(short o)
+        {
+            CheckPtr();
+            Marshal.WriteInt16(Push(),o);
+        }
+        
+        public void Push(int o)
+        {
+            CheckPtr();
+            Marshal.WriteInt32(Push(),o);
+        }
+
+        public void Push(long o)
+        {
+            CheckPtr();
+            Marshal.WriteInt64(Push(),o);
+        }
+        
+        public void Push(IntPtr ptr)
+        {
+            CheckPtr();
+            Marshal.WriteIntPtr(Push(),ptr);
+        }
+        
-        public IntPtr Push()
-        {
@@ -170 +262 @@
-
-            return(ptr);
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        
-        public IntPtr Pop()
@@ -203 +331 @@
-        }        
-
+        public int AllocatedCount
+        {
+            get {
+                return(mArray->nalloc);
+            }
+        }
+        
+        public int ElementSize
+        {
+            get {
+                return(mArray->elt_size);
+            }
+        }
+        
+        public IntPtr Data
+        {
+            get {
+                return(mArray->elts);
+            }
+        }
+        #endregion
+        
+        #region ICollection
+        public void CopyTo(Array array, int arrayIndex)
+        {
+            if(null == array)
+                throw new AprArgumentNullException("array");
+            if(arrayIndex < 0 || arrayIndex > array.Length)
+                throw new AprArgumentOutOfRangeException("arrayIndex");
+            if(array.Rank > 1)
+                throw new AprArgumentException("array is multidimensional");
+            if((array.Length - arrayIndex) < Count)
+                throw new AprArgumentException("Not enough room from arrayIndex to end of array for this AprArray");
+            
+            int i = arrayIndex;
+            IEnumerator it = GetEnumerator();
+            while(it.MoveNext()) {
+                array.SetValue(it.Current, i++);
+            }
+        }
+        
+        public bool IsSynchronized 
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        public object SyncRoot 
+        {
+            get
+            {
+                return this;
+            }
+        }
+
-        public int Count
-        {
@@ -209 +394 @@
-            }
-        }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
-        }
-        #endregion
+
+    }
+    
+    public class AprArrayEnumerator : IEnumerator
+    {
+        AprArray mArray;
+        int mIndex;
+    
+        public AprArrayEnumerator(AprArray array)
+        {
+            mArray = array;
+            mIndex = -1;
+        }
+        
+        #region IEnumerator
+        public bool MoveNext()
+        {
+            if (++mIndex >= mArray.Count) {
+                mIndex = mArray.Count;
+                return(false);
+            }
+            return(true);
+        }
+        
+        public void Reset()
+        {
+            mIndex = -1;
+        }
+                
+        public object Current
+        {
+            get
+            {
+                if (mIndex < 0 || mIndex >= mArray.Count)
+                    throw new AprInvalidOperationException("No current item.");
+                
+                if(mArray.ElementType == null)
+                    throw new AprInvalidOperationException("Array not typed.");
+                                
+                if(mArray.ElementType.IsPrimitive)
+                {
+                    object val;
+                    switch(mArray.ElementSize)
+                    {
+                        case 1:
+                            val = Marshal.ReadByte(mArray.Data,mIndex);
+                            break;
+                        case 2:
+                            val = Marshal.ReadInt16(mArray.Data,mIndex*2);
+                            break;
+                        case 4:
+                            val = Marshal.ReadInt32(mArray.Data,mIndex*4);
+                            break;
+                        case 8:
+                            val = Marshal.ReadInt64(mArray.Data,mIndex*8);
+                            break;
+                        default:
+                            throw new AprInvalidOperationException("Invalid element size.");
+                    }
+                    return(Convert.ChangeType(val,mArray.ElementType));
+                }
+                
+                ConstructorInfo ctor = mArray.ElementType.GetConstructor(new Type[] {typeof(IntPtr)});
+                if( ctor == null )
+                    throw new AprInvalidOperationException("Type is not primitive and cannot be constructed from an IntPtr.");
+                
+                IntPtr ptr = Marshal.ReadIntPtr(mArray.Data,mIndex*mArray.ElementSize);
+                return(ctor.Invoke(new Object[] { ptr }));
+            }
+        }
+        #endregion
+
-    }
-}

trunk/AprSharp/dev/src/AprNullReferenceException.cs

@@ -12 +12 @@
-using System;
-using System.Runtime.Serialization;
-using Softec;
-
-namespace Softec.AprSharp

trunk/AprSharp/dev/src/AprSharp.prjx

@@ -20 +20 @@
-    <File name="./AprHashIndex.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
-    <File name="./AprArray.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
+    <File name="./AprInvalidOperationException.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
-  </Contents>
-  <References />

trunk/AprSharp/test/src/AprArrayTest.cs

@@ -99 +99 @@
-        
-        [Test]
+        public void PushPopObject()
+        {
+            AprPool p = AprPool.Create();
+            Assert.IsFalse(p.IsNull,"#B01");
+        
+            AprArray a = AprArray.Make(p,5,typeof(int));
+            Assert.IsFalse(a.IsNull,"#B02");
+            
+            a.Push(1);
+            a.Push(2);
+            a.Push(3);
+            a.Push(4);
+            a.Push(5);
+            
+            Assert.AreEqual(5,a.PopObject(),"#B05");
+            Assert.AreEqual(4,a.PopObject(),"#BO6");
+            Assert.AreEqual(3,a.PopObject(),"#BO7");
+            Assert.AreEqual(2,a.PopObject(),"#BO8");
+            Assert.AreEqual(1,a.PopObject(),"#BO9");
+
+            a = AprArray.Make(p,5,typeof(AprString));
+            
+            a.Push(new AprString(p,"This"));
+            a.Push(new AprString(p,"is"));
+            a.Push(new AprString(p,"a"));
+            a.Push(new AprString(p,"test."));
+
+            Assert.AreEqual("test.",a.PopObject().ToString(),"#B10");
+            Assert.AreEqual("a",a.PopObject().ToString(),"#B11");
+            Assert.AreEqual("is",a.PopObject().ToString(),"#B12");
+            Assert.AreEqual("This",a.PopObject().ToString(),"#B13");
+
+            p.Destroy();
+            Assert.IsTrue(p.IsNull,"#B14");
+        }
+        
+        [Test]
-        public void Copy()
-        {
@@ -205 +242 @@
-            p.Destroy();
-            Assert.IsTrue(p.IsNull,"#C04");
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    }
-}