/// <summary>
/// Adds a standard type mapping by substituting one subnamespace for another
/// </summary>
/// <param name="nsSource">Subnamespace of source type</param>
/// <param name="nsTargets">Subnamespaces of target type as an array</param>
/// <param name="viewSuffix">Suffix for type name. Should be "View" or synonym of "View". (Optional)</param>
public static void AddSubNamespaceMapping(string nsSource, string[] nsTargets, string viewSuffix = "View")
{
//need to terminate with "." in order to concatenate with type name later
var nsencoded = RegExHelper.NamespaceToRegEx(nsSource + ".");
string rxbeforetgt, rxaftersrc, rxaftertgt;
string rxbeforesrc = rxbeforetgt = rxaftersrc = rxaftertgt = String.Empty;
if (!String.IsNullOrEmpty(nsSource))
{
if (!nsSource.StartsWith("*"))
{
rxbeforesrc = RegExHelper.GetNamespaceCaptureGroup("nsbefore");
rxbeforetgt = @"${nsbefore}";
}
if (!nsSource.EndsWith("*"))
{
rxaftersrc = RegExHelper.GetNamespaceCaptureGroup("nsafter");
rxaftertgt = "${nsafter}";
}
}
var rxmid = RegExHelper.GetCaptureGroup("subns", nsencoded);
var nsreplace = String.Concat(rxbeforesrc, rxmid, rxaftersrc);
var nsTargetsRegEx = nsTargets.Select(t => String.Concat(rxbeforetgt, t, ".", rxaftertgt)).ToArray();
AddTypeMapping(nsreplace, null, nsTargetsRegEx, viewSuffix);
}
/// <summary>
/// Adds a standard type mapping based on namespace RegEx replace and filter patterns
/// </summary>
/// <param name="nsSourceReplaceRegEx">RegEx replace pattern for source namespace</param>
/// <param name="nsSourceFilterRegEx">RegEx filter pattern for source namespace</param>
/// <param name="nsTargetsRegEx">Array of RegEx replace values for target namespaces</param>
/// <param name="viewSuffix">Suffix for type name. Should be "View" or synonym of "View". (Optional)</param>
public static void AddTypeMapping(string nsSourceReplaceRegEx, string nsSourceFilterRegEx, string[] nsTargetsRegEx, string viewSuffix = "View")
{
RegisterViewSuffix(viewSuffix);
var replist = new List <string>();
var repsuffix = useNameSuffixesInMappings ? viewSuffix : String.Empty;
const string basegrp = "${basename}";
foreach (var t in nsTargetsRegEx)
{
replist.Add(t + String.Format(nameFormat, basegrp, repsuffix));
}
string rxbase = RegExHelper.GetNameCaptureGroup("basename");
string suffix = String.Empty;
if (useNameSuffixesInMappings)
{
suffix = viewModelSuffix;
if (!viewModelSuffix.Contains(viewSuffix) && includeViewSuffixInVmNames)
{
suffix = viewSuffix + suffix;
}
}
var rxsrcfilter = String.IsNullOrEmpty(nsSourceFilterRegEx)
? null
: String.Concat(nsSourceFilterRegEx, String.Format(nameFormat, RegExHelper.NameRegEx, suffix), "$");
var rxsuffix = RegExHelper.GetCaptureGroup("suffix", suffix);
NameTransformer.AddRule(
String.Concat(nsSourceReplaceRegEx, String.Format(nameFormat, rxbase, rxsuffix), "$"),
replist.ToArray(),
rxsrcfilter
);
}
/// <summary>
/// Adds a standard type mapping based on namespace RegEx replace and filter patterns
/// </summary>
/// <param name="nsSourceReplaceRegEx">RegEx replace pattern for source namespace</param>
/// <param name="nsSourceFilterRegEx">RegEx filter pattern for source namespace</param>
/// <param name="nsTargetsRegEx">Array of RegEx replace values for target namespaces</param>
/// <param name="viewSuffix">Suffix for type name. Should be "View" or synonym of "View". (Optional)</param>
public static void AddTypeMapping(string nsSourceReplaceRegEx, string nsSourceFilterRegEx, string[] nsTargetsRegEx, string viewSuffix = "View")
{
var replist = new List <string>();
Action <string> func;
const string basegrp = "${basename}";
var interfacegrp = "${" + InterfaceCaptureGroupName + "}";
if (useNameSuffixesInMappings)
{
if (viewModelSuffix.Contains(viewSuffix) || !includeViewSuffixInVmNames)
{
var nameregex = String.Format(nameFormat, basegrp, viewModelSuffix);
func = t => {
replist.Add(t + "I" + nameregex + interfacegrp);
replist.Add(t + "I" + basegrp + interfacegrp);
replist.Add(t + nameregex);
replist.Add(t + basegrp);
};
}
else
{
var nameregex = String.Format(nameFormat, basegrp, "${suffix}" + viewModelSuffix);
func = t => {
replist.Add(t + "I" + nameregex + interfacegrp);
replist.Add(t + nameregex);
};
}
}
else
{
func = t => {
replist.Add(t + "I" + basegrp + interfacegrp);
replist.Add(t + basegrp);
};
}
nsTargetsRegEx.ToList().ForEach(t => func(t));
string suffix = useNameSuffixesInMappings ? viewSuffix : String.Empty;
var srcfilterregx = String.IsNullOrEmpty(nsSourceFilterRegEx)
? null
: String.Concat(nsSourceFilterRegEx, String.Format(nameFormat, RegExHelper.NameRegEx, suffix), "$");
var rxbase = RegExHelper.GetNameCaptureGroup("basename");
var rxsuffix = RegExHelper.GetCaptureGroup("suffix", suffix);
//Add a dummy capture group -- place after the "$" so it can never capture anything
var rxinterface = RegExHelper.GetCaptureGroup(InterfaceCaptureGroupName, String.Empty);
NameTransformer.AddRule(
String.Concat(nsSourceReplaceRegEx, String.Format(nameFormat, rxbase, rxsuffix), "$", rxinterface),
replist.ToArray(),
srcfilterregx
);
}
/// <summary>
/// Adds a standard type mapping based on simple namespace mapping
/// </summary>
/// <param name="nsSource">Namespace of source type</param>
/// <param name="nsTargets">Namespaces of target type as an array</param>
/// <param name="viewSuffix">Suffix for type name. Should be "View" or synonym of "View". (Optional)</param>
public static void AddNamespaceMapping(string nsSource, string[] nsTargets, string viewSuffix = "View")
{
//need to terminate with "." in order to concatenate with type name later
var nsencoded = RegExHelper.NamespaceToRegEx(nsSource + ".");
//Start pattern search from beginning of string ("^")
//unless original string was blank (i.e. special case to indicate "append target to source")
if (!String.IsNullOrEmpty(nsSource))
{
nsencoded = "^" + nsencoded;
}
//Capture namespace as "origns" in case we need to use it in the output in the future
var nsreplace = RegExHelper.GetCaptureGroup("origns", nsencoded);
var nsTargetsRegEx = nsTargets.Select(t => t + ".").ToArray();
AddTypeMapping(nsreplace, null, nsTargetsRegEx, viewSuffix);
}