public string Convert(string input)
{
var numbers = input.Split(new []{"."},StringSplitOptions.RemoveEmptyEntries);
var chunks = Chunk(numbers[0]);
var seperators = new Seperators();
var sb = new StringBuilder();
sb.Prepend(seperators.Next());
sb.Prepend(VerbaliseLast(chunks.Pop(), chunks.Count > 0));
while (chunks.Count > 0)
{
var chunk = chunks.Pop();
var next = seperators.Next();
sb.Prepend(next);
var verbalise = Verbalise(chunk);
sb.Prepend(verbalise);
}
if (numbers.Length > 1)
{
sb.Append(" point");
foreach (var digit in numbers[1])
{
sb.AppendFormat(" {0}", verbalLookup[int.Parse(digit.ToString())]);
}
}
return sb.ToString()
.Trim();
}
private string GetFlagsStringRepresentation(long value)
{
var result = (ulong)value;
var names = MetaData.Names;
var values = MetaData.Values;
Contract.Assert(names.Count == values.Count);
var index = values.Count - 1;
var retval = new StringBuilder();
var firstTime = true;
var saveResult = result;
while (index >= 0)
{
var temp = (ulong)values[index];
if (index == 0 && temp == 0)
{
break;
}
if ((result & temp) == temp)
{
result -= temp;
if (!firstTime)
{
retval.Prepend(" | ");
}
retval.Prepend(names[index]);
firstTime = false;
}
index--;
}
if (result != 0)
{
return(value.ToString());
}
if (saveResult == 0)
{
if (values.Count > 0 && values[0] == 0)
{
return(names[0]);
}
return("0");
}
return(retval.ToString());
}
private string GetFlagsStringRepresentation(MemoryBuffer memory)
{
var value = ReadUnsignedValueFromMemory(memory);
var result = value;
var values = Enum.Values;
var index = values.Count - 1;
var retval = new StringBuilder();
var firstTime = true;
var saveResult = result;
while (index >= 0)
{
var temp = (ulong)values[index].Value;
if (index == 0 && temp == 0)
{
break;
}
if ((result & temp) == temp)
{
result -= temp;
if (!firstTime)
{
retval.Prepend(" | ");
}
retval.Prepend(values[index].Key);
firstTime = false;
}
index--;
}
if (result != 0)
{
return(value.ToString());
}
if (saveResult == 0)
{
if (values.Count > 0 && values[0].Value == 0)
{
return(values[0].Key);
}
return("0");
}
return(retval.ToString());
}
public static string ToShortString(this TimeSpan source)
{
//@"hh\:mm\:ss
StringBuilder formattedTimespan = new StringBuilder(@"mm\:ss");
if ((int)source.TotalHours > 0)
{
formattedTimespan.Prepend(@"hh\:");
}
if ((int)source.TotalDays > 0)
{
formattedTimespan.Prepend(@"dd\:");
}
return(source.ToString(formattedTimespan.ToString()));
}
protected override string CalcLineIndent(ITreeNode node)
{
string customIndent = GetCustomIndent(node, CustomIndentType.RelativeLineCalculation);
if (customIndent != null)
{
return(customIndent);
}
var indent = new StringBuilder();
foreach (ITokenNode token in node.GetFirstTokenIn().PrevTokens())
{
TokenNodeType tokenType = token.GetTokenType();
if (tokenType == PsiTokenType.WHITE_SPACE)
{
indent.Prepend(token.GetText());
}
else if (tokenType == PsiTokenType.NEW_LINE)
{
break;
}
}
return(indent.ToString());
}
public virtual void SaveScene(string state)
{
this.SetPath(state);
Debug.Log("Saving " + Serializer.scenePath);
foreach (var script in Locate.GetSceneComponents <MonoBehaviour>())
{
var serializable = script.GetAttributedVariables(typeof(Store).AsArray());
if (serializable.Count < 1)
{
continue;
}
var output = new StringBuilder();
foreach (var target in serializable)
{
var name = target.Key;
var value = target.Value;
output.Append(this.Save(name, value));
}
var contents = output.ToString().TrimRight(this.Separator());
if (!contents.IsEmpty())
{
var id = script.GetInstanceID().ToString().Replace("-", "n");
output.Prepend(this.Hash(id), this.Separator());
this.GetFile(script).Write(output.ToString().Trim(this.Separator()));
}
}
File.CheckSave();
}
public void TestPrependChar()
{
var sut = new StringBuilder("test");
sut.Prepend('x');
Check.That(sut.ToString()).IsEqualTo("xtest");
}
public void TestPrependString(string value)
{
var sut = new StringBuilder("test");
sut.Prepend(value);
Check.That(sut.ToString()).IsEqualTo(value + "test");
}
public void StringBuilder_Prepend()
{
StringBuilder sb = new StringBuilder();
sb.Append("b");
sb.Prepend("a");
Assert.AreEqual("ab", sb.ToString());
}
/// <summary>
/// Generates randome string based on the <see cref="ColumnTypeStringConfiguration"/>.
/// </summary>
/// <param name="config">String configuration.</param>
/// <returns>Ramdom string.</returns>
public static string RandomString(Dictionary <string, object> config)
{
string lenghtConfig = config.GetValueOrExpected <string>(ColumnTypeStringConfiguration.Length, null);
string textCaseConfig = config.GetValueOrExpected <string>(ColumnTypeStringConfiguration.Case, null);
ColumnTypeStringCaseConfiguration textCase;
if (string.IsNullOrEmpty(textCaseConfig))
{
textCase = ColumnTypeStringCaseConfiguration.Sentence;
}
else
{
textCase = EnumExtensions <ColumnTypeStringCaseConfiguration> .Parse(textCaseConfig);
}
var textSeperator = EnumExtensions <ColumnTypeStringCaseConfiguration> .GetDisplayValue(textCase);
var generatedString = new StringBuilder();
var textInfo = CultureInfo.CurrentCulture.TextInfo;
if (string.IsNullOrEmpty(lenghtConfig) || string.IsNullOrWhiteSpace(lenghtConfig))
{
int size = config.GetValueOrExpected <int>(ColumnTypeStringConfiguration.Length, 5);
var text = GenerateString(size);
var formattedText = StringCaseFormatter(textCase, text, textInfo, true);
generatedString.Append(formattedText);
}
else
{
var wordLengths = lenghtConfig.Split('|');
for (int i = 0; i < wordLengths.Length; i++)
{
var text = GenerateString(Convert.ToInt32(wordLengths[i]));
var formattedText = StringCaseFormatter(textCase, text, textInfo, i == 0);
generatedString.Append(formattedText + textSeperator);
}
generatedString.Remove(generatedString.Length - 1, 1);
}
var randomString = new StringBuilder(generatedString.ToString().Trim());
var prefix = config.GetValueOrExpected <string>(ColumnTypeStringConfiguration.Prefix, string.Empty);
var suffix = config.GetValueOrExpected <string>(ColumnTypeStringConfiguration.Suffix, string.Empty);
if (!string.IsNullOrEmpty(prefix))
{
randomString.Prepend(prefix);
}
if (!string.IsNullOrEmpty(suffix))
{
randomString.Append(suffix);
}
return(randomString.ToString());
}
protected override string CalcNodeIndent(ITreeNode node)
{
var indent = new StringBuilder();
foreach (ITokenNode token in node.GetFirstTokenIn().PrevTokens())
{
TokenNodeType tokenType = token.GetTokenType();
if (tokenType == PsiTokenType.WHITE_SPACE)
{
indent.Prepend(token.GetText());
}
else if (tokenType != PsiTokenType.NEW_LINE)
{
indent.Prepend(new string(' ', token.GetTextLength()));
}
else
{
break;
}
}
return indent.ToString();
}
protected override string CalcNodeIndent(ITreeNode node)
{
var indent = new StringBuilder();
foreach (ITokenNode token in node.GetFirstTokenIn().PrevTokens())
{
TokenNodeType tokenType = token.GetTokenType();
if (tokenType == PsiTokenType.WHITE_SPACE)
{
indent.Prepend(token.GetText());
}
else if (tokenType != PsiTokenType.NEW_LINE)
{
indent.Prepend(new string(' ', token.GetTextLength()));
}
else
{
break;
}
}
return(indent.ToString());
}
public void TestStringBuilder_Prepend()
{
var endLine = "blablabla";
var startLine = "Something";
_sb.Append(endLine);
_sb.Prepend(startLine);
var sb = new StringBuilder();
sb.Append(startLine);
sb.Append(endLine);
Assert.AreEqual(sb.ToString(), _sb.ToString());
}
/// <summary>
/// Generates ramdom integer based on <see cref="ColumnTypeIntegerConfiguration"/>.
/// </summary>
/// <param name="column">Integer configuration.</param>
/// <returns>Ramdon Integer.</returns>
public static string RandomInt(ref Column column)
{
int min = column.Config.GetValueOrExpected <int>(ColumnTypeIntegerConfiguration.Min, 1);
bool increment = column.Config.GetValueOrExpected <bool>(ColumnTypeIntegerConfiguration.Increment, false);
int value;
if (increment)
{
var interval = column.Config.GetValueOrExpected <int>(ColumnTypeIntegerConfiguration.Interval, 1);
value = min;
min += interval;
column.Config[ColumnTypeIntegerConfiguration.Min] = min;
}
else
{
int max = column.Config.GetValueOrExpected <int>(ColumnTypeIntegerConfiguration.Max, 1001);
if (min > max)
{
max = min + 1000;
}
value = random.Next(min, max);
}
var prefix = column.Config.GetValueOrExpected <string>(ColumnTypeIntegerConfiguration.Prefix, string.Empty);
var suffix = column.Config.GetValueOrExpected <string>(ColumnTypeIntegerConfiguration.Suffix, string.Empty);
var number = new StringBuilder(Convert.ToString(value));
if (!string.IsNullOrEmpty(prefix))
{
number.Prepend(prefix);
}
if (!string.IsNullOrEmpty(suffix))
{
number.Append(suffix);
}
return(number.ToString());
}
public virtual string SaveReference(string name, object value)
{
var output = new StringBuilder();
foreach (var variable in value.GetVariables())
{
var key = variable.Key;
var data = variable.Value;
output.Append(this.Save(key, data));
}
var contents = output.ToString().TrimRight(this.Separator());
if (!contents.IsEmpty())
{
var hash = this.GetHash(value);
var typeName = "[" + value.GetType().FullName + "]";
output.Prepend(typeName, this.Separator());
this.GetFile(value).Write(output.ToString().Trim(this.Separator()));
return(this.Format(name, "@" + hash));
}
return("");
}
protected override string CalcLineIndent(ITreeNode node)
{
string customIndent = GetCustomIndent(node, CustomIndentType.RelativeLineCalculation);
if (customIndent != null)
{
return customIndent;
}
var indent = new StringBuilder();
foreach (ITokenNode token in node.GetFirstTokenIn().PrevTokens())
{
TokenNodeType tokenType = token.GetTokenType();
if (tokenType == PsiTokenType.WHITE_SPACE)
{
indent.Prepend(token.GetText());
}
else if (tokenType == PsiTokenType.NEW_LINE)
{
break;
}
}
return indent.ToString();
}
/// <summary>
/// Prepends a line to the beginning of the string builder.
/// </summary>
/// <param name="text">String Builder instance.</param>
/// <param name="content">Line Content to prepent.</param>
/// <returns>Value after prependeding.</returns>
public static StringBuilder PrependLine(this StringBuilder text, string content)
{
text.Prepend(content);
return(text.Append(Environment.NewLine));
}
internal static string Format(string input, Markdown markdown)
{
if (string.IsNullOrWhiteSpace(input))
{
return(input);
}
var format = new StringBuilder("{0}");
if (markdown == 0)
{
return(format.ToString());
}
if (markdown.HasFlag(Markdown.Code))
{
if (markdown.HasFlag(Markdown.Quote))
{
format.Prepend("> ");
}
if (input.Contains('\n'))
{
format.Encase("```");
}
else
{
format.Encase('`');
}
}
else if (markdown.HasFlag(Markdown.Quote))
{
if (input.Contains('\n'))
{
format.Prepend(">>> ");
}
}
if (markdown.HasFlag(Markdown.Bold))
{
format.Encase("**");
}
if (markdown.HasFlag(Markdown.Italics))
{
format.Encase('*');
}
if (markdown.HasFlag(Markdown.Strike))
{
format.Encase("~~");
}
if (markdown.HasFlag(Markdown.Underline))
{
format.Encase("__");
}
if (markdown.HasFlag(Markdown.Spoiler))
{
format.Encase("||");
}
return(format.ToString());
}
public static StringBuilder PrependLine(this StringBuilder sb, string content) => sb.Prepend(content).Prepend(Environment.NewLine);
public static StringBuilder PrependLine(this StringBuilder builder, string content)
{
builder.Prepend(content);
return(builder.Prepend(Environment.NewLine));
}
/// <summary>
/// Resolves the type of a <see cref="BaseWrapperNode"/> node (<see cref="PointerNode"/> and <see cref="ArrayNode"/>).
/// </summary>
/// <param name="node">The node to resolve.</param>
/// <param name="isAnonymousExpression">Specify if the expression should be anonymous.</param>
/// <param name="logger">The logger.</param>
/// <returns>The resolved type of the node.</returns>
private string ResolveWrappedType(BaseNode node, bool isAnonymousExpression, ILogger logger)
{
Contract.Requires(node != null);
var sb = new StringBuilder();
if (!isAnonymousExpression)
{
sb.Append(node.Name);
}
BaseNode lastWrapperNode = null;
var currentNode = node;
while (true)
{
currentNode = TransformNode(currentNode);
if (currentNode is PointerNode pointerNode)
{
sb.Prepend('*');
if (pointerNode.InnerNode == null) // void*
{
if (!isAnonymousExpression)
{
sb.Prepend(' ');
}
sb.Prepend("void");
break;
}
lastWrapperNode = pointerNode;
currentNode = pointerNode.InnerNode;
}
else if (currentNode is ArrayNode arrayNode)
{
if (lastWrapperNode is PointerNode)
{
sb.Prepend('(');
sb.Append(')');
}
sb.Append($"[{arrayNode.Count}]");
lastWrapperNode = arrayNode;
currentNode = arrayNode.InnerNode;
}
else
{
var simpleType = GetTypeDefinition(currentNode, logger);
if (!isAnonymousExpression)
{
sb.Prepend(' ');
}
sb.Prepend(simpleType);
break;
}
}
return(sb.ToString().Trim());
}
internal static StringBuilder PrependIf(this StringBuilder builder, bool condition, string text)
{
return(condition ? builder?.Prepend(text) : builder);
}
