public string GetParameterString(FunctionFormatTagParameter info)
{
return(GetParameterTypeString(info.Type) +
" " +
(info.TypeToCast != null ? "(" + GetParameterTypeString(info.TypeToCast.Value) + ")" : null) +
info.Name);
}
private bool ManageFormattedFunction(Localization localization, string comment, IEnumerable <ReswItem> basicLocalizedItems, string resourceName)
{
FunctionFormatTagParametersInfo tagTypedInfo = null;
var(format, isDotNetFormatting) = ParseTag(comment);
if (format != null)
{
localization.IsDotNetFormatting = isDotNetFormatting;
var types = FormatTag.SplitParameters(format);
tagTypedInfo = FormatTag.ParseParameters(localization.Key, types, basicLocalizedItems, resourceName, _logger);
if (tagTypedInfo != null)
{
localization.Parameters = tagTypedInfo.Parameters;
}
}
if (localization is IVariantLocalization variantLocalization)
{
FunctionFormatTagParameter variantParameter = null;
// Add an extra parameter for variant if necessary
if (tagTypedInfo?.VariantParameter == null)
{
variantParameter = new FunctionFormatTagParameter
{
Type = ParameterType.Long, Name = "variantId", IsVariantId = true
};
localization.ExtraParameters.Add(variantParameter);
}
else
{
variantParameter = tagTypedInfo.VariantParameter;
}
variantLocalization.ParameterToUseForVariant = variantParameter;
}
if (localization is PluralLocalization pluralLocalization)
{
FunctionFormatTagParameter pluralizationQuantifier = null;
// Add an extra parameter for pluralization if necessary
if (tagTypedInfo?.PluralizationParameter == null)
{
pluralizationQuantifier = new FunctionFormatTagParameter
{
Type = ParameterType.Double, Name = "pluralizationReferenceNumber"
};
pluralLocalization.ExtraParameters.Add(pluralizationQuantifier);
}
else
{
pluralizationQuantifier = tagTypedInfo.PluralizationParameter;
}
pluralLocalization.ParameterToUseForPluralization = pluralizationQuantifier;
}
return(true);
}
protected abstract void CreateFormatMethod(CodeStringBuilder builder, string key, bool isProperty, IEnumerable <IFormatTagParameter> parameters, string summary = null,
IEnumerable <FunctionFormatTagParameter> extraParameters = null, FunctionFormatTagParameter parameterForPluralization = null, bool supportNoneState = false, FunctionFormatTagParameter parameterForVariant = null);
protected override void CppCreateFormatMethod(CodeStringBuilder builderCpp, string computedNamespace, string key, bool isProperty, bool isDotNetFormatting, IEnumerable <IFormatTagParameter> parameters, IEnumerable <FunctionFormatTagParameter> extraParameters = null, FunctionFormatTagParameter parameterForPluralization = null, bool supportNoneState = false, FunctionFormatTagParameter parameterForVariant = null)
{
if (isProperty)
{
builderCpp.AppendLine($"String^ {computedNamespace}{key}::get()");
}
else
{
var functionParameters = parameters != null?parameters.OfType <FunctionFormatTagParameter>().ToList() :
new List <FunctionFormatTagParameter>();
if (extraParameters != null && extraParameters.Any())
{
functionParameters.InsertRange(0, extraParameters);
}
var parametersStr = functionParameters.Any() ?
functionParameters.Select(p => GetParameterTypeString(p.Type, false) + " " + p.Name).Aggregate((a, b) => a + ", " + b)
: "";
builderCpp.AppendLine($"String^ {computedNamespace}{key}({parametersStr})");
}
builderCpp.AppendLine("{");
builderCpp.AddLevel();
string keyToUseStr = parameterForVariant != null ? $"ref new String(L\"{key}_Variant\") + {parameterForVariant.Name}" : $"L\"{key}\"";
string localizationStr;
if (parameterForPluralization != null)
{
var pluralNumber = parameterForPluralization.TypeToCast.HasValue ? $"static_cast<{GetParameterTypeString(parameterForPluralization.TypeToCast.Value, false)}>({parameterForPluralization.Name})" : parameterForPluralization.Name;
var supportNoneStateStr = supportNoneState ? "true" : "false";
localizationStr = $"ReswPlusLib::ResourceLoaderExtension::GetPlural(GetResourceLoader(), {keyToUseStr}, {pluralNumber}, {supportNoneStateStr})";
}
else
{
localizationStr = $"GetResourceLoader()->GetString({keyToUseStr})";
}
if (parameters != null && parameters.Any())
{
var formatParameters = parameters
.Select(p =>
{
switch (p)
{
case LiteralStringFormatTagParameter constStringParam:
{
return(isDotNetFormatting ? $"ref new String(L\"{constStringParam.Value}\")" : $"L\"{constStringParam.Value}\"");
}
case MacroFormatTagParameter macroParam:
{
return(isDotNetFormatting ? $"ReswPlusLib::Macros::{macroParam.Id}" : $"ReswPlusLib::Macros::{macroParam.Id}->Data()");
}
case StringRefFormatTagParameter localizationStringParameter:
{
return(isDotNetFormatting ? $"{localizationStringParameter.Id}" : $"{localizationStringParameter.Id}->Data()");
}
case FunctionFormatTagParameter functionParam:
{
switch (functionParam.Type)
{
case ParameterType.String:
return(isDotNetFormatting ? functionParam.Name : functionParam.Name + "->Data()");
case ParameterType.Object:
return(isDotNetFormatting ? functionParam.Name + "->ToString()" : functionParam.Name + "->ToString()->Data()");
default:
return(functionParam.Name);
}
}
default:
//should not happen
return("");
}
}).Aggregate((a, b) => a + ", " + b);
if (isDotNetFormatting)
{
builderCpp.AppendLine($"return ReswPlusLib::StringFormatting::FormatDotNet({localizationStr}, ref new Array<Object^>({parameters.Count()}){{{formatParameters}}});");
}
else
{
builderCpp.AppendLine($"size_t needed = _swprintf_p(nullptr, 0, {localizationStr}->Data(), {formatParameters});");
builderCpp.AppendLine($"wchar_t *buffer = new wchar_t[needed + 1];");
builderCpp.AppendLine($"_swprintf_p(buffer, needed + 1, {localizationStr}->Data(), {formatParameters});");
builderCpp.AppendLine($"return ref new String(buffer);");
}
}
else
{
builderCpp.AppendLine($"return {localizationStr};");
}
builderCpp.RemoveLevel();
builderCpp.AppendLine("}");
}
protected override void CreateFormatMethod(CodeStringBuilder builder, string key, bool isProperty, IEnumerable <IFormatTagParameter> parameters, string summary = null, IEnumerable <FunctionFormatTagParameter> extraParameters = null, FunctionFormatTagParameter parameterForPluralization = null, bool supportNoneState = false, FunctionFormatTagParameter parameterForVariant = null)
{
builder.AppendLine("/// <summary>");
builder.AppendLine($"/// {summary}");
builder.AppendLine("/// </summary>");
if (isProperty)
{
builder.AppendLine($"public static string {key}");
builder.AppendLine("{");
builder.AddLevel();
builder.AppendLine("get");
}
else
{
var functionParameters = parameters != null?parameters.OfType <FunctionFormatTagParameter>().ToList() :
new List <FunctionFormatTagParameter>();
if (extraParameters != null && extraParameters.Any())
{
functionParameters.InsertRange(0, extraParameters);
}
if (parameters.Any(p => p is FunctionFormatTagParameter functionParam && functionParam.IsVariantId) || extraParameters.Any(p => p.IsVariantId))
{
// one of the parameter is a variantId, we must create a second method with object as the variantId type.
var genericParametersStr = functionParameters.Select(p => (p.IsVariantId ? "object" : GetParameterTypeString(p.Type)) + " " + p.Name).Aggregate((a, b) => a + ", " + b);
builder.AppendLine($"public static string {key}({genericParametersStr})");
builder.AppendLine("{");
builder.AddLevel();
builder.AppendLine("try");
builder.AppendLine("{");
builder.AddLevel();
builder.AppendLine($"return {key}({functionParameters.Select(p => p.IsVariantId ? $"Convert.ToInt64({p.Name})" : p.Name).Aggregate((a, b) => a + ", " + b)});");
builder.RemoveLevel();
builder.AppendLine("}");
builder.AppendLine("catch");
builder.AppendLine("{");
builder.AddLevel();
builder.AppendLine("return \"\";");
builder.RemoveLevel();
builder.AppendLine("}");
builder.RemoveLevel();
builder.AppendLine("}");
builder.AppendEmptyLine();
builder.AppendLine("/// <summary>");
builder.AppendLine($"/// {summary}");
builder.AppendLine("/// </summary>");
}
var parametersStr = functionParameters.Select(p => GetParameterTypeString(p.Type) + " " + p.Name).Aggregate((a, b) => a + ", " + b);
builder.AppendLine($"public static string {key}({parametersStr})");
}
builder.AppendLine("{");
builder.AddLevel();
string keyToUseStr = $"\"{key}\"";
if (parameterForVariant != null)
{
keyToUseStr = $"\"{key}_Variant\" + {parameterForVariant.Name}";
}
string localizationStr;
if (parameterForPluralization != null)
{
var pluralNumber = parameterForPluralization.TypeToCast.HasValue ? $"({GetParameterTypeString(parameterForPluralization.TypeToCast.Value)}){parameterForPluralization.Name}" : parameterForPluralization.Name;
var supportNoneStateStr = supportNoneState ? "true" : "false";
localizationStr = $"ReswPlusLib.ResourceLoaderExtension.GetPlural(_resourceLoader, {keyToUseStr}, {pluralNumber}, {supportNoneStateStr})";
}
else
{
localizationStr = $"_resourceLoader.GetString({keyToUseStr})";
}
if (parameters != null && parameters.Any())
{
var formatParameters = parameters.Select(p =>
{
switch (p)
{
case FunctionFormatTagParameter functionParam:
return(functionParam.Name);
case MacroFormatTagParameter macroParam:
return($"ReswPlusLib.Macros.{macroParam.Id}");
case LiteralStringFormatTagParameter constStringParameter:
return($"\"{constStringParameter.Value}\"");
case StringRefFormatTagParameter localizationStringParameter:
return(localizationStringParameter.Id);
default:
//should not happen
return("");
}
}).Aggregate((a, b) => a + ", " + b);
builder.AppendLine($"return string.Format({localizationStr}, {formatParameters});");
}
else
{
builder.AppendLine($"return {localizationStr};");
}
if (isProperty)
{
builder.RemoveLevel();
builder.AppendLine("}");
}
builder.RemoveLevel();
builder.AppendLine("}");
}
protected abstract void CppCreateFormatMethod(CodeStringBuilder builderHeader, string computedNamespace, string key, bool isProperty, bool isDotNetFormatting, IEnumerable <IFormatTagParameter> parameters, IEnumerable <FunctionFormatTagParameter> extraParameters = null, FunctionFormatTagParameter parameterForPluralization = null, bool supportNoneState = false, FunctionFormatTagParameter parameterForVariant = null);
