2007-05-11 Jonathan Chambers <joncham@gmail.com>

[mono.git] / mcs / class / corlib / System.Text / Encoder.cs

diff --git a/mcs/class/corlib/System.Text/Encoder.cs b/mcs/class/corlib/System.Text/Encoder.cs
index 4fbe69b87a49e3f2d3ae99b2d9308f6c74314a41..320a600b9143a49fc94e402adc3a1c87550fa32e 100644 (file)
--- a/mcs/class/corlib/System.Text/Encoder.cs
+++ b/mcs/class/corlib/System.Text/Encoder.cs
@@ -26,14 +26,43 @@ namespace System.Text
 {
 
 using System;
+using System.Runtime.InteropServices;
 
 [Serializable]
+#if NET_2_0
+[ComVisible (true)]
+#endif
 public abstract class Encoder
 {
 
        // Constructor.
        protected Encoder() {}
 
+#if NET_2_0
+       EncoderFallback fallback = new EncoderReplacementFallback ();
+       EncoderFallbackBuffer fallback_buffer;
+
+       [ComVisible (false)]
+       public EncoderFallback Fallback {
+               get { return fallback; }
+               set {
+                       if (value == null)
+                               throw new ArgumentNullException ();
+                       fallback = value;
+                       fallback_buffer = null;
+               }
+       }
+
+       [ComVisible (false)]
+       public EncoderFallbackBuffer FallbackBuffer {
+               get {
+                       if (fallback_buffer == null)
+                               fallback_buffer = Fallback.CreateFallbackBuffer ();
+                       return fallback_buffer;
+               }
+       }
+#endif
+
        // Get the number of bytes needed to encode a buffer.
        public abstract int GetByteCount(char[] chars, int index,
                                                                         int count, bool flush);
@@ -42,6 +71,106 @@ public abstract class Encoder
        public abstract int GetBytes(char[] chars, int charIndex, int charCount,
                                                                 byte[] bytes, int byteIndex, bool flush);
 
+#if NET_2_0
+       [CLSCompliant (false)]
+       [ComVisible (false)]
+       public unsafe virtual int GetByteCount (char* chars, int charCount, bool flush)
+       {
+               if (chars == null)
+                       throw new ArgumentNullException ("chars");
+               if (charCount < 0)
+                       throw new ArgumentOutOfRangeException ("charCount");
+
+               char [] carr = new char [charCount];
+               Marshal.Copy ((IntPtr) chars, carr, 0, charCount);
+               return GetByteCount (carr, 0, charCount, flush);
+       }
+
+       [CLSCompliant (false)]
+       [ComVisible (false)]
+       public unsafe virtual int GetBytes (char* chars, int charCount,
+               byte* bytes, int byteCount, bool flush)
+       {
+               CheckArguments (chars, charCount, bytes, byteCount);
+
+               char [] carr = new char [charCount];
+               Marshal.Copy ((IntPtr) chars, carr, 0, charCount);
+               byte [] barr = new byte [byteCount];
+               Marshal.Copy ((IntPtr) bytes, barr, 0, byteCount);
+               return GetBytes (carr, 0, charCount, barr, 0, flush);
+       }
+
+       [ComVisible (false)]
+       public virtual void Reset ()
+       {
+               if (fallback_buffer != null)
+                       fallback_buffer.Reset ();
+       }
+
+       [CLSCompliant (false)]
+       [ComVisible (false)]
+       public unsafe virtual void Convert (
+               char* chars, int charCount,
+               byte* bytes, int byteCount, bool flush,
+               out int charsUsed, out int bytesUsed, out bool completed)
+       {
+               CheckArguments (chars, charCount, bytes, byteCount);
+
+               charsUsed = charCount;
+               while (true) {
+                       bytesUsed = GetByteCount (chars, charsUsed, flush);
+                       if (bytesUsed <= byteCount)
+                               break;
+                       flush = false;
+                       charsUsed >>= 1;
+               }
+               completed = charsUsed == charCount;
+               bytesUsed = GetBytes (chars, charsUsed, bytes, byteCount, flush);
+       }
+
+       [ComVisible (false)]
+       public virtual void Convert (
+               char [] chars, int charIndex, int charCount,
+               byte [] bytes, int byteIndex, int byteCount, bool flush,
+               out int charsUsed, out int bytesUsed, out bool completed)
+       {
+               if (chars == null)
+                       throw new ArgumentNullException ("chars");
+               if (bytes == null)
+                       throw new ArgumentNullException ("bytes");
+               if (charIndex < 0 || chars.Length <= charIndex)
+                       throw new ArgumentOutOfRangeException ("charIndex");
+               if (charCount < 0 || chars.Length < charIndex + charCount)
+                       throw new ArgumentOutOfRangeException ("charCount");
+               if (byteIndex < 0 || bytes.Length <= byteIndex)
+                       throw new ArgumentOutOfRangeException ("byteIndex");
+               if (byteCount < 0 || bytes.Length < byteIndex + byteCount)
+                       throw new ArgumentOutOfRangeException ("byteCount");
+
+               charsUsed = charCount;
+               while (true) {
+                       bytesUsed = GetByteCount (chars, charIndex, charsUsed, flush);
+                       if (bytesUsed <= byteCount)
+                               break;
+                       flush = false;
+                       charsUsed >>= 1;
+               }
+               completed = charsUsed == charCount;
+               bytesUsed = GetBytes (chars, charIndex, charsUsed, bytes, byteIndex, flush);
+       }
+
+       unsafe void CheckArguments (char* chars, int charCount, byte* bytes, int byteCount)
+       {
+               if (chars == null)
+                       throw new ArgumentNullException ("chars");
+               if (bytes == null)
+                       throw new ArgumentNullException ("bytes");
+               if (charCount < 0)
+                       throw new ArgumentOutOfRangeException ("charCount");
+               if (byteCount < 0)
+                       throw new ArgumentOutOfRangeException ("byteCount");
+       }
+#endif
 }; // class Encoder
 
 }; // namespace System.Text