/// <summary> /// Creates a proxy Fluent Method Group. /// </summary> /// <param name="subjectFluentMethodGroup">the first group that become either subject or gets generalized depending on the generalizeSubject parameter</param> /// <param name="secondaryFluentMethodGroup">the second group which is always gets generalized</param> /// <param name="generalizeSubject">decides whether the subject fluent method group also needs to be generalized</param> /// <returns>proxy fluent method group</returns> public static ProxyFluentMethodGroup Create(IFluentMethodGroup subjectFluentMethodGroup, IFluentMethodGroup secondaryFluentMethodGroup, bool generalizeSubject) { ProxyFluentMethodGroup proxy = Init(subjectFluentMethodGroup); // if (generalizeSubject) { proxy.subjectFluentMethodGroup = null; // No subject, means use nullObjects // -- Generalize the subject Fluent Method Group -- GeneralizedOutput subjectGeneralized = GeneralizedOutput.Generalize(subjectFluentMethodGroup); // if (!subjectGeneralized.IsEmpty) { proxy.generalizedOutputs.Add(subjectGeneralized); } foreach (var output in subjectGeneralized.GeneralizedOutputs.Where(gop => !gop.IsEmpty)) { proxy.generalizedOutputs.Add(output); } // proxy.innerMethods.AddRange(subjectFluentMethodGroup.InnerMethods); proxy.childFluentMethodGroups.AddRange(subjectFluentMethodGroup.ChildFluentMethodGroups); } else { proxy.subjectFluentMethodGroup = subjectFluentMethodGroup; // foreach (var output in subjectFluentMethodGroup.GeneralizedOutputs.Where(gop => !gop.IsEmpty)) { proxy.generalizedOutputs.Add(output); } proxy.innerMethods.AddRange(subjectFluentMethodGroup.InnerMethods); proxy.childFluentMethodGroups.AddRange(subjectFluentMethodGroup.ChildFluentMethodGroups); } // // -- Generalize the secondary Fluent Method Group -- GeneralizedOutput secondaryGeneralized = GeneralizedOutput.Generalize(secondaryFluentMethodGroup); // if (!secondaryGeneralized.IsEmpty) { proxy.generalizedOutputs.Add(secondaryGeneralized); } foreach (var output in secondaryGeneralized.GeneralizedOutputs.Where(gop => !gop.IsEmpty)) { proxy.generalizedOutputs.Add(output); } // proxy.innerMethods.AddRange(secondaryFluentMethodGroup.InnerMethods); // proxy.childFluentMethodGroups.AddRange(secondaryFluentMethodGroup.ChildFluentMethodGroups); // return(proxy); }
/// <summary> /// Creates a proxy fluent method group for the given fluent method group. /// </summary> /// <param name="subjectFluentMethodGroup">the subject for which proxy needs to be created</param> /// <returns>proxy fluent method group</returns> public static ProxyFluentMethodGroup Create(IFluentMethodGroup subjectFluentMethodGroup) { ProxyFluentMethodGroup proxy = Init(subjectFluentMethodGroup); // proxy.subjectFluentMethodGroup = subjectFluentMethodGroup; // foreach (var output in subjectFluentMethodGroup.GeneralizedOutputs.Where(gop => !gop.IsEmpty)) { proxy.generalizedOutputs.Add(output); } return(proxy); }
/// <summary> /// Prune the "Segment Fluent Method Group" in this list to produce a "Fluent Method Group". /// </summary> /// <returns>Fluent Method Group</returns> public IFluentMethodGroup Prune() { var localGroups = this; if (localGroups.Count == 0) { return(null); } else { IFluentMethodGroup prunedGroup = ProxyFluentMethodGroup.Create(localGroups.First()); foreach (ISegmentFluentMethodGroup currentGroup in localGroups.Skip(1)) { if (prunedGroup.StandardFluentModel == null) { if (currentGroup.StandardFluentModel == null) { // If both doesn't have standard model then create a proxy by generalizing both // prunedGroup = ProxyFluentMethodGroup.Create(prunedGroup, currentGroup, true); } else { if (prunedGroup.GeneralizedOutputs.Select(go => go.DefineFunc).Any(d => d.IsDefineSupported)) { prunedGroup = ProxyFluentMethodGroup.Create(prunedGroup, currentGroup, true); } else { // If the current one have a standard model then make it the subject and generalize the pruned one // prunedGroup = ProxyFluentMethodGroup.Create(currentGroup, prunedGroup, false); } } } else { if (prunedGroup.LocalNameInPascalCase.Equals(this.InnerMethodGroupName, StringComparison.OrdinalIgnoreCase) && currentGroup.LocalNameInPascalCase.Equals(this.InnerMethodGroupName, StringComparison.OrdinalIgnoreCase)) { // If both has standard model and both local names matches with the inner method group name then // create a proxy by generalizing both. // prunedGroup = ProxyFluentMethodGroup.Create(prunedGroup, currentGroup, true); } else if (!prunedGroup.LocalNameInPascalCase.Equals(this.InnerMethodGroupName, StringComparison.OrdinalIgnoreCase) && !currentGroup.LocalNameInPascalCase.Equals(this.InnerMethodGroupName, StringComparison.OrdinalIgnoreCase)) { // If both has standard model and both local names doesn't matches with the inner method group name then // create a proxy by generalizing both. // prunedGroup = ProxyFluentMethodGroup.Create(prunedGroup, currentGroup, true); } else if (prunedGroup.LocalNameInPascalCase.Equals(this.InnerMethodGroupName, StringComparison.OrdinalIgnoreCase)) { // If both has standard models but only the local name of pruned matches with the inner method // group name then create a proxy with pruned as subject and current one generalized. // prunedGroup = ProxyFluentMethodGroup.Create(prunedGroup, currentGroup, false); } else { // If both has standard models but only the local name of current matches with the inner method // group name then create a proxy with current as subject and pruned one generalized. // prunedGroup = ProxyFluentMethodGroup.Create(currentGroup, prunedGroup, false); } } } this.PrunedMethodGroup = prunedGroup; return(prunedGroup); } }