Skip to content

Commit b1b504c

Browse files
smdnsmdn
committed
add MimeType.Equals/TypeEquals/SubTypeEquals(ReadOnlySpan<char>, StringComparison)
1 parent 9b08c8c commit b1b504c

File tree

3 files changed

+59
-40
lines changed

3 files changed

+59
-40
lines changed

‎src/Smdn.Fundamental.MimeType/Smdn.Fundamental.MimeType.csproj‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,7 @@ SPDX-License-Identifier: MIT
2020

2121
<ItemGroup>
2222
<ProjectReference VersionRange="[3.0.0,4.0.0)" Include="..\Smdn.Fundamental.Exception\Smdn.Fundamental.Exception.csproj" />
23+
<PackageReference Include="System.Memory" />
2324
<PackageReference Include="System.ValueTuple" />
2425
<PackageReference Include="System.Runtime.InteropServices.RuntimeInformation" />
2526
<PackageReference Include="Microsoft.Win32.Registry" />

‎src/Smdn.Fundamental.MimeType/Smdn/MimeType.cs‎

Lines changed: 23 additions & 40 deletions
Original file line numberDiff line numberDiff line change
@@ -116,44 +116,34 @@ public void Deconstruct(out string type, out string subType)
116116
}
117117

118118
public bool TypeEquals(MimeType mimeType)
119-
{
120-
if (mimeType == null)
121-
return false;
122-
123-
return TypeEquals(mimeType.Type);
124-
}
119+
=> mimeType is not null && TypeEquals(mimeType.Type.AsSpan(), StringComparison.Ordinal);
125120

126-
public bool TypeEquals(string type) => string.Equals(Type, type, StringComparison.Ordinal);
121+
public bool TypeEquals(string type)
122+
=> type is not null && TypeEquals(type.AsSpan(), StringComparison.Ordinal);
127123

128124
public bool TypeEqualsIgnoreCase(MimeType mimeType)
129-
{
130-
if (mimeType == null)
131-
return false;
125+
=> mimeType is not null && TypeEquals(mimeType.Type.AsSpan(), StringComparison.OrdinalIgnoreCase);
132126

133-
return TypeEqualsIgnoreCase(mimeType.Type);
134-
}
127+
public bool TypeEqualsIgnoreCase(string type)
128+
=> type is not null && TypeEquals(type.AsSpan(), StringComparison.OrdinalIgnoreCase);
135129

136-
public bool TypeEqualsIgnoreCase(string type) => string.Equals(Type, type, StringComparison.OrdinalIgnoreCase);
130+
public bool TypeEquals(ReadOnlySpan<char> type, StringComparison comparisonType = StringComparison.Ordinal)
131+
=> Type.AsSpan().Equals(type, comparisonType);
137132

138133
public bool SubTypeEquals(MimeType mimeType)
139-
{
140-
if (mimeType == null)
141-
return false;
142-
143-
return SubTypeEquals(mimeType.SubType);
144-
}
134+
=> mimeType is not null && SubTypeEquals(mimeType.SubType.AsSpan(), StringComparison.Ordinal);
145135

146-
public bool SubTypeEquals(string subType) => string.Equals(SubType, subType, StringComparison.Ordinal);
136+
public bool SubTypeEquals(string subType)
137+
=> subType is not null && SubTypeEquals(subType.AsSpan(), StringComparison.Ordinal);
147138

148139
public bool SubTypeEqualsIgnoreCase(MimeType mimeType)
149-
{
150-
if (mimeType == null)
151-
return false;
140+
=> mimeType is not null && SubTypeEquals(mimeType.SubType.AsSpan(), StringComparison.OrdinalIgnoreCase);
152141

153-
return SubTypeEqualsIgnoreCase(mimeType.SubType);
154-
}
142+
public bool SubTypeEqualsIgnoreCase(string subType)
143+
=> subType is not null && SubTypeEquals(subType.AsSpan(), StringComparison.OrdinalIgnoreCase);
155144

156-
public bool SubTypeEqualsIgnoreCase(string subType) => string.Equals(SubType, subType, StringComparison.OrdinalIgnoreCase);
145+
public bool SubTypeEquals(ReadOnlySpan<char> subType, StringComparison comparisonType = StringComparison.Ordinal)
146+
=> SubType.AsSpan().Equals(subType, comparisonType);
157147

158148
public override bool Equals(object obj)
159149
{
@@ -173,14 +163,6 @@ public bool Equals(MimeType other)
173163
return TypeEquals(other) && SubTypeEquals(other);
174164
}
175165

176-
public bool Equals(string other)
177-
{
178-
if (other == null)
179-
return false;
180-
else
181-
return string.Equals(ToString(), other, StringComparison.Ordinal);
182-
}
183-
184166
public bool EqualsIgnoreCase(MimeType other)
185167
{
186168
if (other == null)
@@ -189,13 +171,14 @@ public bool EqualsIgnoreCase(MimeType other)
189171
return TypeEqualsIgnoreCase(other) && SubTypeEqualsIgnoreCase(other);
190172
}
191173

174+
public bool Equals(string other)
175+
=> other is not null && Equals(other.AsSpan(), StringComparison.Ordinal);
176+
192177
public bool EqualsIgnoreCase(string other)
193-
{
194-
if (other == null)
195-
return false;
196-
else
197-
return string.Equals(ToString(), other, StringComparison.OrdinalIgnoreCase);
198-
}
178+
=> other is not null && Equals(other.AsSpan(), StringComparison.OrdinalIgnoreCase);
179+
180+
public bool Equals(ReadOnlySpan<char> other, StringComparison comparisonType = StringComparison.Ordinal)
181+
=> ToString().AsSpan().Equals(other, comparisonType); // TODO: reduce allocation (ToString)
199182

200183
public override int GetHashCode() => ToString().GetHashCode();
201184

‎tests/Smdn.Fundamental.MimeType/Smdn/MimeType.cs‎

Lines changed: 35 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -100,6 +100,23 @@ public void TestEqualsIgnoreCase(string typeX, string subtypeX, string typeY, st
100100
public void TestEqualsIgnoreCase_String(string typeX, string subtypeX, string other, bool expected)
101101
=> Assert.AreEqual(expected, new MimeType(typeX, subtypeX).EqualsIgnoreCase(other));
102102

103+
[TestCase("text", "plain", "text/plain", StringComparison.Ordinal, true)]
104+
[TestCase("text", "plain", "text/plain", StringComparison.OrdinalIgnoreCase, true)]
105+
[TestCase("text", "plain", "text/PLAIN", StringComparison.Ordinal, false)]
106+
[TestCase("text", "plain", "text/PLAIN", StringComparison.OrdinalIgnoreCase, true)]
107+
[TestCase("text", "plain", "TEXT/plain", StringComparison.Ordinal, false)]
108+
[TestCase("text", "plain", "TEXT/plain", StringComparison.OrdinalIgnoreCase, true)]
109+
[TestCase("text", "plain", "TEXT/PLAIN", StringComparison.Ordinal, false)]
110+
[TestCase("text", "plain", "TEXT/PLAIN", StringComparison.OrdinalIgnoreCase, true)]
111+
[TestCase("text", "html", "text/plain", StringComparison.Ordinal, false)]
112+
[TestCase("text", "html", "text/plain", StringComparison.OrdinalIgnoreCase, false)]
113+
[TestCase("image", "plain", "text/plain", StringComparison.Ordinal, false)]
114+
[TestCase("image", "plain", "text/plain", StringComparison.OrdinalIgnoreCase, false)]
115+
[TestCase("application", "octet-stream", "text/plain", StringComparison.Ordinal, false)]
116+
[TestCase("application", "octet-stream", "text/plain", StringComparison.OrdinalIgnoreCase, false)]
117+
public void TestEquals_ReadOnlySpanOfChar(string typeX, string subtypeX, string other, StringComparison comparison, bool expected)
118+
=> Assert.AreEqual(expected, new MimeType(typeX, subtypeX).Equals(other.AsSpan(), comparison));
119+
103120
[TestCase("text", "plain", "text", "plain", true)]
104121
[TestCase("text", "plain", "text", "PLAIN", true)]
105122
[TestCase("text", "plain", "TEXT", "plain", false)]
@@ -130,6 +147,15 @@ public void TestTypeEquals_String(string typeX, string subtypeX, string typeY, b
130147
public void TestTypeEqualsIgnoreCase_String(string typeX, string subtypeX, string typeY, bool expected)
131148
=> Assert.AreEqual(expected, new MimeType(typeX, subtypeX).TypeEqualsIgnoreCase(typeY));
132149

150+
[TestCase("text", "plain", "text", StringComparison.Ordinal, true)]
151+
[TestCase("text", "plain", "text", StringComparison.OrdinalIgnoreCase, true)]
152+
[TestCase("text", "plain", "TEXT", StringComparison.Ordinal, false)]
153+
[TestCase("text", "plain", "TEXT", StringComparison.OrdinalIgnoreCase, true)]
154+
[TestCase("text", "plain", "", StringComparison.Ordinal, false)]
155+
[TestCase("text", "plain", "", StringComparison.OrdinalIgnoreCase, false)]
156+
public void TestTypeEquals_ReadOnlySpanOfChar(string typeX, string subtypeX, string typeY, StringComparison comparison, bool expected)
157+
=> Assert.AreEqual(expected, new MimeType(typeX, subtypeX).TypeEquals(typeY.AsSpan(), comparison));
158+
133159
[TestCase("text", "plain", "text", "plain", true)]
134160
[TestCase("text", "plain", "text", "PLAIN", false)]
135161
[TestCase("text", "plain", "TEXT", "plain", true)]
@@ -160,6 +186,15 @@ public void TestSubTypeEquals_String(string typeX, string subtypeX, string subty
160186
public void TestSubTypeEqualsIgnoreCase_String(string typeX, string subtypeX, string subtypeY, bool expected)
161187
=> Assert.AreEqual(expected, new MimeType(typeX, subtypeX).SubTypeEqualsIgnoreCase(subtypeY));
162188

189+
[TestCase("text", "plain", "plain", StringComparison.Ordinal, true)]
190+
[TestCase("text", "plain", "plain", StringComparison.OrdinalIgnoreCase, true)]
191+
[TestCase("text", "plain", "PLAIN", StringComparison.Ordinal, false)]
192+
[TestCase("text", "plain", "PLAIN", StringComparison.OrdinalIgnoreCase, true)]
193+
[TestCase("text", "plain", "", StringComparison.Ordinal, false)]
194+
[TestCase("text", "plain", "", StringComparison.OrdinalIgnoreCase, false)]
195+
public void TestSubTypeEquals_ReadOnlySpanOfChar(string typeX, string subtypeX, string subtypeY, StringComparison comparison, bool expected)
196+
=> Assert.AreEqual(expected, new MimeType(typeX, subtypeX).SubTypeEquals(subtypeY.AsSpan(), comparison));
197+
163198
[Test]
164199
public void TestToString()
165200
{

0 commit comments

Comments
 (0)