From 6b4e1da5bfc33f9bbba33ea869495839726d0669 Mon Sep 17 00:00:00 2001 From: GoldenCrystal Date: Tue, 16 Dec 2014 00:53:15 +0100 Subject: [PATCH] Masked some unsupported IList and ICollection members. Added more XML documentation tags. --- UnicodeInformation/CanonicalCombiningClass.cs | 215 ++++++++++++++++++ UnicodeInformation/CodePointEnumerator.cs | 8 + UnicodeInformation/ContributoryProperties.cs | 79 ++++++- .../PermissiveCodePointEnumerator.cs | 8 + UnicodeInformation/UnicodeBlock.cs | 3 + .../UnicodeCrossReferenceCollection.cs | 10 +- .../UnicodeNameAliasCollection.cs | 28 ++- .../UnicodeRadicalStrokeCountCollection.cs | 10 +- UnicodeInformation/UnihanNumericType.cs | 7 + 9 files changed, 345 insertions(+), 23 deletions(-) diff --git a/UnicodeInformation/CanonicalCombiningClass.cs b/UnicodeInformation/CanonicalCombiningClass.cs index 9b6a10a..3c0c4d1 100644 --- a/UnicodeInformation/CanonicalCombiningClass.cs +++ b/UnicodeInformation/CanonicalCombiningClass.cs @@ -2,434 +2,649 @@ namespace System.Unicode { + /// Represent known values for the Canonical_Combining_Class property. public enum CanonicalCombiningClass : byte { + /// Represents the value Not_Reordered. [ValueName("Not_Reordered"), Display(Name = "Not_Reordered", Description = "Spacing and enclosing marks; also many vowel and consonant signs, even if nonspacing")] NotReordered = 0, + /// Represents the value Overlay. [ValueName("Overlay"), Display(Name = "Overlay", Description = "Marks which overlay a base letter or symbol")] Overlay = 1, + /// Represents the value Nukta. [ValueName("Nukta"), Display(Name = "Nukta", Description = "Diacritic nukta marks in Brahmi-derived scripts")] Nukta = 7, + /// Represents the value Kana_Voicing. [ValueName("Kana_Voicing"), Display(Name = "Kana_Voicing", Description = "Hiragana/Katakana voicing marks")] KanaVoicing = 8, + /// Represents the value Virama. [ValueName("Virama"), Display(Name = "Virama", Description = "Viramas")] Virama = 9, + /// Represents the value Ccc10. [ValueName("Ccc10"), Display(Name = "Ccc10", Description = "Start of fixed position classes")] Ccc10 = 10, + /// Represents the value Ccc11. [ValueName("Ccc11"), Display(Name = "Ccc11")] Ccc11 = 11, + /// Represents the value Ccc12. [ValueName("Ccc12"), Display(Name = "Ccc12")] Ccc12 = 12, + /// Represents the value Ccc13. [ValueName("Ccc13"), Display(Name = "Ccc13")] Ccc13 = 13, + /// Represents the value Ccc14. [ValueName("Ccc14"), Display(Name = "Ccc14")] Ccc14 = 14, + /// Represents the value Ccc15. [ValueName("Ccc15"), Display(Name = "Ccc15")] Ccc15 = 15, + /// Represents the value Ccc16. [ValueName("Ccc16"), Display(Name = "Ccc16")] Ccc16 = 16, + /// Represents the value Ccc17. [ValueName("Ccc17"), Display(Name = "Ccc17")] Ccc17 = 17, + /// Represents the value Ccc18. [ValueName("Ccc18"), Display(Name = "Ccc18")] Ccc18 = 18, + /// Represents the value Ccc19. [ValueName("Ccc19"), Display(Name = "Ccc19")] Ccc19 = 19, + /// Represents the value Ccc20. [ValueName("Ccc20"), Display(Name = "Ccc20")] Ccc20 = 20, + /// Represents the value Ccc21. [ValueName("Ccc21"), Display(Name = "Ccc21")] Ccc21 = 21, + /// Represents the value Ccc22. [ValueName("Ccc22"), Display(Name = "Ccc22")] Ccc22 = 22, + /// Represents the value Ccc23. [ValueName("Ccc23"), Display(Name = "Ccc23")] Ccc23 = 23, + /// Represents the value Ccc24. [ValueName("Ccc24"), Display(Name = "Ccc24")] Ccc24 = 24, + /// Represents the value Ccc25. [ValueName("Ccc25"), Display(Name = "Ccc25")] Ccc25 = 25, + /// Represents the value Ccc26. [ValueName("Ccc26"), Display(Name = "Ccc26")] Ccc26 = 26, + /// Represents the value Ccc27. [ValueName("Ccc27"), Display(Name = "Ccc27")] Ccc27 = 27, + /// Represents the value Ccc28. [ValueName("Ccc28"), Display(Name = "Ccc28")] Ccc28 = 28, + /// Represents the value Ccc29. [ValueName("Ccc29"), Display(Name = "Ccc29")] Ccc29 = 29, + /// Represents the value Ccc30. [ValueName("Ccc30"), Display(Name = "Ccc30")] Ccc30 = 30, + /// Represents the value Ccc31. [ValueName("Ccc31"), Display(Name = "Ccc31")] Ccc31 = 31, + /// Represents the value Ccc32. [ValueName("Ccc32"), Display(Name = "Ccc32")] Ccc32 = 32, + /// Represents the value Ccc33. [ValueName("Ccc33"), Display(Name = "Ccc33")] Ccc33 = 33, + /// Represents the value Ccc34. [ValueName("Ccc34"), Display(Name = "Ccc34")] Ccc34 = 34, + /// Represents the value Ccc35. [ValueName("Ccc35"), Display(Name = "Ccc35")] Ccc35 = 35, + /// Represents the value Ccc36. [ValueName("Ccc36"), Display(Name = "Ccc36")] Ccc36 = 36, + /// Represents the value Ccc37. [ValueName("Ccc37"), Display(Name = "Ccc37")] Ccc37 = 37, + /// Represents the value Ccc38. [ValueName("Ccc38"), Display(Name = "Ccc38")] Ccc38 = 38, + /// Represents the value Ccc39. [ValueName("Ccc39"), Display(Name = "Ccc39")] Ccc39 = 39, + /// Represents the value Ccc40. [ValueName("Ccc40"), Display(Name = "Ccc40")] Ccc40 = 40, + /// Represents the value Ccc41. [ValueName("Ccc41"), Display(Name = "Ccc41")] Ccc41 = 41, + /// Represents the value Ccc42. [ValueName("Ccc42"), Display(Name = "Ccc42")] Ccc42 = 42, + /// Represents the value Ccc43. [ValueName("Ccc43"), Display(Name = "Ccc43")] Ccc43 = 43, + /// Represents the value Ccc44. [ValueName("Ccc44"), Display(Name = "Ccc44")] Ccc44 = 44, + /// Represents the value Ccc45. [ValueName("Ccc45"), Display(Name = "Ccc45")] Ccc45 = 45, + /// Represents the value Ccc46. [ValueName("Ccc46"), Display(Name = "Ccc46")] Ccc46 = 46, + /// Represents the value Ccc47. [ValueName("Ccc47"), Display(Name = "Ccc47")] Ccc47 = 47, + /// Represents the value Ccc48. [ValueName("Ccc48"), Display(Name = "Ccc48")] Ccc48 = 48, + /// Represents the value Ccc49. [ValueName("Ccc49"), Display(Name = "Ccc49")] Ccc49 = 49, + /// Represents the value Ccc50. [ValueName("Ccc50"), Display(Name = "Ccc50")] Ccc50 = 50, + /// Represents the value Ccc51. [ValueName("Ccc51"), Display(Name = "Ccc51")] Ccc51 = 51, + /// Represents the value Ccc52. [ValueName("Ccc52"), Display(Name = "Ccc52")] Ccc52 = 52, + /// Represents the value Ccc53. [ValueName("Ccc53"), Display(Name = "Ccc53")] Ccc53 = 53, + /// Represents the value Ccc54. [ValueName("Ccc54"), Display(Name = "Ccc54")] Ccc54 = 54, + /// Represents the value Ccc55. [ValueName("Ccc55"), Display(Name = "Ccc55")] Ccc55 = 55, + /// Represents the value Ccc56. [ValueName("Ccc56"), Display(Name = "Ccc56")] Ccc56 = 56, + /// Represents the value Ccc57. [ValueName("Ccc57"), Display(Name = "Ccc57")] Ccc57 = 57, + /// Represents the value Ccc58. [ValueName("Ccc58"), Display(Name = "Ccc58")] Ccc58 = 58, + /// Represents the value Ccc59. [ValueName("Ccc59"), Display(Name = "Ccc59")] Ccc59 = 59, + /// Represents the value Ccc60. [ValueName("Ccc60"), Display(Name = "Ccc60")] Ccc60 = 60, + /// Represents the value Ccc61. [ValueName("Ccc61"), Display(Name = "Ccc61")] Ccc61 = 61, + /// Represents the value Ccc62. [ValueName("Ccc62"), Display(Name = "Ccc62")] Ccc62 = 62, + /// Represents the value Ccc63. [ValueName("Ccc63"), Display(Name = "Ccc63")] Ccc63 = 63, + /// Represents the value Ccc64. [ValueName("Ccc64"), Display(Name = "Ccc64")] Ccc64 = 64, + /// Represents the value Ccc65. [ValueName("Ccc65"), Display(Name = "Ccc65")] Ccc65 = 65, + /// Represents the value Ccc66. [ValueName("Ccc66"), Display(Name = "Ccc66")] Ccc66 = 66, + /// Represents the value Ccc67. [ValueName("Ccc67"), Display(Name = "Ccc67")] Ccc67 = 67, + /// Represents the value Ccc68. [ValueName("Ccc68"), Display(Name = "Ccc68")] Ccc68 = 68, + /// Represents the value Ccc69. [ValueName("Ccc69"), Display(Name = "Ccc69")] Ccc69 = 69, + /// Represents the value Ccc70. [ValueName("Ccc70"), Display(Name = "Ccc70")] Ccc70 = 70, + /// Represents the value Ccc71. [ValueName("Ccc71"), Display(Name = "Ccc71")] Ccc71 = 71, + /// Represents the value Ccc72. [ValueName("Ccc72"), Display(Name = "Ccc72")] Ccc72 = 72, + /// Represents the value Ccc73. [ValueName("Ccc73"), Display(Name = "Ccc73")] Ccc73 = 73, + /// Represents the value Ccc74. [ValueName("Ccc74"), Display(Name = "Ccc74")] Ccc74 = 74, + /// Represents the value Ccc75. [ValueName("Ccc75"), Display(Name = "Ccc75")] Ccc75 = 75, + /// Represents the value Ccc76. [ValueName("Ccc76"), Display(Name = "Ccc76")] Ccc76 = 76, + /// Represents the value Ccc77. [ValueName("Ccc77"), Display(Name = "Ccc77")] Ccc77 = 77, + /// Represents the value Ccc78. [ValueName("Ccc78"), Display(Name = "Ccc78")] Ccc78 = 78, + /// Represents the value Ccc79. [ValueName("Ccc79"), Display(Name = "Ccc79")] Ccc79 = 79, + /// Represents the value Ccc80. [ValueName("Ccc80"), Display(Name = "Ccc80")] Ccc80 = 80, + /// Represents the value Ccc81. [ValueName("Ccc81"), Display(Name = "Ccc81")] Ccc81 = 81, + /// Represents the value Ccc82. [ValueName("Ccc82"), Display(Name = "Ccc82")] Ccc82 = 82, + /// Represents the value Ccc83. [ValueName("Ccc83"), Display(Name = "Ccc83")] Ccc83 = 83, + /// Represents the value Ccc84. [ValueName("Ccc84"), Display(Name = "Ccc84")] Ccc84 = 84, + /// Represents the value Ccc85. [ValueName("Ccc85"), Display(Name = "Ccc85")] Ccc85 = 85, + /// Represents the value Ccc86. [ValueName("Ccc86"), Display(Name = "Ccc86")] Ccc86 = 86, + /// Represents the value Ccc87. [ValueName("Ccc87"), Display(Name = "Ccc87")] Ccc87 = 87, + /// Represents the value Ccc88. [ValueName("Ccc88"), Display(Name = "Ccc88")] Ccc88 = 88, + /// Represents the value Ccc89. [ValueName("Ccc89"), Display(Name = "Ccc89")] Ccc89 = 89, + /// Represents the value Ccc90. [ValueName("Ccc90"), Display(Name = "Ccc90")] Ccc90 = 90, + /// Represents the value Ccc91. [ValueName("Ccc91"), Display(Name = "Ccc91")] Ccc91 = 91, + /// Represents the value Ccc92. [ValueName("Ccc92"), Display(Name = "Ccc92")] Ccc92 = 92, + /// Represents the value Ccc93. [ValueName("Ccc93"), Display(Name = "Ccc93")] Ccc93 = 93, + /// Represents the value Ccc94. [ValueName("Ccc94"), Display(Name = "Ccc94")] Ccc94 = 94, + /// Represents the value Ccc95. [ValueName("Ccc95"), Display(Name = "Ccc95")] Ccc95 = 95, + /// Represents the value Ccc96. [ValueName("Ccc96"), Display(Name = "Ccc96")] Ccc96 = 96, + /// Represents the value Ccc97. [ValueName("Ccc97"), Display(Name = "Ccc97")] Ccc97 = 97, + /// Represents the value Ccc98. [ValueName("Ccc98"), Display(Name = "Ccc98")] Ccc98 = 98, + /// Represents the value Ccc99. [ValueName("Ccc99"), Display(Name = "Ccc99")] Ccc99 = 99, + /// Represents the value Ccc100. [ValueName("Ccc100"), Display(Name = "Ccc100")] Ccc100 = 100, + /// Represents the value Ccc101. [ValueName("Ccc101"), Display(Name = "Ccc101")] Ccc101 = 101, + /// Represents the value Ccc102. [ValueName("Ccc102"), Display(Name = "Ccc102")] Ccc102 = 102, + /// Represents the value Ccc103. [ValueName("Ccc103"), Display(Name = "Ccc103")] Ccc103 = 103, + /// Represents the value Ccc104. [ValueName("Ccc104"), Display(Name = "Ccc104")] Ccc104 = 104, + /// Represents the value Ccc105. [ValueName("Ccc105"), Display(Name = "Ccc105")] Ccc105 = 105, + /// Represents the value Ccc106. [ValueName("Ccc106"), Display(Name = "Ccc106")] Ccc106 = 106, + /// Represents the value Ccc107. [ValueName("Ccc107"), Display(Name = "Ccc107")] Ccc107 = 107, + /// Represents the value Ccc108. [ValueName("Ccc108"), Display(Name = "Ccc108")] Ccc108 = 108, + /// Represents the value Ccc109. [ValueName("Ccc109"), Display(Name = "Ccc109")] Ccc109 = 109, + /// Represents the value Ccc110. [ValueName("Ccc110"), Display(Name = "Ccc110")] Ccc110 = 110, + /// Represents the value Ccc111. [ValueName("Ccc111"), Display(Name = "Ccc111")] Ccc111 = 111, + /// Represents the value Ccc112. [ValueName("Ccc112"), Display(Name = "Ccc112")] Ccc112 = 112, + /// Represents the value Ccc113. [ValueName("Ccc113"), Display(Name = "Ccc113")] Ccc113 = 113, + /// Represents the value Ccc114. [ValueName("Ccc114"), Display(Name = "Ccc114")] Ccc114 = 114, + /// Represents the value Ccc115. [ValueName("Ccc115"), Display(Name = "Ccc115")] Ccc115 = 115, + /// Represents the value Ccc116. [ValueName("Ccc116"), Display(Name = "Ccc116")] Ccc116 = 116, + /// Represents the value Ccc117. [ValueName("Ccc117"), Display(Name = "Ccc117")] Ccc117 = 117, + /// Represents the value Ccc118. [ValueName("Ccc118"), Display(Name = "Ccc118")] Ccc118 = 118, + /// Represents the value Ccc119. [ValueName("Ccc119"), Display(Name = "Ccc119")] Ccc119 = 119, + /// Represents the value Ccc120. [ValueName("Ccc120"), Display(Name = "Ccc120")] Ccc120 = 120, + /// Represents the value Ccc121. [ValueName("Ccc121"), Display(Name = "Ccc121")] Ccc121 = 121, + /// Represents the value Ccc122. [ValueName("Ccc122"), Display(Name = "Ccc122")] Ccc122 = 122, + /// Represents the value Ccc123. [ValueName("Ccc123"), Display(Name = "Ccc123")] Ccc123 = 123, + /// Represents the value Ccc124. [ValueName("Ccc124"), Display(Name = "Ccc124")] Ccc124 = 124, + /// Represents the value Ccc125. [ValueName("Ccc125"), Display(Name = "Ccc125")] Ccc125 = 125, + /// Represents the value Ccc126. [ValueName("Ccc126"), Display(Name = "Ccc126")] Ccc126 = 126, + /// Represents the value Ccc127. [ValueName("Ccc127"), Display(Name = "Ccc127")] Ccc127 = 127, + /// Represents the value Ccc128. [ValueName("Ccc128"), Display(Name = "Ccc128")] Ccc128 = 128, + /// Represents the value Ccc129. [ValueName("Ccc129"), Display(Name = "Ccc129")] Ccc129 = 129, + /// Represents the value Ccc130. [ValueName("Ccc130"), Display(Name = "Ccc130")] Ccc130 = 130, + /// Represents the value Ccc131. [ValueName("Ccc131"), Display(Name = "Ccc131")] Ccc131 = 131, + /// Represents the value Ccc132. [ValueName("Ccc132"), Display(Name = "Ccc132")] Ccc132 = 132, + /// Represents the value Ccc133. [ValueName("Ccc133"), Display(Name = "Ccc133")] Ccc133 = 133, + /// Represents the value Ccc134. [ValueName("Ccc134"), Display(Name = "Ccc134")] Ccc134 = 134, + /// Represents the value Ccc135. [ValueName("Ccc135"), Display(Name = "Ccc135")] Ccc135 = 135, + /// Represents the value Ccc136. [ValueName("Ccc136"), Display(Name = "Ccc136")] Ccc136 = 136, + /// Represents the value Ccc137. [ValueName("Ccc137"), Display(Name = "Ccc137")] Ccc137 = 137, + /// Represents the value Ccc138. [ValueName("Ccc138"), Display(Name = "Ccc138")] Ccc138 = 138, + /// Represents the value Ccc139. [ValueName("Ccc139"), Display(Name = "Ccc139")] Ccc139 = 139, + /// Represents the value Ccc140. [ValueName("Ccc140"), Display(Name = "Ccc140")] Ccc140 = 140, + /// Represents the value Ccc141. [ValueName("Ccc141"), Display(Name = "Ccc141")] Ccc141 = 141, + /// Represents the value Ccc142. [ValueName("Ccc142"), Display(Name = "Ccc142")] Ccc142 = 142, + /// Represents the value Ccc143. [ValueName("Ccc143"), Display(Name = "Ccc143")] Ccc143 = 143, + /// Represents the value Ccc144. [ValueName("Ccc144"), Display(Name = "Ccc144")] Ccc144 = 144, + /// Represents the value Ccc145. [ValueName("Ccc145"), Display(Name = "Ccc145")] Ccc145 = 145, + /// Represents the value Ccc146. [ValueName("Ccc146"), Display(Name = "Ccc146")] Ccc146 = 146, + /// Represents the value Ccc147. [ValueName("Ccc147"), Display(Name = "Ccc147")] Ccc147 = 147, + /// Represents the value Ccc148. [ValueName("Ccc148"), Display(Name = "Ccc148")] Ccc148 = 148, + /// Represents the value Ccc149. [ValueName("Ccc149"), Display(Name = "Ccc149")] Ccc149 = 149, + /// Represents the value Ccc150. [ValueName("Ccc150"), Display(Name = "Ccc150")] Ccc150 = 150, + /// Represents the value Ccc151. [ValueName("Ccc151"), Display(Name = "Ccc151")] Ccc151 = 151, + /// Represents the value Ccc152. [ValueName("Ccc152"), Display(Name = "Ccc152")] Ccc152 = 152, + /// Represents the value Ccc153. [ValueName("Ccc153"), Display(Name = "Ccc153")] Ccc153 = 153, + /// Represents the value Ccc154. [ValueName("Ccc154"), Display(Name = "Ccc154")] Ccc154 = 154, + /// Represents the value Ccc155. [ValueName("Ccc155"), Display(Name = "Ccc155")] Ccc155 = 155, + /// Represents the value Ccc156. [ValueName("Ccc156"), Display(Name = "Ccc156")] Ccc156 = 156, + /// Represents the value Ccc157. [ValueName("Ccc157"), Display(Name = "Ccc157")] Ccc157 = 157, + /// Represents the value Ccc158. [ValueName("Ccc158"), Display(Name = "Ccc158")] Ccc158 = 158, + /// Represents the value Ccc159. [ValueName("Ccc159"), Display(Name = "Ccc159")] Ccc159 = 159, + /// Represents the value Ccc160. [ValueName("Ccc160"), Display(Name = "Ccc160")] Ccc160 = 160, + /// Represents the value Ccc161. [ValueName("Ccc161"), Display(Name = "Ccc161")] Ccc161 = 161, + /// Represents the value Ccc162. [ValueName("Ccc162"), Display(Name = "Ccc162")] Ccc162 = 162, + /// Represents the value Ccc163. [ValueName("Ccc163"), Display(Name = "Ccc163")] Ccc163 = 163, + /// Represents the value Ccc164. [ValueName("Ccc164"), Display(Name = "Ccc164")] Ccc164 = 164, + /// Represents the value Ccc165. [ValueName("Ccc165"), Display(Name = "Ccc165")] Ccc165 = 165, + /// Represents the value Ccc166. [ValueName("Ccc166"), Display(Name = "Ccc166")] Ccc166 = 166, + /// Represents the value Ccc167. [ValueName("Ccc167"), Display(Name = "Ccc167")] Ccc167 = 167, + /// Represents the value Ccc168. [ValueName("Ccc168"), Display(Name = "Ccc168")] Ccc168 = 168, + /// Represents the value Ccc169. [ValueName("Ccc169"), Display(Name = "Ccc169")] Ccc169 = 169, + /// Represents the value Ccc170. [ValueName("Ccc170"), Display(Name = "Ccc170")] Ccc170 = 170, + /// Represents the value Ccc171. [ValueName("Ccc171"), Display(Name = "Ccc171")] Ccc171 = 171, + /// Represents the value Ccc172. [ValueName("Ccc172"), Display(Name = "Ccc172")] Ccc172 = 172, + /// Represents the value Ccc173. [ValueName("Ccc173"), Display(Name = "Ccc173")] Ccc173 = 173, + /// Represents the value Ccc174. [ValueName("Ccc174"), Display(Name = "Ccc174")] Ccc174 = 174, + /// Represents the value Ccc175. [ValueName("Ccc175"), Display(Name = "Ccc175")] Ccc175 = 175, + /// Represents the value Ccc176. [ValueName("Ccc176"), Display(Name = "Ccc176")] Ccc176 = 176, + /// Represents the value Ccc177. [ValueName("Ccc177"), Display(Name = "Ccc177")] Ccc177 = 177, + /// Represents the value Ccc178. [ValueName("Ccc178"), Display(Name = "Ccc178")] Ccc178 = 178, + /// Represents the value Ccc179. [ValueName("Ccc179"), Display(Name = "Ccc179")] Ccc179 = 179, + /// Represents the value Ccc180. [ValueName("Ccc180"), Display(Name = "Ccc180")] Ccc180 = 180, + /// Represents the value Ccc181. [ValueName("Ccc181"), Display(Name = "Ccc181")] Ccc181 = 181, + /// Represents the value Ccc182. [ValueName("Ccc182"), Display(Name = "Ccc182")] Ccc182 = 182, + /// Represents the value Ccc183. [ValueName("Ccc183"), Display(Name = "Ccc183")] Ccc183 = 183, + /// Represents the value Ccc184. [ValueName("Ccc184"), Display(Name = "Ccc184")] Ccc184 = 184, + /// Represents the value Ccc185. [ValueName("Ccc185"), Display(Name = "Ccc185")] Ccc185 = 185, + /// Represents the value Ccc186. [ValueName("Ccc186"), Display(Name = "Ccc186")] Ccc186 = 186, + /// Represents the value Ccc187. [ValueName("Ccc187"), Display(Name = "Ccc187")] Ccc187 = 187, + /// Represents the value Ccc188. [ValueName("Ccc188"), Display(Name = "Ccc188")] Ccc188 = 188, + /// Represents the value Ccc189. [ValueName("Ccc189"), Display(Name = "Ccc189")] Ccc189 = 189, + /// Represents the value Ccc190. [ValueName("Ccc190"), Display(Name = "Ccc190")] Ccc190 = 190, + /// Represents the value Ccc191. [ValueName("Ccc191"), Display(Name = "Ccc191")] Ccc191 = 191, + /// Represents the value Ccc192. [ValueName("Ccc192"), Display(Name = "Ccc192")] Ccc192 = 192, + /// Represents the value Ccc193. [ValueName("Ccc193"), Display(Name = "Ccc193")] Ccc193 = 193, + /// Represents the value Ccc194. [ValueName("Ccc194"), Display(Name = "Ccc194")] Ccc194 = 194, + /// Represents the value Ccc195. [ValueName("Ccc195"), Display(Name = "Ccc195")] Ccc195 = 195, + /// Represents the value Ccc196. [ValueName("Ccc196"), Display(Name = "Ccc196")] Ccc196 = 196, + /// Represents the value Ccc197. [ValueName("Ccc197"), Display(Name = "Ccc197")] Ccc197 = 197, + /// Represents the value Ccc198. [ValueName("Ccc198"), Display(Name = "Ccc198")] Ccc198 = 198, + /// Represents the value Ccc199. [ValueName("Ccc199"), Display(Name = "Ccc199", Description = "End of fixed position classes")] Ccc199 = 199, + /// Represents the value Attached_Below_Left. [ValueName("Attached_Below_Left"), Display(Name = "Attached_Below_Left", Description = "Marks attached at the bottom left")] AttachedBelowLeft = 200, + /// Represents the value Attached_Below. [ValueName("Attached_Below"), Display(Name = "Attached_Below", Description = "Marks attached directly below")] AttachedBelow = 202, + /// Represents the value Attached_Below_Right. [ValueName("Attached_Below_Right"), Display(Name = "Attached_Below_Right", Description = "Marks attached at the bottom right")] AttachedBelowRight = 204, + /// Represents the value Attached_Left. [ValueName("Attached_Left"), Display(Name = "Attached_Left", Description = "Marks attached to the left")] AttachedLeft = 208, + /// Represents the value Attached_Right. [ValueName("Attached_Right"), Display(Name = "Attached_Right", Description = "Marks attached to the right")] AttachedRight = 210, + /// Represents the value Attached_Above_Left. [ValueName("Attached_Above_Left"), Display(Name = "Attached_Above_Left", Description = "Marks attached at the top left")] AttachedAboveLeft = 212, + /// Represents the value Attached_Above. [ValueName("Attached_Above"), Display(Name = "Attached_Above", Description = "Marks attached directly above")] AttachedAbove = 214, + /// Represents the value Attached_Above_Right. [ValueName("Attached_Above_Right"), Display(Name = "Attached_Above_Right", Description = "Marks attached at the top right")] AttachedAboveRight = 216, + /// Represents the value Below_Left. [ValueName("Below_Left"), Display(Name = "Below_Left", Description = "Distinct marks at the bottom left")] BelowLeft = 218, + /// Represents the value Below. [ValueName("Below"), Display(Name = "Below", Description = "Distinct marks directly below")] Below = 220, + /// Represents the value Below_Right. [ValueName("Below_Right"), Display(Name = "Below_Right", Description = "Distinct marks at the bottom right")] BelowRight = 222, + /// Represents the value Left. [ValueName("Left"), Display(Name = "Left", Description = "Distinct marks to the left")] Left = 224, + /// Represents the value Right. [ValueName("Right"), Display(Name = "Right", Description = "Distinct marks to the right")] Right = 226, + /// Represents the value Above_Left. [ValueName("Above_Left"), Display(Name = "Above_Left", Description = "Distinct marks at the top left")] AboveLeft = 228, + /// Represents the value Above. [ValueName("Above"), Display(Name = "Above", Description = "Distinct marks directly above")] Above = 230, + /// Represents the value Above_Right. [ValueName("Above_Right"), Display(Name = "Above_Right", Description = "Distinct marks at the top right")] AboveRight = 232, + /// Represents the value Double_Below. [ValueName("Double_Below"), Display(Name = "Double_Below", Description = "Distinct marks subtending two bases")] DoubleBelow = 233, + /// Represents the value Double_Above. [ValueName("Double_Above"), Display(Name = "Double_Above", Description = "Distinct marks extending above two bases")] DoubleAbove = 234, + /// Represents the value Iota_Subscript. [ValueName("Iota_Subscript"), Display(Name = "Iota_Subscript", Description = "Greek iota subscript only")] IotaSubscript = 240, } diff --git a/UnicodeInformation/CodePointEnumerator.cs b/UnicodeInformation/CodePointEnumerator.cs index 84ca0bc..58d6a02 100644 --- a/UnicodeInformation/CodePointEnumerator.cs +++ b/UnicodeInformation/CodePointEnumerator.cs @@ -7,12 +7,16 @@ using System.Threading.Tasks; namespace System.Unicode { + /// Supports a standard iteration of code points in a . public struct CodePointEnumerator : IEnumerator { private readonly string text; private int current; private int index; + /// Initializes a new instance of the struct. + /// The text whose code point should be enumerated. + /// is . public CodePointEnumerator(string text) { if (text == null) throw new ArgumentNullException(nameof(text)); @@ -22,12 +26,16 @@ namespace System.Unicode this.index = -1; } + /// Gets the element in the collection at the current position of the enumerator.. + /// The element in the collection at the current position of the enumerator. public int Current { get { return current; } } object IEnumerator.Current { get { return current; } } void IDisposable.Dispose() { } + /// Advances the enumerator to the next element of the collection. + /// if the enumerator was successfully advanced to the next element; if the enumerator has passed the end of the collection. public bool MoveNext() { if (index < text.Length && (index += current > 0xFFFF ? 2 : 1) < text.Length) diff --git a/UnicodeInformation/ContributoryProperties.cs b/UnicodeInformation/ContributoryProperties.cs index 43cf527..88061a5 100644 --- a/UnicodeInformation/ContributoryProperties.cs +++ b/UnicodeInformation/ContributoryProperties.cs @@ -7,73 +7,136 @@ using System.Threading.Tasks; namespace System.Unicode { + /// A bitmask of the various available contributory properties. [Flags] public enum ContributoryProperties : int { - None = 0x00000000, + /// Represents the ASCII_Hex_Digit property. + /// ASCII characters commonly used for the representation of hexadecimal numbers. [ValueName("ASCII_Hex_Digit"), Display(Name = "ASCII_Hex_Digit", Description = "ASCII characters commonly used for the representation of hexadecimal numbers.")] AsciiHexDigit = 0x00000001, + /// Represents the Bidi_Control property. + /// Format control characters which have specific functions in the Unicode Bidirectional Algorithm [UAX9]. [ValueName("Bidi_Control"), Display(Name = "Bidi_Control", Description = "Format control characters which have specific functions in the Unicode Bidirectional Algorithm [UAX9].")] BidiControl = 0x00000002, + /// Represents the Dash property. + /// Punctuation characters explicitly called out as dashes in the Unicode Standard, plus their compatibility equivalents. Most of these have the General_Category value Pd, but some have the General_Category value Sm because of their use in mathematics. [ValueName("Dash"), Display(Name = "Dash", Description = "Punctuation characters explicitly called out as dashes in the Unicode Standard, plus their compatibility equivalents. Most of these have the General_Category value Pd, but some have the General_Category value Sm because of their use in mathematics.")] Dash = 0x00000004, + /// Represents the Deprecated property. + /// For a machine-readable list of deprecated characters. No characters will ever be removed from the standard, but the usage of deprecated characters is strongly discouraged. [ValueName("Deprecated"), Display(Name = "Deprecated", Description = "For a machine-readable list of deprecated characters. No characters will ever be removed from the standard, but the usage of deprecated characters is strongly discouraged.")] Deprecated = 0x00000008, + /// Represents the Diacritic property. + /// Characters that linguistically modify the meaning of another character to which they apply. Some diacritics are not combining characters, and some combining characters are not diacritics. [ValueName("Diacritic"), Display(Name = "Diacritic", Description = "Characters that linguistically modify the meaning of another character to which they apply. Some diacritics are not combining characters, and some combining characters are not diacritics.")] Diacritic = 0x00000010, + /// Represents the Extender property. + /// Characters whose principal function is to extend the value or shape of a preceding alphabetic character. Typical of these are length and iteration marks. [ValueName("Extender"), Display(Name = "Extender", Description = "Characters whose principal function is to extend the value or shape of a preceding alphabetic character. Typical of these are length and iteration marks.")] Extender = 0x00000020, + /// Represents the Hex_Digit property. + /// Characters commonly used for the representation of hexadecimal numbers, plus their compatibility equivalents. [ValueName("Hex_Digit"), Display(Name = "Hex_Digit", Description = "Characters commonly used for the representation of hexadecimal numbers, plus their compatibility equivalents.")] HexDigit = 0x00000040, - [ValueName("Hyphen"), Display(Name = "Hyphen", Description = "Dashes which are used to mark connections between pieces of words, plus the Katakana middle dot. The Katakana middle dotfunctions like a hyphen, but is shaped like a dot rather than a dash.")] + /// Represents the Hyphen property. + /// Dashes which are used to mark connections between pieces of words, plus the Katakana middle dot. The Katakana middle dotfunctions like a hyphen, but is shaped like a dot rather than a dash. + [ValueName("Hyphen"), Display(Name = "Hyphen", Description = "Dashes which are used to mark connections between pieces of words, plus the Katakana middle dot. The Katakana middle dotfunctions like a hyphen, but is shaped like a dot rather than a dash.")] Hyphen = 0x00000080, + /// Represents the Ideographic property. + /// Characters considered to be CJKV (Chinese, Japanese, Korean, and Vietnamese) ideographs. This property roughly defines the class of "Chinese characters" and does not include characters of other logographic scripts such as Cuneiform or Egyptian Hieroglyphs. [ValueName("Ideographic"), Display(Name = "Ideographic", Description = "Characters considered to be CJKV (Chinese, Japanese, Korean, and Vietnamese) ideographs. This property roughly defines the class of \"Chinese characters\" and does not include characters of other logographic scripts such as Cuneiform or Egyptian Hieroglyphs.")] Ideographic = 0x00000100, + /// Represents the IDS_Binary_Operator property. + /// Used in Ideographic Description Sequences. [ValueName("IDS_Binary_Operator"), Display(Name = "IDS_Binary_Operator", Description = "Used in Ideographic Description Sequences.")] IdsBinaryOperator = 0x00000200, + /// Represents the IDS_Trinary_Operator property. + /// Used in Ideographic Description Sequences. [ValueName("IDS_Trinary_Operator"), Display(Name = "IDS_Trinary_Operator", Description = "Used in Ideographic Description Sequences.")] IdsTrinaryOperator = 0x00000400, + /// Represents the Join_Control property. + /// Format control characters which have specific functions for control of cursive joining and ligation. [ValueName("Join_Control"), Display(Name = "Join_Control", Description = "Format control characters which have specific functions for control of cursive joining and ligation.")] JoinControl = 0x00000800, + /// Represents the Logical_Order_Exception property. + /// A small number of spacing vowel letters occurring in certain Southeast Asian scripts such as Thai and Lao, which use a visual order display model. These letters are stored in text ahead of syllable-initial consonants, and require special handling for processes such as searching and sorting. [ValueName("Logical_Order_Exception"), Display(Name = "Logical_Order_Exception", Description = "A small number of spacing vowel letters occurring in certain Southeast Asian scripts such as Thai and Lao, which use a visual order display model. These letters are stored in text ahead of syllable-initial consonants, and require special handling for processes such as searching and sorting.")] LogicalOrderException = 0x00001000, + /// Represents the Noncharacter_Code_Point property. + /// Code points permanently reserved for internal use. [ValueName("Noncharacter_Code_Point"), Display(Name = "Noncharacter_Code_Point", Description = "Code points permanently reserved for internal use.")] NonCharacterCodePoint = 0x00002000, + /// Represents the Other_Alphabetic property. + /// Used in deriving the Alphabetic property. [ValueName("Other_Alphabetic"), Display(Name = "Other_Alphabetic", Description = "Used in deriving the Alphabetic property.")] OtherAlphabetic = 0x00004000, + /// Represents the Other_Default_Ignorable_Code_Point property. + /// Used in deriving the Default_Ignorable_Code_Point property. [ValueName("Other_Default_Ignorable_Code_Point"), Display(Name = "Other_Default_Ignorable_Code_Point", Description = "Used in deriving the Default_Ignorable_Code_Point property.")] OtherDefaultIgnorableCodePoint = 0x00008000, - [ValueName("Other_Grapheme_Extend"), Display(Name = "Other_Grapheme_Extend", Description = "Used in deriving  the Grapheme_Extend property.")] + /// Represents the Other_Grapheme_Extend property. + /// Used in deriving the Grapheme_Extend property. + [ValueName("Other_Grapheme_Extend"), Display(Name = "Other_Grapheme_Extend", Description = "Used in deriving the Grapheme_Extend property.")] OtherGraphemeExtend = 0x00010000, - [ValueName("Other_ID_Continue"), Display(Name = "Other_ID_Continue", Description = "Used to maintain backward compatibility of ID_Continue.")] + /// Represents the Other_ID_Continue property. + /// Used to maintain backward compatibility of ID_Continue. + [ValueName("Other_ID_Continue"), Display(Name = "Other_ID_Continue", Description = "Used to maintain backward compatibility of ID_Continue.")] OtherIdContinue = 0x00020000, - [ValueName("Other_ID_Start"), Display(Name = "Other_ID_Start", Description = "Used to maintain backward compatibility of ID_Start.")] + /// Represents the Other_ID_Start property. + /// Used to maintain backward compatibility of ID_Start. + [ValueName("Other_ID_Start"), Display(Name = "Other_ID_Start", Description = "Used to maintain backward compatibility of ID_Start.")] OtherIdStart = 0x00040000, + /// Represents the Other_Lowercase property. + /// Used in deriving the Lowercase property. [ValueName("Other_Lowercase"), Display(Name = "Other_Lowercase", Description = "Used in deriving the Lowercase property.")] OtherLowercase = 0x00080000, + /// Represents the Other_Math property. + /// Used in deriving the Math property. [ValueName("Other_Math"), Display(Name = "Other_Math", Description = "Used in deriving the Math property.")] OtherMath = 0x00100000, + /// Represents the Other_Uppercase property. + /// Used in deriving the Uppercase property. [ValueName("Other_Uppercase"), Display(Name = "Other_Uppercase", Description = "Used in deriving the Uppercase property.")] OtherUppercase = 0x00200000, + /// Represents the Pattern_Syntax property. + /// Used for pattern syntax as described in Unicode Standard Annex #31, "Unicode Identifier and Pattern Syntax" [UAX31]. [ValueName("Pattern_Syntax"), Display(Name = "Pattern_Syntax", Description = "Used for pattern syntax as described in Unicode Standard Annex #31, \"Unicode Identifier and Pattern Syntax\" [UAX31].")] PatternSyntax = 0x00400000, + /// Represents the Pattern_White_Space property. [ValueName("Pattern_White_Space"), Display(Name = "Pattern_White_Space")] PatternWhiteSpace = 0x00800000, + /// Represents the Quotation_Mark property. + /// Punctuation characters that function as quotation marks. [ValueName("Quotation_Mark"), Display(Name = "Quotation_Mark", Description = "Punctuation characters that function as quotation marks.")] QuotationMark = 0x01000000, + /// Represents the Radical property. + /// Used in Ideographic Description Sequences. [ValueName("Radical"), Display(Name = "Radical", Description = "Used in Ideographic Description Sequences.")] Radical = 0x02000000, - [ValueName("Soft_Dotted"), Display(Name = "Soft_Dotted", Description = "Characters with a \"soft dot\", like i or j. An accent placed on these characters causes the dot to disappear. An explicit dot abovecan be added where required, such as in Lithuanian.")] + /// Represents the Soft_Dotted property. + /// Characters with a "soft dot", like i or j. An accent placed on these characters causes the dot to disappear. An explicit dot abovecan be added where required, such as in Lithuanian. + [ValueName("Soft_Dotted"), Display(Name = "Soft_Dotted", Description = "Characters with a \"soft dot\", like i or j. An accent placed on these characters causes the dot to disappear. An explicit dot abovecan be added where required, such as in Lithuanian.")] SoftDotted = 0x04000000, + /// Represents the STerm property. + /// Sentence Terminal. Used in Unicode Standard Annex #29, "Unicode Text Segmentation" [UAX29]. [ValueName("STerm"), Display(Name = "STerm", Description = "Sentence Terminal. Used in Unicode Standard Annex #29, \"Unicode Text Segmentation\" [UAX29].")] SequenceTerminal = 0x08000000, + /// Represents the Terminal_Punctuation property. + /// Punctuation characters that generally mark the end of textual units. [ValueName("Terminal_Punctuation"), Display(Name = "Terminal_Punctuation", Description = "Punctuation characters that generally mark the end of textual units.")] TerminalPunctuation = 0x10000000, + /// Represents the Unified_Ideograph property. + /// A property which specifies the exact set of Unified CJK Ideographs in the standard. This set excludes CJK Compatibility Ideographs (which have canonical decompositions to Unified CJK Ideographs), as well as characters from the CJK Symbols and Punctuation block. The property is used in the definition of Ideographic Description Sequences. [ValueName("Unified_Ideograph"), Display(Name = "Unified_Ideograph", Description = "A property which specifies the exact set of Unified CJK Ideographs in the standard. This set excludes CJK Compatibility Ideographs (which have canonical decompositions to Unified CJK Ideographs), as well as characters from the CJK Symbols and Punctuation block. The property is used in the definition of Ideographic Description Sequences.")] UnifiedIdeograph = 0x20000000, - [ValueName("Variation_Selector"), Display(Name = "Variation_Selector", Description = "Indicates characters that are Variation Selectors. For details on the behavior of these characters, seeStandardizedVariants.html, Section 23.4, Variation Selectors in [Unicode], and Unicode Technical Standard #37, \"Unicode Ideographic Variation Database\" [UTS37].")] + /// Represents the Variation_Selector property. + /// Indicates characters that are Variation Selectors. For details on the behavior of these characters, seeStandardizedVariants.html, Section 23.4, Variation Selectors in [Unicode], and Unicode Technical Standard #37, "Unicode Ideographic Variation Database" [UTS37]. + [ValueName("Variation_Selector"), Display(Name = "Variation_Selector", Description = "Indicates characters that are Variation Selectors. For details on the behavior of these characters, seeStandardizedVariants.html, Section 23.4, Variation Selectors in [Unicode], and Unicode Technical Standard #37, \"Unicode Ideographic Variation Database\" [UTS37].")] VariationSelector = 0x40000000, - [ValueName("White_Space"), Display(Name = "White_Space", Description = "Spaces, separator characters and other control characters which should be treated by programming languages as \"white space\" for the purpose of parsing elements. See also Line_Break, Grapheme_Cluster_Break, Sentence_Break, and Word_Break, which classify space characters and related controls somewhat differently for particular text segmentation contexts.")] + /// Represents the White_Space property. + /// Spaces, separator characters and other control characters which should be treated by programming languages as "white space" for the purpose of parsing elements. See also Line_Break, Grapheme_Cluster_Break, Sentence_Break, and Word_Break, which classify space characters and related controls somewhat differently for particular text segmentation contexts. + [ValueName("White_Space"), Display(Name = "White_Space", Description = "Spaces, separator characters and other control characters which should be treated by programming languages as \"white space\" for the purpose of parsing elements. See also Line_Break, Grapheme_Cluster_Break, Sentence_Break, and Word_Break, which classify space characters and related controls somewhat differently for particular text segmentation contexts.")] WhiteSpace = ~0x7FFFFFFF, } } diff --git a/UnicodeInformation/PermissiveCodePointEnumerator.cs b/UnicodeInformation/PermissiveCodePointEnumerator.cs index 7e7efb0..6c30e57 100644 --- a/UnicodeInformation/PermissiveCodePointEnumerator.cs +++ b/UnicodeInformation/PermissiveCodePointEnumerator.cs @@ -7,12 +7,16 @@ using System.Threading.Tasks; namespace System.Unicode { + /// Supports a permissive iteration of code points in a . public struct PermissiveCodePointEnumerator : IEnumerator { private readonly string text; private int current; private int index; + /// Initializes a new instance of the struct. + /// The text whose code point should be enumerated. + /// is . public PermissiveCodePointEnumerator(string text) { if (text == null) throw new ArgumentNullException(nameof(text)); @@ -22,12 +26,16 @@ namespace System.Unicode this.index = -1; } + /// Gets the element in the collection at the current position of the enumerator.. + /// The element in the collection at the current position of the enumerator. public int Current { get { return current; } } object IEnumerator.Current { get { return current; } } void IDisposable.Dispose() { } + /// Advances the enumerator to the next element of the collection. + /// if the enumerator was successfully advanced to the next element; if the enumerator has passed the end of the collection. public bool MoveNext() { if (index < text.Length && (index += current > 0xFFFF ? 2 : 1) < text.Length) diff --git a/UnicodeInformation/UnicodeBlock.cs b/UnicodeInformation/UnicodeBlock.cs index ed37f87..ace18d2 100644 --- a/UnicodeInformation/UnicodeBlock.cs +++ b/UnicodeInformation/UnicodeBlock.cs @@ -6,9 +6,12 @@ using System.Threading.Tasks; namespace System.Unicode { + /// Represents a Unicode block. public struct UnicodeBlock { + /// The code point range of this block. public readonly UnicodeCodePointRange CodePointRange; + /// The name of this block. public readonly string Name; internal UnicodeBlock(UnicodeCodePointRange codePointRange, string name) diff --git a/UnicodeInformation/UnicodeCrossReferenceCollection.cs b/UnicodeInformation/UnicodeCrossReferenceCollection.cs index 0633bef..f0561b2 100644 --- a/UnicodeInformation/UnicodeCrossReferenceCollection.cs +++ b/UnicodeInformation/UnicodeCrossReferenceCollection.cs @@ -49,13 +49,13 @@ namespace System.Unicode bool ICollection.IsReadOnly { get { return true; } } - public void Add(int item) { throw new NotSupportedException(); } - public void Insert(int index, int item) { throw new NotSupportedException(); } + void ICollection.Add(int item) { throw new NotSupportedException(); } + void IList.Insert(int index, int item) { throw new NotSupportedException(); } - public bool Remove(int item) { throw new NotSupportedException(); } - public void RemoveAt(int index) { throw new NotSupportedException(); } + bool ICollection.Remove(int item) { throw new NotSupportedException(); } + void IList.RemoveAt(int index) { throw new NotSupportedException(); } - public void Clear() { throw new NotSupportedException(); } + void ICollection.Clear() { throw new NotSupportedException(); } public int IndexOf(int item) { return Array.IndexOf(items, item); } public bool Contains(int item) { return IndexOf(item) >= 0; } diff --git a/UnicodeInformation/UnicodeNameAliasCollection.cs b/UnicodeInformation/UnicodeNameAliasCollection.cs index c33a427..3bfa1be 100644 --- a/UnicodeInformation/UnicodeNameAliasCollection.cs +++ b/UnicodeInformation/UnicodeNameAliasCollection.cs @@ -7,24 +7,33 @@ using System.Threading.Tasks; namespace System.Unicode { + /// Represents a collection of name aliases. public struct UnicodeNameAliasCollection : IList { + /// Represents an enumerator for the class. public struct Enumerator : IEnumerator { private readonly UnicodeNameAlias[] items; private int index; + /// Initializes a new instance of the struct. + /// The items to enumerate. internal Enumerator(UnicodeNameAlias[] items) { this.items = items; this.index = -1; } + /// Does nothing. public void Dispose() { } + /// Gets the element in the collection at the current position of the enumerator.. + /// The element in the collection at the current position of the enumerator. public UnicodeNameAlias Current { get { return items[index]; } } object IEnumerator.Current { get { return Current; } } + /// Advances the enumerator to the next element of the collection. + /// true if the enumerator was successfully advanced to the next element; false if the enumerator has passed the end of the collection. public bool MoveNext() { return index < items.Length && ++index < items.Length; } void IEnumerator.Reset() { this.index = -1; } @@ -32,9 +41,14 @@ namespace System.Unicode private readonly UnicodeNameAlias[] items; + /// Initializes a new instance of the struct. public UnicodeNameAliasCollection() { items = UnicodeNameAlias.EmptyArray; } internal UnicodeNameAliasCollection(UnicodeNameAlias[] items) { this.items = items ?? UnicodeNameAlias.EmptyArray; } + /// Gets the at the specified index. + /// The . + /// The index. + /// The at the specified index. public UnicodeNameAlias this[int index] { get { return items[index]; } } UnicodeNameAlias IList.this[int index] @@ -43,23 +57,27 @@ namespace System.Unicode set { throw new NotSupportedException(); } } + /// Gets the number of elements contained in the . + /// The number of elements contained in the . public int Count { get { return items.Length; } } bool ICollection.IsReadOnly { get { return true; } } - public void Add(UnicodeNameAlias item) { throw new NotSupportedException(); } - public void Insert(int index, UnicodeNameAlias item) { throw new NotSupportedException(); } + void ICollection.Add(UnicodeNameAlias item) { throw new NotSupportedException(); } + void IList.Insert(int index, UnicodeNameAlias item) { throw new NotSupportedException(); } - public bool Remove(UnicodeNameAlias item) { throw new NotSupportedException(); } - public void RemoveAt(int index) { throw new NotSupportedException(); } + bool ICollection.Remove(UnicodeNameAlias item) { throw new NotSupportedException(); } + void IList.RemoveAt(int index) { throw new NotSupportedException(); } - public void Clear() { throw new NotSupportedException(); } + void ICollection.Clear() { throw new NotSupportedException(); } public int IndexOf(UnicodeNameAlias item) { return Array.IndexOf(items, item); } public bool Contains(UnicodeNameAlias item) { return IndexOf(item) >= 0; } public void CopyTo(UnicodeNameAlias[] array, int arrayIndex) { items.CopyTo(array, arrayIndex); } + /// Returns an enumerator that iterates through the collection. + /// An that can be used to iterate through the collection. public Enumerator GetEnumerator() { return new Enumerator(items); } IEnumerator IEnumerable.GetEnumerator() { return GetEnumerator(); } diff --git a/UnicodeInformation/UnicodeRadicalStrokeCountCollection.cs b/UnicodeInformation/UnicodeRadicalStrokeCountCollection.cs index 94915f2..de34f23 100644 --- a/UnicodeInformation/UnicodeRadicalStrokeCountCollection.cs +++ b/UnicodeInformation/UnicodeRadicalStrokeCountCollection.cs @@ -47,13 +47,13 @@ namespace System.Unicode bool ICollection.IsReadOnly { get { return true; } } - public void Add(UnicodeRadicalStrokeCount item) { throw new NotSupportedException(); } - public void Insert(int index, UnicodeRadicalStrokeCount item) { throw new NotSupportedException(); } + void ICollection.Add(UnicodeRadicalStrokeCount item) { throw new NotSupportedException(); } + void IList.Insert(int index, UnicodeRadicalStrokeCount item) { throw new NotSupportedException(); } - public bool Remove(UnicodeRadicalStrokeCount item) { throw new NotSupportedException(); } - public void RemoveAt(int index) { throw new NotSupportedException(); } + bool ICollection.Remove(UnicodeRadicalStrokeCount item) { throw new NotSupportedException(); } + void IList.RemoveAt(int index) { throw new NotSupportedException(); } - public void Clear() { throw new NotSupportedException(); } + void ICollection.Clear() { throw new NotSupportedException(); } public int IndexOf(UnicodeRadicalStrokeCount item) { return Array.IndexOf(items, item); } public bool Contains(UnicodeRadicalStrokeCount item) { return IndexOf(item) >= 0; } diff --git a/UnicodeInformation/UnihanNumericType.cs b/UnicodeInformation/UnihanNumericType.cs index 4fe787a..1a93b64 100644 --- a/UnicodeInformation/UnihanNumericType.cs +++ b/UnicodeInformation/UnihanNumericType.cs @@ -9,11 +9,18 @@ namespace System.Unicode /// Represents the different numeric types from the Unihan database. public enum UnihanNumericType : byte { + /// Indicates that there is no Unihan numeric property defined for the code point. None = 0, + /// Indicates that the propery kPrimaryNumeric is defined for this code point. + /// The kPrimaryNumeric property is used for ideographs wich are standard numerals. [ValueName("kPrimaryNumeric")] Primary = 1, + /// Indicates that the propery kAccountingNumeric is defined for this code point. + /// The kAccountingNumeric property is used for ideographs used as accounting numerals. [ValueName("kAccountingNumeric")] Accounting = 2, + /// Indicates that the propery kOtherNumeric is defined for this code point. + /// The kOtherNumeric property is used for ideographs wich are used as numerals in non common contexts. [ValueName("kOtherNumeric")] Other = 3, }