Added support for kRSUnicode/Unicode_Radical_Stroke.

UnicodeInformation/UnicodeCharInfo.cs

@@ -52,6 +52,8 @@ namespace System.Unicode
 		public ContributoryProperties ContributoryProperties { get { return unicodeCharacterData?.ContributoryProperties ?? 0; } }
 		public CoreProperties CoreProperties { get { return unicodeCharacterData?.CoreProperties ?? 0; } }
 		public UnicodeCrossReferenceCollection CrossRerefences { get { return new UnicodeCrossReferenceCollection(unicodeCharacterData?.CrossRerefences); } }
+		[ValueName("kRSUnicode"), ValueName("cjkRSUnicode"), ValueName("Unicode_Radical_Stroke"), ValueName("URS")]
+		public UnicodeRadicalStrokeCountCollection UnicodeRadicalStrokeCounts { get { return new UnicodeRadicalStrokeCountCollection(unihanCharacterData?.UnicodeRadicalStrokeCounts); } }
 
 		[ValueName("kDefinition")]
 		public string Definition { get { return unihanCharacterData?.Definition; } }

UnicodeInformation/UnicodeInfo.cs

@@ -185,6 +185,18 @@ namespace System.Unicode
 				reader.ReadInt64() :
 				0;
 
+			UnicodeRadicalStrokeCount[] unicodeRadicalStrokeCounts = (fields & UnihanFields.UnicodeRadicalStrokeCountMore) != 0 ?
+				new UnicodeRadicalStrokeCount
+				[
+					(fields & UnihanFields.UnicodeRadicalStrokeCountMore) == UnihanFields.UnicodeRadicalStrokeCountMore ?
+						reader.ReadByte() + 3 :
+						((byte)(fields & UnihanFields.UnicodeRadicalStrokeCountMore) >> 2)
+				] :
+				UnicodeRadicalStrokeCount.EmptyArray;
+
+			for (int i = 0; i < unicodeRadicalStrokeCounts.Length; ++i)
+				unicodeRadicalStrokeCounts[i] = new UnicodeRadicalStrokeCount(reader.ReadByte(), reader.ReadByte());
+
 			string definition = (fields & UnihanFields.Definition) != 0 ? reader.ReadString() : null;
 			string mandarinReading = (fields & UnihanFields.MandarinReading) != 0 ? reader.ReadString() : null;
 			string cantoneseReading = (fields & UnihanFields.CantoneseReading) != 0 ? reader.ReadString() : null;
@@ -201,6 +213,7 @@ namespace System.Unicode
 				codePoint,
 				numericType,
 				numericValue,
+				unicodeRadicalStrokeCounts,
 				definition,
 				mandarinReading,
 				cantoneseReading,

UnicodeInformation/UnicodeInformation.csproj

@@ -67,6 +67,7 @@
     <Compile Include="CoreProperties.cs" />
     <Compile Include="HangulInfo.cs" />
     <Compile Include="UnicodeCrossReferenceCollection.cs" />
+    <Compile Include="UnicodeRadicalStrokeCountCollection.cs" />
     <Compile Include="UnicodeNameAliasCollection.cs" />
     <Compile Include="UcdFields.cs" />
     <Compile Include="EnumHelper.cs" />
@@ -81,6 +82,7 @@
     <Compile Include="UnicodeInfo.cs" />
     <Compile Include="UnicodeNameAlias.cs" />
     <Compile Include="UnicodeNameAliasKind.cs" />
+    <Compile Include="UnicodeRadicalStrokeCount.cs" />
     <Compile Include="UnihanNumericType.cs" />
     <Compile Include="UnicodeNumericType.cs" />
     <Compile Include="UnihanCharacterData.cs" />

UnicodeInformation/UnicodeRadicalStrokeCount.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace System.Unicode
+{
+	public struct UnicodeRadicalStrokeCount
+	{
+		internal static readonly UnicodeRadicalStrokeCount[] EmptyArray = new UnicodeRadicalStrokeCount[0];
+
+		private readonly byte radical;
+		private readonly byte strokeCount;
+
+		internal UnicodeRadicalStrokeCount(byte rawRadical, byte rawStrokeCount)
+		{
+			radical = rawRadical;
+			strokeCount = rawStrokeCount;
+		}
+
+		internal UnicodeRadicalStrokeCount(byte radical, byte strokeCount, bool isSimplified)
+		{
+			this.radical = radical;
+			this.strokeCount = strokeCount;
+
+			if (isSimplified) this.strokeCount |= 0x80;
+		}
+
+		public byte Radical { get { return radical; } }
+		public byte StrokeCount { get { return strokeCount; } }
+		public bool IsSimplified { get { return (strokeCount & 0x80) != 0; } }
+    }
+}

UnicodeInformation/UnicodeRadicalStrokeCountCollection.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace System.Unicode
+{
+	public struct UnicodeRadicalStrokeCountCollection : IList<UnicodeRadicalStrokeCount>
+	{
+		public struct Enumerator : IEnumerator<UnicodeRadicalStrokeCount>
+		{
+			private readonly UnicodeRadicalStrokeCount[] items;
+			private int index;
+
+			internal Enumerator(UnicodeRadicalStrokeCount[] items)
+			{
+				this.items = items;
+				this.index = -1;
+			}
+
+			public void Dispose() { }
+
+			public UnicodeRadicalStrokeCount Current { get { return items[index]; } }
+			object IEnumerator.Current { get { return Current; } }
+
+			public bool MoveNext() { return index < items.Length && ++index < items.Length; }
+
+			void IEnumerator.Reset() { this.index = -1; }
+		}
+
+		private readonly UnicodeRadicalStrokeCount[] items;
+
+		public UnicodeRadicalStrokeCountCollection() { items = UnicodeRadicalStrokeCount.EmptyArray; }
+		internal UnicodeRadicalStrokeCountCollection(UnicodeRadicalStrokeCount[] items) { this.items = items ?? UnicodeRadicalStrokeCount.EmptyArray; }
+
+		public UnicodeRadicalStrokeCount this[int index] { get { return items[index]; } }
+
+		UnicodeRadicalStrokeCount IList<UnicodeRadicalStrokeCount>.this[int index]
+		{
+			get { return items[index]; }
+			set { throw new NotSupportedException(); }
+		}
+
+		public int Count { get { return items.Length; } }
+
+		bool ICollection<UnicodeRadicalStrokeCount>.IsReadOnly { get { return true; } }
+
+		public void Add(UnicodeRadicalStrokeCount item) { throw new NotSupportedException(); }
+		public void Insert(int index, UnicodeRadicalStrokeCount item) { throw new NotSupportedException(); }
+
+		public bool Remove(UnicodeRadicalStrokeCount item) { throw new NotSupportedException(); }
+		public void RemoveAt(int index) { throw new NotSupportedException(); }
+
+		public void Clear() { throw new NotSupportedException(); }
+
+		public int IndexOf(UnicodeRadicalStrokeCount item) { return Array.IndexOf(items, item); }
+		public bool Contains(UnicodeRadicalStrokeCount item) { return IndexOf(item) >= 0; }
+
+		public void CopyTo(UnicodeRadicalStrokeCount[] array, int arrayIndex) { items.CopyTo(array, arrayIndex); }
+
+		public Enumerator GetEnumerator() { return new Enumerator(items); }
+
+		IEnumerator<UnicodeRadicalStrokeCount> IEnumerable<UnicodeRadicalStrokeCount>.GetEnumerator() { return GetEnumerator(); }
+		IEnumerator IEnumerable.GetEnumerator() { return GetEnumerator(); }
+	}
+}

UnicodeInformation/UnihanCharacterData.cs

@@ -11,6 +11,7 @@ namespace System.Unicode
 		public readonly int CodePoint;
 		public readonly UnihanNumericType NumericType;
 		public readonly long NumericValue;
+		public readonly UnicodeRadicalStrokeCount[] UnicodeRadicalStrokeCounts;
 		public readonly string Definition;
 		public readonly string MandarinReading;
 		public readonly string CantoneseReading;
@@ -27,6 +28,7 @@ namespace System.Unicode
 			int codePoint,
 			UnihanNumericType numericType,
 			long numericValue,
+			UnicodeRadicalStrokeCount[] unicodeRadicalStrokeCounts,
 			string definition,
 			string mandarinReading,
 			string cantoneseReading,
@@ -42,6 +44,7 @@ namespace System.Unicode
 			CodePoint = codePoint;
 			NumericType = numericType;
 			NumericValue = numericValue;
+			UnicodeRadicalStrokeCounts = unicodeRadicalStrokeCounts;
 			Definition = definition;
 			MandarinReading = mandarinReading;
 			CantoneseReading = cantoneseReading;

UnicodeInformation/UnihanFields.cs

@@ -14,16 +14,21 @@ namespace System.Unicode
 		AccountingNumeric = 2,
 		OtherNumeric = 3,
 
-		Definition = 4,
-		MandarinReading = 8,
-		CantoneseReading = 16,
-		JapaneseKunReading = 32,
-		JapaneseOnReading = 64,
-		KoreanReading = 128,
-		HangulReading = 256,
-		VietnameseReading = 512,
+		// UnicodeRadicalStroke : Not exactly a bit mask…
+		UnicodeRadicalStrokeCount = 4, // Will indicate exactly one value for Unicode_Radical_Stroke.
+		UnicodeRadicalStrokeCountTwice = 8,	// Will indicate exactly two values for Unicode_Radical_Stroke.
+		UnicodeRadicalStrokeCountMore = 12,	// Will indicate three or more values for Unicode_Radical_Stroke. This combination should never happen in the current files.
 
-		SimplifiedVariant = 1024,
-		TraditionalVariant = 2048,
+		Definition = 16,
+		MandarinReading = 32,
+		CantoneseReading = 64,
+		JapaneseKunReading = 128,
+		JapaneseOnReading = 256,
+		KoreanReading = 512,
+		HangulReading = 1024,
+		VietnameseReading = 2048,
+
+		SimplifiedVariant = 4096,
+		TraditionalVariant = 8192,
 	}
 }