ConversionUtilities
Provides name conversion utility methods.
using System;
using System.Globalization;
using System.IO;
using System.Runtime.CompilerServices;
using System.Text;
using System.Text.RegularExpressions;
using System.Xml.Linq;
namespace NJsonSchema
{
[System.Runtime.CompilerServices.NullableContext(1)]
[System.Runtime.CompilerServices.Nullable(0)]
public class ConversionUtilities
{
[System.Runtime.CompilerServices.NullableContext(0)]
private enum CamelCaseMode
{
None,
FirstLower,
FirstUpper
}
private static readonly char[] _camelCaseCleanupChars = new char[2] {
' ',
'/'
};
private static readonly char[] CamelCaseCleanupChars = _camelCaseCleanupChars;
private static readonly char[] _whiteSpaceChars = new char[4] {
'\n',
'\r',
'\t',
' '
};
private static readonly char[] _lineBreakTrimChars = new char[3] {
'\n',
'\t',
' '
};
private static readonly char[] _cSharpDocLineBreakChars = new char[2] {
'\r',
'\n'
};
private static readonly Lazy<Regex> _cSharpDocLineBreakRegex = new Lazy<Regex>(() => new Regex("^( *)/// ", RegexOptions.Multiline | RegexOptions.Compiled));
public static string ConvertToCamelCase(string input)
{
return ConvertToCamelCase(input, false, CamelCaseMode.None);
}
public static string ConvertToLowerCamelCase(string input, bool firstCharacterMustBeAlpha)
{
return ConvertToCamelCase(input, firstCharacterMustBeAlpha, CamelCaseMode.FirstLower);
}
public static string ConvertToUpperCamelCase(string input, bool firstCharacterMustBeAlpha)
{
return ConvertToCamelCase(input, firstCharacterMustBeAlpha, CamelCaseMode.FirstUpper);
}
private static string ConvertToCamelCase(string input, bool firstCharacterMustBeAlpha, CamelCaseMode mode)
{
if (string.IsNullOrEmpty(input))
return string.Empty;
if (input.AsSpan().IndexOfAny(CamelCaseCleanupChars) != -1)
input = input.Replace(' ', '_').Replace('/', '_');
if (input.AsSpan().IndexOf('-') == -1) {
char c = input[0];
if (char.IsNumber(c)) {
if (!firstCharacterMustBeAlpha)
return input;
return "_" + input;
}
char c2;
switch (mode) {
case CamelCaseMode.FirstUpper:
c2 = char.ToUpperInvariant(c);
break;
case CamelCaseMode.FirstLower:
c2 = char.ToLowerInvariant(c);
break;
default:
c2 = c;
break;
}
char c3 = c2;
if (c3 != c) {
string str = c3.ToString();
string text = input;
return str + text.Substring(1, text.Length - 1);
}
return input;
}
return DoFullCamelCaseConversion(input, firstCharacterMustBeAlpha, mode);
}
private unsafe static string DoFullCamelCaseConversion(string input, bool firstCharacterMustBeAlpha, CamelCaseMode mode)
{
int num = input.Length + (firstCharacterMustBeAlpha ? 1 : 0);
Span<char> span2;
if (num <= 256) {
Span<char> span = new Span<char>(stackalloc byte[512], 256);
span2 = span;
} else
span2 = new char[num];
Span<char> initialBuffer = span2;
System.Text.ValueStringBuilder valueStringBuilder = new System.Text.ValueStringBuilder(initialBuffer);
bool flag = false;
for (int i = 0; i < input.Length; i++) {
char c = input[i];
if (c == '-')
flag = true;
else if (flag) {
valueStringBuilder.Append(char.ToUpperInvariant(c));
flag = false;
} else {
if (i == 0) {
if (!firstCharacterMustBeAlpha || !char.IsNumber(c)) {
switch (mode) {
case CamelCaseMode.FirstUpper:
c = char.ToUpperInvariant(c);
break;
case CamelCaseMode.FirstLower:
c = char.ToLowerInvariant(c);
break;
}
} else
valueStringBuilder.Append('_');
}
valueStringBuilder.Append(c);
}
}
return valueStringBuilder.ToString();
}
public static string ConvertToStringLiteral(string input)
{
return ConvertToStringLiteral(input, null, null);
}
internal static string ConvertToStringLiteral(string input, [System.Runtime.CompilerServices.Nullable(2)] string prefix, [System.Runtime.CompilerServices.Nullable(2)] string postfix)
{
System.Text.ValueStringBuilder valueStringBuilder = new System.Text.ValueStringBuilder(input.Length + (prefix?.Length ?? 0) + (postfix?.Length ?? 0));
try {
if (prefix != null)
valueStringBuilder.Append(prefix);
foreach (char c in input) {
switch (c) {
case '\'':
valueStringBuilder.Append("\\'");
break;
case '"':
valueStringBuilder.Append("\\\"");
break;
case '\\':
valueStringBuilder.Append("\\\\");
break;
case ' ':
valueStringBuilder.Append("\\0");
break;
case '':
valueStringBuilder.Append("\\a");
break;
case '\b':
valueStringBuilder.Append("\\b");
break;
case ' ':
valueStringBuilder.Append("\\f");
break;
case '\n':
valueStringBuilder.Append("\\n");
break;
case '\r':
valueStringBuilder.Append("\\r");
break;
case '\t':
valueStringBuilder.Append("\\t");
break;
case ' ':
valueStringBuilder.Append("\\v");
break;
default:
if (c >= ' ' && c <= '~')
valueStringBuilder.Append(c);
else {
valueStringBuilder.Append("\\u");
int num = c;
valueStringBuilder.Append(num.ToString("x4", CultureInfo.InvariantCulture));
}
break;
}
}
if (postfix != null)
valueStringBuilder.Append(postfix);
return valueStringBuilder.ToString();
} finally {
valueStringBuilder.Dispose();
}
}
public static string TrimWhiteSpaces([System.Runtime.CompilerServices.Nullable(2)] string text)
{
return text?.Trim(_whiteSpaceChars) ?? string.Empty;
}
[System.Runtime.CompilerServices.NullableContext(0)]
public static ReadOnlySpan<char> TrimWhiteSpaces(ReadOnlySpan<char> text)
{
return text.Trim(_whiteSpaceChars);
}
public static string RemoveLineBreaks([System.Runtime.CompilerServices.Nullable(2)] string text)
{
return text?.Replace("\r", "").Replace("\n", " \n").Replace("\n ", "\n")
.Replace(" \n", " \n")
.Replace("\n", "")
.Trim(_lineBreakTrimChars) ?? string.Empty;
}
public static string Singularize(string word)
{
if (word == "people")
return "Person";
if (!Polyfills.EndsWith(word, 's'))
return word;
return word.Substring(0, word.Length - 1);
}
public static string Tab(string input, int tabCount)
{
if (input == null)
return "";
string text = CreateTabString(tabCount);
if (text.Length != 0) {
System.Text.ValueStringBuilder valueStringBuilder = new System.Text.ValueStringBuilder(input.Length);
try {
for (int i = 0; i < input.Length; i++) {
char c = input[i];
valueStringBuilder.Append(c);
if (c == '\n') {
bool flag = false;
for (int j = i + 1; j < input.Length; j++) {
char c2 = input[j];
if (c2 == '\n')
break;
if (!char.IsWhiteSpace(c2)) {
flag = true;
break;
}
}
if (flag)
valueStringBuilder.Append(text);
}
}
return valueStringBuilder.ToString();
} finally {
valueStringBuilder.Dispose();
}
}
return input;
}
public static void Tab(string input, int tabCount, TextWriter writer)
{
string tabString = CreateTabString(tabCount);
AddPrefixToBeginningOfNonEmptyLines(input, tabString, writer);
}
private static void AddPrefixToBeginningOfNonEmptyLines(string input, string tabString, TextWriter writer)
{
if (tabString.Length != 0) {
for (int i = 0; i < input.Length; i++) {
char c = input[i];
writer.Write(c);
if (c == '\n') {
bool flag = false;
for (int j = i + 1; j < input.Length; j++) {
char c2 = input[j];
if (c2 == '\n')
break;
if (!char.IsWhiteSpace(c2)) {
flag = true;
break;
}
}
if (flag)
writer.Write(tabString);
}
}
}
}
public static string ConvertCSharpDocs(string input, int tabCount)
{
if (input == null)
input = "";
if (input.IndexOfAny(_cSharpDocLineBreakChars) != -1)
input = input.Replace("\r", string.Empty).Replace("\n", "\n" + CreateTabString(tabCount) + "/// ");
string input2 = new XText(input).ToString();
return _cSharpDocLineBreakRegex.Value.Replace(input2, (Match m) => m.Groups[1]?.ToString() + "/// <br/>");
}
private static string CreateTabString(int tabCount)
{
switch (tabCount) {
case 0:
return "";
case 1:
return " ";
case 2:
return " ";
default:
return new string(' ', 4 * tabCount);
}
}
}
}