/// <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 = DefaultViewSuffix) { //need to terminate with "." in order to concatenate with type name later var nsencoded = RegExHelper.NamespaceToRegEx(nsSource + "."); string rxbeforetgt, rxaftersrc, rxaftertgt; var 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 = DefaultViewSuffix) { 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)); } var rxbase = RegExHelper.GetNameCaptureGroup("basename"); var 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 = DefaultViewSuffix) { 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().Apply(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); }