beagled/Lucene.Net/Analysis/ISOLatin1AccentFilter.cs

   1 /*
   2  * Copyright 2004-2005 The Apache Software Foundation
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 using System;
  18
  19 namespace Lucene.Net.Analysis
  20 {
  21
  22         /// <summary> A filter that replaces accented characters in the ISO Latin 1 character set
  23         /// (ISO-8859-1) by their unaccented equivalent. The case will not be altered.
  24         /// <p>
  25         /// For instance, '&agrave;' will be replaced by 'a'.
  26         /// <p>
  27         /// </summary>
  28         public class ISOLatin1AccentFilter : TokenFilter
  29         {
  30                 public ISOLatin1AccentFilter(TokenStream input) : base(input)
  31                 {
  32                 }
  33
  34                 public override Token Next()
  35                 {
  36                         Token t = input.Next();
  37                         if (t == null)
  38                                 return null;
  39                         // Return a token with filtered characters.
  40                         return new Token(RemoveAccents(t.TermText()), t.StartOffset(), t.EndOffset(), t.Type());
  41                 }
  42
  43                 /// <summary> To replace accented characters in a String by unaccented equivalents.</summary>
  44                 public static System.String RemoveAccents(System.String input)
  45                 {
  46                         System.Text.StringBuilder output = new System.Text.StringBuilder();
  47                         for (int i = 0; i < input.Length; i++)
  48                         {
  49                 long val = input[i];
  50
  51                                 switch (input[i])
  52                                 {
  53
  54                                         case '\u00C0':  // Ã€
  55                                         case '\u00C1':  // Ã?
  56                                         case '\u00C2':  // Ã‚
  57                                         case '\u00C3':  // Ãƒ
  58                                         case '\u00C4':  // Ã„
  59                                         case '\u00C5':  // Ã…
  60                                                 output.Append("A");
  61                                                 break;
  62
  63                                         case '\u00C6':  // Ã†
  64                                                 output.Append("AE");
  65                                                 break;
  66
  67                                         case '\u00C7':  // Ã‡
  68                                                 output.Append("C");
  69                                                 break;
  70
  71                                         case '\u00C8':  // Ãˆ
  72                                         case '\u00C9':  // Ã‰
  73                                         case '\u00CA':  // ÃŠ
  74                                         case '\u00CB':  // Ã‹
  75                                                 output.Append("E");
  76                                                 break;
  77
  78                                         case '\u00CC':  // ÃŒ
  79                                         case '\u00CD':  // Ã?
  80                                         case '\u00CE':  // ÃŽ
  81                                         case '\u00CF':  // Ã?
  82                                                 output.Append("I");
  83                                                 break;
  84
  85                                         case '\u00D0':  // Ã?
  86                                                 output.Append("D");
  87                                                 break;
  88
  89                                         case '\u00D1':  // Ã‘
  90                                                 output.Append("N");
  91                                                 break;
  92
  93                                         case '\u00D2':  // Ã’
  94                                         case '\u00D3':  // Ã“
  95                                         case '\u00D4':  // Ã”
  96                                         case '\u00D5':  // Ã•
  97                                         case '\u00D6':  // Ã–
  98                                         case '\u00D8':  // Ã˜
  99                                                 output.Append("O");
 100                                                 break;
 101
 102                                         case '\u0152':  // Å’
 103                                                 output.Append("OE");
 104                                                 break;
 105
 106                                         case '\u00DE':  // Ãž
 107                                                 output.Append("TH");
 108                                                 break;
 109
 110                                         case '\u00D9':  // Ã™
 111                                         case '\u00DA':  // Ãš
 112                                         case '\u00DB':  // Ã›
 113                                         case '\u00DC':  // Ãœ
 114                                                 output.Append("U");
 115                                                 break;
 116
 117                                         case '\u00DD':  // Ã?
 118                                         case '\u0178':  // Å¸
 119                                                 output.Append("Y");
 120                                                 break;
 121
 122                                         case '\u00E0':  // Ã
 123                                         case '\u00E1':  // Ã¡
 124                                         case '\u00E2':  // Ã¢
 125                                         case '\u00E3':  // Ã£
 126                                         case '\u00E4':  // Ã¤
 127                                         case '\u00E5':  // Ã¥
 128                                                 output.Append("a");
 129                                                 break;
 130
 131                                         case '\u00E6':  // Ã¦
 132                                                 output.Append("ae");
 133                                                 break;
 134
 135                                         case '\u00E7':  // Ã§
 136                                                 output.Append("c");
 137                                                 break;
 138
 139                                         case '\u00E8':  // Ã¨
 140                                         case '\u00E9':  // Ã©
 141                                         case '\u00EA':  // Ãª
 142                                         case '\u00EB':  // Ã«
 143                                                 output.Append("e");
 144                                                 break;
 145
 146                                         case '\u00EC':  // Ã¬
 147                                         case '\u00ED':  // Ã
 148                                         case '\u00EE':  // Ã®
 149                                         case '\u00EF':  // Ã¯
 150                                                 output.Append("i");
 151                                                 break;
 152
 153                                         case '\u00F0':  // Ã°
 154                                                 output.Append("d");
 155                                                 break;
 156
 157                                         case '\u00F1':  // Ã±
 158                                                 output.Append("n");
 159                                                 break;
 160
 161                                         case '\u00F2':  // Ã²
 162                                         case '\u00F3':  // Ã³
 163                                         case '\u00F4':  // Ã´
 164                                         case '\u00F5':  // Ãµ
 165                                         case '\u00F6':  // Ã¶
 166                                         case '\u00F8':  // Ã¸
 167                                                 output.Append("o");
 168                                                 break;
 169
 170                                         case '\u0153':  // Å“
 171                                                 output.Append("oe");
 172                                                 break;
 173
 174                                         case '\u00DF':  // ÃŸ
 175                                                 output.Append("ss");
 176                                                 break;
 177
 178                                         case '\u00FE':  // Ã¾
 179                                                 output.Append("th");
 180                                                 break;
 181
 182                                         case '\u00F9':  // Ã¹
 183                                         case '\u00FA':  // Ãº
 184                                         case '\u00FB':  // Ã»
 185                                         case '\u00FC':  // Ã¼
 186                                                 output.Append("u");
 187                                                 break;
 188
 189                                         case '\u00FD':  // Ã½
 190                                         case '\u00FF':  // Ã¿
 191                                                 output.Append("y");
 192                                                 break;
 193
 194                                         default:
 195                                                 output.Append(input[i]);
 196                                                 break;
 197
 198                                 }
 199                         }
 200                         return output.ToString();
 201                 }
 202         }
 203 }