src/mscorlib/src/System/Text/EncoderExceptionFallback.cs

   1 // Licensed to the .NET Foundation under one or more agreements.
   2 // The .NET Foundation licenses this file to you under the MIT license.
   3 // See the LICENSE file in the project root for more information.
   4
   5 using System;
   6 using System.Runtime.Serialization;
   7 using System.Diagnostics.Contracts;
   8
   9 namespace System.Text
  10 {
  11     public sealed class EncoderExceptionFallback : EncoderFallback
  12     {
  13         // Construction
  14         public EncoderExceptionFallback()
  15         {
  16         }
  17
  18         public override EncoderFallbackBuffer CreateFallbackBuffer()
  19         {
  20             return new EncoderExceptionFallbackBuffer();
  21         }
  22
  23         // Maximum number of characters that this instance of this fallback could return
  24         public override int MaxCharCount
  25         {
  26             get
  27             {
  28                 return 0;
  29             }
  30         }
  31
  32         public override bool Equals(Object value)
  33         {
  34             EncoderExceptionFallback that = value as EncoderExceptionFallback;
  35             if (that != null)
  36             {
  37                 return (true);
  38             }
  39             return (false);
  40         }
  41
  42         public override int GetHashCode()
  43         {
  44             return 654;
  45         }
  46     }
  47
  48
  49     public sealed class EncoderExceptionFallbackBuffer : EncoderFallbackBuffer
  50     {
  51         public EncoderExceptionFallbackBuffer() { }
  52         public override bool Fallback(char charUnknown, int index)
  53         {
  54             // Fall back our char
  55             throw new EncoderFallbackException(
  56                 SR.Format(SR.Argument_InvalidCodePageConversionIndex, (int)charUnknown, index), charUnknown, index);
  57         }
  58
  59         public override bool Fallback(char charUnknownHigh, char charUnknownLow, int index)
  60         {
  61             if (!Char.IsHighSurrogate(charUnknownHigh))
  62             {
  63                 throw new ArgumentOutOfRangeException(nameof(charUnknownHigh),
  64                     SR.Format(SR.ArgumentOutOfRange_Range, 0xD800, 0xDBFF));
  65             }
  66             if (!Char.IsLowSurrogate(charUnknownLow))
  67             {
  68                 throw new ArgumentOutOfRangeException(nameof(charUnknownLow),
  69                     SR.Format(SR.ArgumentOutOfRange_Range, 0xDC00, 0xDFFF));
  70             }
  71             Contract.EndContractBlock();
  72
  73             int iTemp = Char.ConvertToUtf32(charUnknownHigh, charUnknownLow);
  74
  75             // Fall back our char
  76             throw new EncoderFallbackException(
  77                 SR.Format(SR.Argument_InvalidCodePageConversionIndex, iTemp, index), charUnknownHigh, charUnknownLow, index);
  78         }
  79
  80         public override char GetNextChar()
  81         {
  82             return (char)0;
  83         }
  84
  85         public override bool MovePrevious()
  86         {
  87             // Exception fallback doesn't have anywhere to back up to.
  88             return false;
  89         }
  90
  91         // Exceptions are always empty
  92         public override int Remaining
  93         {
  94             get
  95             {
  96                 return 0;
  97             }
  98         }
  99     }
 100
 101     public sealed class EncoderFallbackException : ArgumentException
 102     {
 103         private char charUnknown;
 104         private char charUnknownHigh;
 105         private char charUnknownLow;
 106         private int index;
 107
 108         public EncoderFallbackException()
 109             : base(SR.Arg_ArgumentException)
 110         {
 111             HResult = __HResults.COR_E_ARGUMENT;
 112         }
 113
 114         public EncoderFallbackException(String message)
 115             : base(message)
 116         {
 117             HResult = __HResults.COR_E_ARGUMENT;
 118         }
 119
 120         public EncoderFallbackException(String message, Exception innerException)
 121             : base(message, innerException)
 122         {
 123             HResult = __HResults.COR_E_ARGUMENT;
 124         }
 125
 126         internal EncoderFallbackException(
 127             String message, char charUnknown, int index) : base(message)
 128         {
 129             this.charUnknown = charUnknown;
 130             this.index = index;
 131         }
 132
 133         internal EncoderFallbackException(
 134             String message, char charUnknownHigh, char charUnknownLow, int index) : base(message)
 135         {
 136             if (!Char.IsHighSurrogate(charUnknownHigh))
 137             {
 138                 throw new ArgumentOutOfRangeException(nameof(charUnknownHigh),
 139                     SR.Format(SR.ArgumentOutOfRange_Range, 0xD800, 0xDBFF));
 140             }
 141             if (!Char.IsLowSurrogate(charUnknownLow))
 142             {
 143                 throw new ArgumentOutOfRangeException(nameof(CharUnknownLow),
 144                     SR.Format(SR.ArgumentOutOfRange_Range, 0xDC00, 0xDFFF));
 145             }
 146             Contract.EndContractBlock();
 147
 148             this.charUnknownHigh = charUnknownHigh;
 149             this.charUnknownLow = charUnknownLow;
 150             this.index = index;
 151         }
 152
 153         public char CharUnknown
 154         {
 155             get
 156             {
 157                 return (charUnknown);
 158             }
 159         }
 160
 161         public char CharUnknownHigh
 162         {
 163             get
 164             {
 165                 return (charUnknownHigh);
 166             }
 167         }
 168
 169         public char CharUnknownLow
 170         {
 171             get
 172             {
 173                 return (charUnknownLow);
 174             }
 175         }
 176
 177         public int Index
 178         {
 179             get
 180             {
 181                 return index;
 182             }
 183         }
 184
 185         // Return true if the unknown character is a surrogate pair.
 186         public bool IsUnknownSurrogate()
 187         {
 188             return (charUnknownHigh != '\0');
 189         }
 190     }
 191 }