netcore/System.Private.CoreLib/shared/System/Text/DecoderReplacementFallback.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.Diagnostics;
   6
   7 namespace System.Text
   8 {
   9     public sealed class DecoderReplacementFallback : DecoderFallback
  10     {
  11         // Our variables
  12         private readonly string _strDefault;
  13
  14         // Construction.  Default replacement fallback uses no best fit and ? replacement string
  15         public DecoderReplacementFallback() : this("?")
  16         {
  17         }
  18
  19         public DecoderReplacementFallback(string replacement)
  20         {
  21             if (replacement == null)
  22                 throw new ArgumentNullException(nameof(replacement));
  23
  24             // Make sure it doesn't have bad surrogate pairs
  25             bool bFoundHigh = false;
  26             for (int i = 0; i < replacement.Length; i++)
  27             {
  28                 // Found a surrogate?
  29                 if (char.IsSurrogate(replacement, i))
  30                 {
  31                     // High or Low?
  32                     if (char.IsHighSurrogate(replacement, i))
  33                     {
  34                         // if already had a high one, stop
  35                         if (bFoundHigh)
  36                             break;  // break & throw at the bFoundHIgh below
  37                         bFoundHigh = true;
  38                     }
  39                     else
  40                     {
  41                         // Low, did we have a high?
  42                         if (!bFoundHigh)
  43                         {
  44                             // Didn't have one, make if fail when we stop
  45                             bFoundHigh = true;
  46                             break;
  47                         }
  48
  49                         // Clear flag
  50                         bFoundHigh = false;
  51                     }
  52                 }
  53                 // If last was high we're in trouble (not surrogate so not low surrogate, so break)
  54                 else if (bFoundHigh)
  55                     break;
  56             }
  57             if (bFoundHigh)
  58                 throw new ArgumentException(SR.Format(SR.Argument_InvalidCharSequenceNoIndex, nameof(replacement)));
  59
  60             _strDefault = replacement;
  61         }
  62
  63         public string DefaultString => _strDefault;
  64
  65         public override DecoderFallbackBuffer CreateFallbackBuffer() =>
  66             new DecoderReplacementFallbackBuffer(this);
  67
  68         // Maximum number of characters that this instance of this fallback could return
  69         public override int MaxCharCount => _strDefault.Length;
  70
  71         public override bool Equals(object? value) =>
  72             value is DecoderReplacementFallback that &&
  73             _strDefault == that._strDefault;
  74
  75         public override int GetHashCode() => _strDefault.GetHashCode();
  76     }
  77
  78     public sealed class DecoderReplacementFallbackBuffer : DecoderFallbackBuffer
  79     {
  80         // Store our default string
  81         private readonly string _strDefault;
  82         private int _fallbackCount = -1;
  83         private int _fallbackIndex = -1;
  84
  85         // Construction
  86         public DecoderReplacementFallbackBuffer(DecoderReplacementFallback fallback)
  87         {
  88             _strDefault = fallback.DefaultString;
  89         }
  90
  91         // Fallback Methods
  92         public override bool Fallback(byte[] bytesUnknown, int index)
  93         {
  94             // We expect no previous fallback in our buffer
  95             // We can't call recursively but others might (note, we don't test on last char!!!)
  96             if (_fallbackCount >= 1)
  97             {
  98                 ThrowLastBytesRecursive(bytesUnknown);
  99             }
 100
 101             // Go ahead and get our fallback
 102             if (_strDefault.Length == 0)
 103                 return false;
 104
 105             _fallbackCount = _strDefault.Length;
 106             _fallbackIndex = -1;
 107
 108             return true;
 109         }
 110
 111         public override char GetNextChar()
 112         {
 113             // We want it to get < 0 because == 0 means that the current/last character is a fallback
 114             // and we need to detect recursion.  We could have a flag but we already have this counter.
 115             _fallbackCount--;
 116             _fallbackIndex++;
 117
 118             // Do we have anything left? 0 is now last fallback char, negative is nothing left
 119             if (_fallbackCount < 0)
 120                 return '\0';
 121
 122             // Need to get it out of the buffer.
 123             // Make sure it didn't wrap from the fast count-- path
 124             if (_fallbackCount == int.MaxValue)
 125             {
 126                 _fallbackCount = -1;
 127                 return '\0';
 128             }
 129
 130             // Now make sure its in the expected range
 131             Debug.Assert(_fallbackIndex < _strDefault.Length && _fallbackIndex >= 0,
 132                             "Index exceeds buffer range");
 133
 134             return _strDefault[_fallbackIndex];
 135         }
 136
 137         public override bool MovePrevious()
 138         {
 139             // Back up one, only if we just processed the last character (or earlier)
 140             if (_fallbackCount >= -1 && _fallbackIndex >= 0)
 141             {
 142                 _fallbackIndex--;
 143                 _fallbackCount++;
 144                 return true;
 145             }
 146
 147             // Return false 'cause we couldn't do it.
 148             return false;
 149         }
 150
 151         // How many characters left to output?
 152         public override int Remaining =>
 153             // Our count is 0 for 1 character left.
 154             (_fallbackCount < 0) ? 0 : _fallbackCount;
 155
 156         // Clear the buffer
 157         public override unsafe void Reset()
 158         {
 159             _fallbackCount = -1;
 160             _fallbackIndex = -1;
 161             byteStart = null;
 162         }
 163
 164         // This version just counts the fallback and doesn't actually copy anything.
 165         internal override unsafe int InternalFallback(byte[] bytes, byte* pBytes) =>
 166             // Right now this has both bytes and bytes[], since we might have extra bytes,
 167             // hence the array, and we might need the index, hence the byte*.
 168             // Return our replacement string Length
 169             _strDefault.Length;
 170     }
 171 }