/// <summary>
/// Appends this paragraph to the requirement set if it does not belong to it already
/// </summary>
/// <param name="requirementSet"></param>
public bool AppendToRequirementSet(RequirementSet requirementSet)
{
bool retVal = false;
if (!BelongsToRequirementSet(requirementSet))
{
retVal = true;
RequirementSetReference reference =
(RequirementSetReference)acceptor.getFactory().createRequirementSetReference();
reference.setTarget(requirementSet.Guid);
appendRequirementSets(reference);
}
return(retVal);
}
public bool SubParagraphBelongsToRequirementSet(RequirementSet requirementSet)
{
bool retVal = false;
foreach (Paragraph p in SubParagraphs)
{
retVal = p.BelongsToRequirementSet(requirementSet) ||
p.SubParagraphBelongsToRequirementSet(requirementSet);
if (retVal)
{
break;
}
}
return(retVal);
}
/// <summary>
/// Provides the list of applicable requirement sets
/// </summary>
/// <param name="applicableRequirementSets"></param>
private void FillApplicableRequirementSets(HashSet <RequirementSet> applicableRequirementSets)
{
foreach (RequirementSetReference reference in RequirementSetReferences)
{
RequirementSet requirementSet = reference.Ref;
if (requirementSet != null)
{
applicableRequirementSets.Add(reference.Ref);
}
}
Paragraph enclosing = EnclosingParagraph;
if (enclosing != null)
{
enclosing.FillApplicableRequirementSets(applicableRequirementSets);
}
}
/// <summary>
/// Indicates whether this paragraphs belongs to the functionam block whose name is provided as parameter
/// </summary>
/// <param name="requirementSet"></param>
public bool BelongsToRequirementSet(RequirementSet requirementSet)
{
bool retVal = false;
if (requirementSet != null)
{
// Try to find a reference to this requirement set
foreach (RequirementSetReference reference in RequirementSetReferences)
{
if (reference.Ref == requirementSet)
{
retVal = true;
break;
}
}
// Maybe a parent paragraph references this requirement set
// (only if the requirement set specifies that selection is recursive)
if (!retVal && requirementSet.getRecursiveSelection())
{
Paragraph enclosing = EnclosingParagraph;
if (enclosing != null)
{
retVal = enclosing.BelongsToRequirementSet(requirementSet);
}
}
// Try if the requirement belong to a sub requirement set
if (!retVal)
{
foreach (RequirementSet subSet in requirementSet.SubSets)
{
if (BelongsToRequirementSet(subSet))
{
retVal = true;
break;
}
}
}
}
return(retVal);
}
/// <summary>
/// Provides the requirement set whose name corresponds to the name provided
/// </summary>
/// <param name="name"></param>
/// <param name="create">Indicates that the requirement set should be created if it does not exists</param>
/// <returns></returns>
public RequirementSet findRequirementSet(string name, bool create)
{
RequirementSet retVal = null;
foreach (RequirementSet requirementSet in SubSets)
{
if (requirementSet.Name == name)
{
retVal = requirementSet;
break;
}
}
if (retVal == null && create)
{
retVal = (RequirementSet)acceptor.getFactory().createRequirementSet();
retVal.Name = name;
appendSubSets(retVal);
}
return(retVal);
}
public override void visit(Generated.Paragraph obj, bool visitSubNodes)
{
Paragraph paragraph = (Paragraph)obj;
if (paragraph.BelongsToRequirementSet(RequirementSet))
{
Paragraphs.Add(paragraph);
if (RequirementSet.getRecursiveSelection())
{
paragraph.GetParagraphs(Paragraphs);
}
else
{
base.visit(obj, visitSubNodes);
}
}
else
{
base.visit(obj, visitSubNodes);
}
}
/// <summary>
/// Adds a new requirement set to this list of requirement sets
/// </summary>
/// <param name="requirementSet"></param>
public void AddRequirementSet(RequirementSet requirementSet)
{
appendSubSets(requirementSet);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="requirementSet"></param>
/// <param name="paragraphs"></param>
public ParagraphForRequirementSet(RequirementSet requirementSet, List <Paragraph> paragraphs)
{
RequirementSet = requirementSet;
Paragraphs = paragraphs;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="requirementSet"></param>
/// <param name="belonging">
/// Indicates whether the paragraph should belong to the requirement set
/// </param>
/// <param name="notImplemented">Indicates that the the elements that should be marked are the not implemented ones</param>
/// or whether the requirement should not belong to that requirement set
public RequirementSetMarker(RequirementSet requirementSet, bool belonging, bool notImplemented)
{
RequirementSet = requirementSet;
Belonging = belonging;
NotImplemented = notImplemented;
}
/// <summary>
/// Marks the requirements which relate to the corresponding requirement set
/// </summary>
/// <param name="requirementSet"></param>
public void MarkRequirementsWhichDoNotBelongToRequirementSet(RequirementSet requirementSet)
{
MarkingHistory.PerformMark(() =>
{
RequirementSetMarker marker = new RequirementSetMarker(requirementSet, false, false);
foreach (Dictionary dictionary in Dictionaries)
{
marker.visit(dictionary);
}
});
}
/// <summary>
/// Marks the requirements which relate to the corresponding requirement set
/// </summary>
/// <param name="requirementSet"></param>
public void MarkNotImplementedRequirements(RequirementSet requirementSet)
{
MarkingHistory.PerformMark(() =>
{
RequirementSetMarker marker = new RequirementSetMarker(requirementSet, true, true);
foreach (Dictionary dictionary in Dictionaries)
{
marker.visit(dictionary);
}
});
}
/// <summary>
/// Adds a new requirement set to this list of requirement sets
/// </summary>
/// <param name="requirementSet"></param>
public void AddRequirementSet(RequirementSet requirementSet)
{
appendRequirementSets(requirementSet);
}