protected override void HeaderAddExtra(CodeStringBuilder builderHeader, StronglyTypedClass info)
{
var namespaces = new List <string>
{
"winrt"
};
if (info.Namespaces != null)
{
namespaces.AddRange(info.Namespaces);
}
namespaces.Add("factory_implementation");
builderHeader.AppendEmptyLine();
HeaderOpenNamespace(builderHeader, namespaces, true);
builderHeader.AppendLine($"struct {info.ClassName} : {info.ClassName}T<{info.ClassName}, implementation::{info.ClassName}>");
builderHeader.AppendLine("{");
builderHeader.AppendLine("};");
builderHeader.AppendEmptyLine();
builderHeader.AppendLine($"struct {info.ClassName}Extension : {info.ClassName}ExtensionT<{info.ClassName}Extension, implementation::{info.ClassName}Extension>");
builderHeader.AppendLine("{");
builderHeader.AppendLine("};");
HeaderCloseNamespace(builderHeader, namespaces, true);
}
public IEnumerable <GeneratedFile> GetGeneratedFiles(string baseFilename, StronglyTypedClass info, ResourceInfo.ResourceFileInfo resourceFileInfo)
{
var builder = new CodeStringBuilder(resourceFileInfo.Project.GetIndentString());
GenerateHeaders(builder, info.IsAdvanced);
AddNewLine(builder);
OpenNamespace(builder, info.Namespaces);
OpenStronglyTypedClass(builder, info.ResoureFile, info.ClassName);
foreach (var item in info.Localizations)
{
AddNewLine(builder);
OpenRegion(builder, item.Key);
CreateFormatMethod(
builder,
item.Key,
item.IsProperty,
item.Parameters,
item.Summary,
item.ExtraParameters,
(item as PluralLocalization)?.ParameterToUseForPluralization,
(item as PluralLocalization)?.SupportNoneState ?? false,
(item as IVariantLocalization)?.ParameterToUseForVariant);
CloseRegion(builder, item.Key);
}
CloseStronglyTypedClass(builder);
AddNewLine(builder);
CreateMarkupExtension(builder, info.ResoureFile, info.ClassName + "Extension", info.Localizations.Where(i => i is Localization).Select(s => s.Key));
CloseNamespace(builder, info.Namespaces);
return(GetGeneratedFiles(builder, baseFilename));
}
/// <summary>
/// 강력한 형식의 뷰: 특정 모델 클래스가 사용되는 뷰
/// </summary>
public IActionResult StronglyTypedDemo()
{
var stc = new StronglyTypedClass()
{
Id = 1, Name = "홍길동", Age = 21
};
return(View(stc));
}
private StronglyTypedClass Parse(string content, string defaultNamespace, bool isAdvanced)
{
var namespaceToUse = ExtractNamespace(defaultNamespace);
var resourceFileName = Path.GetFileName(_resourceFileInfo.Path);
var className = Path.GetFileNameWithoutExtension(_resourceFileInfo.Path);
var reswInfo = ReswParser.Parse(content);
var projectNameIfLibrary = _resourceFileInfo.ParentProject.IsLibrary ? _resourceFileInfo.ParentProject.Name : null;
//If the resource file is in a library, the resource id in the .pri file
//will be <library name>/FilenameWithoutExtension
var resouceNameForResourceLoader = string.IsNullOrEmpty(projectNameIfLibrary) ?
className : projectNameIfLibrary + "/" + className;
var result = new StronglyTypedClass()
{
IsAdvanced = isAdvanced,
ClassName = className,
Namespaces = namespaceToUse,
ResoureFile = resouceNameForResourceLoader
};
var stringItems = reswInfo.Items
.Where(i => !i.Key.Contains(".") && !(i.Comment?.Contains(TagIgnore) ?? false)).ToArray();
if (isAdvanced)
{
//check Pluralization
var itemsWithPluralOrVariant = reswInfo.Items.GetItemsWithVariantOrPlural();
var basicItems = stringItems.Except(itemsWithPluralOrVariant.SelectMany(e => e.Items)).ToArray();
foreach (var item in itemsWithPluralOrVariant)
{
if (item.SupportPlural)
{
var idNone = item.Key + "_None";
var hasNoneForm = reswInfo.Items.Any(i => i.Key == idNone);
var singleLineValue = _regexRemoveSpace.Replace(item.Items.FirstOrDefault().Value, " ").Trim();
var summary = $"Get the pluralized version of the string similar to: {singleLineValue}";
PluralLocalization localization;
if (item.SupportVariants)
{
localization = new PluralVariantLocalization()
{
Key = item.Key,
Summary = summary,
SupportNoneState = hasNoneForm,
};
}
else
{
localization = new PluralLocalization()
{
Key = item.Key,
Summary = summary,
SupportNoneState = hasNoneForm,
};
}
if (item.Items.Any(i => i.Comment != null && i.Comment.Contains(Deprecated_TagStrongType)))
{
_logger?.LogError($"{Deprecated_TagStrongType} is no more supported, use {TagFormat} instead. See https://github.com/rudyhuyn/ReswPlus/blob/master/README.md");
}
var commentToUse =
item.Items.FirstOrDefault(i => i.Comment != null && _regexStringFormat.IsMatch(i.Comment));
ManageFormattedFunction(localization, commentToUse?.Comment, basicItems, resourceFileName);
result.Localizations.Add(localization);
}
else if (item.SupportVariants)
{
var singleLineValue = _regexRemoveSpace.Replace(item.Items.FirstOrDefault().Value, " ").Trim();
var summary = $"Get the variant version of the string similar to: {singleLineValue}";
var commentToUse = item.Items.FirstOrDefault(i => i.Comment != null && _regexStringFormat.IsMatch(i.Comment));
var localization = new VariantLocalization()
{
Key = item.Key,
Summary = summary,
};
ManageFormattedFunction(localization, commentToUse?.Comment, basicItems, resourceFileName);
result.Localizations.Add(localization);
}
}
stringItems = basicItems;
}
if (stringItems.Any())
{
foreach (var item in stringItems)
{
var singleLineValue = _regexRemoveSpace.Replace(item.Value, " ").Trim();
var summary = $"Looks up a localized string similar to: {singleLineValue}";
var localization = new RegularLocalization()
{
Key = item.Key,
Summary = summary,
};
if (isAdvanced)
{
ManageFormattedFunction(localization, item.Comment, stringItems, resourceFileName);
}
result.Localizations.Add(localization);
}
}
return(result);
}
public virtual IEnumerable <GeneratedFile> GeneratedFiles(string baseFilename, StronglyTypedClass info, ResourceFileInfo resourceInfo, IEnumerable <string> namespaceOverride)
{
var supportMultiNamespaceDeclaration = SupportMultiNamespaceDeclaration();
var namespacesToUse = namespaceOverride ?? info.Namespaces;
var markupClassName = info.ClassName + "Extension";
var headerFileName = baseFilename + ".h";
var cppFileName = baseFilename + ".cpp";
var baseNamespace = namespacesToUse == null || !namespacesToUse.Any() ? "" : namespacesToUse.Aggregate((a, b) => a + "::" + b);
var indentStr = resourceInfo.Project.GetIndentString();
var builderHeader = new CodeStringBuilder(indentStr);
var builderCpp = new CodeStringBuilder(indentStr);
var precompiledHeader = resourceInfo.Project.GetPrecompiledHeader();
var localNamespace = baseNamespace == "" ? "" : $"{LocalNamespaceName}::";
var namespaceResourceClass = $"{localNamespace}{info.ClassName}::";
var namespaceMarkupExtensionClass = $"{localNamespace}{markupClassName}::";
HeaderFileGenerateHeaders(builderHeader, info.ClassName, info.Namespaces, info.IsAdvanced);
builderHeader.AppendEmptyLine();
HeaderOpenNamespace(builderHeader, namespacesToUse, supportMultiNamespaceDeclaration);
HeaderOpenStronglyTypedClass(builderHeader, info.ResoureFile, info.ClassName);
builderHeader.AppendEmptyLine();
CppFileGenerateHeaders(builderCpp, precompiledHeader, headerFileName, baseNamespace, info.ClassName, info.Namespaces, info.IsAdvanced);
builderCpp.AppendEmptyLine();
CppGenerateStronglyTypedClassStaticFunc(builderCpp, namespaceResourceClass, info.ResoureFile);
builderCpp.AppendEmptyLine();
var firstLocalization = true;
foreach (var item in info.Localizations)
{
if (firstLocalization)
{
firstLocalization = false;
}
else
{
builderHeader.AppendEmptyLine();
builderCpp.AppendEmptyLine();
}
HeaderOpenRegion(builderHeader, item.Key);
HeaderCreateFormatMethod(builderHeader, item.Key, item.IsProperty, item.Parameters.OfType <FunctionFormatTagParameter>(), item.Summary, item.ExtraParameters);
builderCpp.AppendEmptyLine();
CppCreateFormatMethod(builderCpp, namespaceResourceClass, item.Key, item.IsProperty, item.IsDotNetFormatting, item.Parameters, item.ExtraParameters,
(item as PluralLocalization)?.ParameterToUseForPluralization,
(item as PluralLocalization)?.SupportNoneState ?? false,
(item as IVariantLocalization)?.ParameterToUseForVariant
);
HeaderCloseRegion(builderHeader);
}
HeaderCloseStronglyTypedClass(builderHeader);
builderHeader.AppendEmptyLine();
HeaderCreateMarkupExtension(builderHeader, info.ResoureFile, markupClassName, info.Localizations.Where(i => i is Localization).Select(s => s.Key), info.Namespaces);
HeaderCloseNamespace(builderHeader, namespacesToUse, supportMultiNamespaceDeclaration);
HeaderAddExtra(builderHeader, info);
builderCpp.AppendEmptyLine();
CppCreateMarkupExtension(builderCpp, namespaceMarkupExtensionClass, info.ResoureFile, markupClassName, info.Localizations.Where(i => i is Localization).Select(s => s.Key));
yield return(new GeneratedFile()
{
Filename = headerFileName, Content = builderHeader.GetString()
});
yield return(new GeneratedFile()
{
Filename = cppFileName, Content = builderCpp.GetString()
});
}
protected virtual void HeaderAddExtra(CodeStringBuilder builderHeader, StronglyTypedClass info)
{
}
public virtual IEnumerable <GeneratedFile> GetGeneratedFiles(string baseFilename, StronglyTypedClass info, ResourceFileInfo resourceFileInfo)
{
return(GeneratedFiles(baseFilename, info, resourceFileInfo, null));
}
public override IEnumerable <GeneratedFile> GetGeneratedFiles(string baseFilename, StronglyTypedClass info, ResourceInfo.ResourceFileInfo resourceFileInfo)
{
// Generate .cpp and .h files
var namespaces = new List <string>
{
"winrt"
};
if (info.Namespaces != null)
{
namespaces.AddRange(info.Namespaces);
}
namespaces.Add("implementation");
var generatedFiles = GeneratedFiles(baseFilename, info, resourceFileInfo, namespaces);
foreach (var file in generatedFiles)
{
yield return(file);
}
var builderIdl = new CodeStringBuilder(resourceFileInfo.ParentProject.GetIndentString());
// Generate .idl file
yield return(GenerateIdlFile(builderIdl, baseFilename, info));
}
private GeneratedFile GenerateIdlFile(CodeStringBuilder builderIdl, string baseFilename, StronglyTypedClass info)
{
HeaderOpenNamespace(builderIdl, info.Namespaces, false);
IdlOpenStronglyTypedClass(builderIdl, info.ClassName);
foreach (var item in info.Localizations)
{
IdlCreateFormatMethod(builderIdl, item.Key, item.IsProperty, item.Parameters.OfType <FunctionFormatTagParameter>(), item.Summary, item.ExtraParameters);
}
IdlCloseStronglyTypedClass(builderIdl);
builderIdl.AppendEmptyLine();
IdlCreateMarkupExtension(builderIdl, info.ClassName + "Extension", info.Localizations.Where(i => i is Localization).Select(s => s.Key));
HeaderCloseNamespace(builderIdl, info.Namespaces, false);
return(new GeneratedFile()
{
Filename = baseFilename + ".idl", Content = builderIdl.GetString()
});
}
