private void AddReq(ReqProRequirementPrx reqReqPrx,
int nTraceLevel, int nTraceFromHopCount, int nTraceToHopCount, ulong ulDegreeOffset,
ReqProRequirementPrx reqReqPrxTracesPreceder)
{
ReqTraceNode reqTraceNode = null;
ReqProRequirementPrx.eTraceAbortReason eAbort = ReqProRequirementPrx.eTraceAbortReason.eNoAbort;
if (dictReqKey.ContainsKey(reqReqPrx.Key))
/* this requirement was already handled */
{
reqTraceNode = dictReqKey[reqReqPrx.Key];
if (reqReqPrxTracesPreceder == null)
{
reqTraceNode.MakeRootNode();
}
if (!(reqTraceNode.TunedUp(nTraceFromHopCount, nTraceToHopCount)))
{
return;
}
}
if (reqReqPrxTracesPreceder != null)
{
if (listnReqTypeTracedKeyExcl.Contains(reqReqPrx.ReqTypeKey))
{
eAbort |= ReqProRequirementPrx.eTraceAbortReason.eReqTypeFilter;
showProgressReqTraceGrid(0, 0, "Filtered: " + reqReqPrx.Tag);
return;
}
}
int nTracesTo;
int nTracesFrom;
ReqProRequirementPrx[] aTracesTo;
ReqProRequirementPrx[] aTracesFrom;
ulong ulDegreeInc = 1UL;
for (int i = 0; i < (nTraceLevel + nMaxLevelTo); i++)
{
ulDegreeInc *= ulLevelMultiplier * ((ulong)nTraceLevel + (ulong)nMaxLevelTo);
}
Tracer tracer = new Tracer("Traces from/to Req " + reqReqPrx.Tag);
aTracesTo = reqReqPrx.GetRequirementTracesTo(nMaxTraceCount, ref eAbort, out nTracesTo, reqReqPrxTracesPreceder);
aTracesFrom = reqReqPrx.GetRequirementTracesFrom(nMaxTraceCount, ref eAbort, out nTracesFrom, reqReqPrxTracesPreceder);
tracer.Stop("Traces from/to Req " + reqReqPrx.Tag);
if (reqTraceNode == null)
{
reqTraceNode = new ReqTraceNode(reqReqPrx, ulDegreeOffset, reqReqPrxTracesPreceder == null,
aTracesFrom, aTracesTo, nTracesFrom, nTracesTo, eAbort, nTraceFromHopCount, nTraceToHopCount);
dictReqKey.Add(reqReqPrx.Key, reqTraceNode);
grid[TraceLevel2Index(nTraceLevel)].Add(reqTraceNode);
}
else
{
reqTraceNode.OnceAgain(ulDegreeOffset, reqReqPrxTracesPreceder == null,
aTracesFrom, aTracesTo, nTracesFrom, nTracesTo, eAbort, nTraceFromHopCount, nTraceToHopCount);
}
showProgressReqTraceGrid(0, 1, "Adding: " + reqTraceNode.Tag);
if (aTracesFrom.GetLength(0) > 0)
{
if (nTraceLevel < this.nMaxLevelFrom)
{
if (reqTraceNode.TraceFromHopCount < this.nMaxFromTraceHops)
{
int nNextTraceFromHopCount = nTraceFromHopCount;
ulong ulLocOffset = ulDegreeOffset * ulLevelMultiplier;
showProgressReqTraceGrid(aTracesFrom.GetLength(0), 0, null);
foreach (ReqProRequirementPrx reqReqPrxFrom in aTracesFrom)
{
if (dictReqKey.ContainsKey(reqReqPrxFrom.Key))
{
ReqTraceNode reqTN = dictReqKey[reqReqPrxFrom.Key];
reqTN.SetRelDegree(ulLocOffset);
reqTN.AddTraceTo(reqReqPrx);
}
else
{
ulLocOffset += ulDegreeInc;
AddReq(reqReqPrxFrom, nTraceLevel + 1, ++nNextTraceFromHopCount, nTraceToHopCount,
ulLocOffset, reqReqPrx);
}
}
}
else
{
System.Diagnostics.Trace.WriteLine("From Hops exceeded at: " + reqReqPrx.TagName);
showProgressReqTraceGrid(0, 0, "tracing from hops exceeded at: " + reqTraceNode.Tag);
eAbort |= ReqProRequirementPrx.eTraceAbortReason.eMaxFromHopsExceeded;
}
}
else
{
eAbort |= ReqProRequirementPrx.eTraceAbortReason.eMaxFromLevelReached;
}
}
if (aTracesTo.GetLength(0) > 0)
{
if (nTraceLevel > -this.nMaxLevelTo)
{
if (reqTraceNode.TraceToHopCount + 1 <= this.nMaxToTraceHops)
{
int nNextTraceToHopCount = reqTraceNode.TraceToHopCount + 1;
ulong ulLocOffset = ulDegreeOffset;
showProgressReqTraceGrid(aTracesTo.GetLength(0), 0, null);
foreach (ReqProRequirementPrx reqReqPrxTo in aTracesTo)
{
if (dictReqKey.ContainsKey(reqReqPrxTo.Key))
{
ReqTraceNode reqTN = dictReqKey[reqReqPrxTo.Key];
reqTN.SetRelDegree(ulLocOffset);
reqTN.AddTraceFrom(reqReqPrx);
}
else
{
ulLocOffset += ulDegreeInc;
AddReq(reqReqPrxTo, nTraceLevel - 1, nTraceFromHopCount, nTraceToHopCount,
ulLocOffset, reqReqPrx);
}
}
}
else
{
System.Diagnostics.Trace.WriteLine("To Hops exceeded at: " + reqReqPrx.TagName);
showProgressReqTraceGrid(0, 0, "tracing to exceeded at: " + reqTraceNode.Tag);
eAbort |= ReqProRequirementPrx.eTraceAbortReason.eMaxToHopsExceeded;
}
}
else
{
eAbort |= ReqProRequirementPrx.eTraceAbortReason.eMaxToLevelReached;
}
}
reqTraceNode.AbortReason = eAbort;
}
public ReqProRequirementPrx(ReqPro40.Project___v7 rpxProject, int nKey)
{
if (rpxProject == null)
{
Init("Key " + nKey, "unknown Project", "unknown Project");
}
else if (!rpxProject.IsProjectOpen)
{
Init("Key " + nKey, "not accessible", "not accessible");
}
else
{
ReqPro40.Requirement___v6 rpxReq = null;
Tracer tracer = new Tracer("Req (Key: " + nKey + ")");
if (rpxReqColl != null)
{
if (rpxProject.Prefix == strHomePrjPrefix)
{
/* somehow strange - Requirement discovered - but not accessible if it does not belong to the home project */
rpxReq = (Requirement___v6)rpxReqColl[nKey, ReqPro40.enumRequirementLookups.eReqLookup_Key];
}
}
if (rpxReq != null)
{
tracer.Stop("Req " + rpxReq.get_Tag(enumTagFormat.eTagFormat_Tag) + " got via rpxColl []");
}
else
{
try
{
rpxReq = dictReqCache[nKey];
dictReqCache.Remove(nKey);
dictReqCache.Add(nKey, rpxReq);
tracer.Stop("Req " + ((rpxReq != null) ? (rpxReq.get_Tag(enumTagFormat.eTagFormat_Tag)) : ("key " + nKey)) +
" got via ReqCache");
}
catch (System.Collections.Generic.KeyNotFoundException)
{
rpxReq = (Requirement___v6)rpxProject.GetRequirement(
nKey, ReqPro40.enumRequirementLookups.eReqLookup_Key,
ReqPro40.enumRequirementsWeights.eReqWeight_Medium,
ReqPro40.enumRequirementFlags.eReqFlag_Empty);
dictReqCache.Add(nKey, rpxReq);
if (dictReqCache.Count > nReqCacheSize)
{
foreach (KeyValuePair <int, ReqPro40.Requirement___v6> kvp in dictReqCache)
{
dictReqCache.Remove(kvp.Key);
break;
}
}
tracer.Stop("Req " + ((rpxReq != null) ? (rpxReq.get_Tag(enumTagFormat.eTagFormat_Tag)) : ("key " + nKey)) +
" got via rpxProject.GetRequirement");
}
}
Init(rpxReq);
}
this.rpxProject = rpxProject;
this.nKey = nKey;
strPrefix = "";
if (rpxProject != null)
{
if (rpxProject.Prefix != strHomePrjPrefix)
{
strPrefix = rpxProject.Prefix;
}
}
}
private void ParseRequirements()
{
ReqPro40.Requirements rpxReqColl;
ReqPro40.Requirement___v6 rpxReq;
ReqPro40.Relationship reqRelParent;
int nReqCount;
ReqTreeNode tnPackage;
ReqTreeNode reqMyTreeNode;
List <ReqTreeNode> reqUnassigned;
Dictionary <int, ReqTreeNode> dictReq;
int i = 0;
reqUnassigned = new List <ReqTreeNode>();
dictReq = new Dictionary <int, ReqTreeNode>();
cb.ShowProgressReqPkgTree(0, 0, 0, 0, "Identifying Requirements");
rpxReqColl = rpxProject.GetRequirements("*", ReqPro40.enumRequirementsLookups.eReqsLookup_All,
ReqPro40.enumRequirementsWeights.eReqWeight_Medium, ReqPro40.enumRequirementFlags.eReqFlag_Empty, 1000, 8);
ReqProRequirementPrx.RPXReqColl = rpxReqColl;
nReqCount = rpxReqColl.Count;
cb.ShowProgressReqPkgTree(0, 0, nReqCount, 0, nReqCount + " Requirements identified");
foreach (object o in rpxReqColl)
{
Tracer tracer = new Tracer("Req (Key: " + o + ") from Req Coll");
rpxReq = (ReqPro40.Requirement___v6)rpxReqColl[o, ReqPro40.enumRequirementLookups.eReqLookup_Key];
tracer.Stop("Req " + rpxReq.get_Tag(ReqPro40.enumTagFormat.eTagFormat_Tag) +
" got via eReqLookup_Key from Requirements Collection");
try
{
i++;
cb.ShowProgressReqPkgTree(0, 0, 0, i, null);
tnPackage = (ReqTreeNode)dictPackage[rpxReq.PackageKey];
reqMyTreeNode = new ReqTreeNode
(rpxReq.get_Tag(ReqPro40.enumTagFormat.eTagFormat_Tag) + ": " + rpxReq.Name,
rpxReq.key, ReqTreeNode.eReqTreeNodeType.eTreeNodeReq);
if (rpxReq.IsRoot)
{
if (tnPackage != null)
{
tnPackage.Add(ref reqMyTreeNode);
}
dictReq.Add(rpxReq.key, reqMyTreeNode);
}
else
{
//Tracer tr = new Tracer("Parent of " + reqMyTreeNode.Text + " discovering");
// performance is too low for that step :-(
//reqRelParent = rpxReq.get_Parent(ReqPro40.enumRequirementsWeights.eReqWeight_Medium);
//reqMyTreeNode.Parent = reqRelParent.SourceKey;
//reqUnassigned.Add(reqMyTreeNode);
//tr.Stop("Parent of " + reqMyTreeNode.Text + " discovered");
if (tnPackage != null)
{
tnPackage.Add(ref reqMyTreeNode);
}
dictReq.Add(rpxReq.key, reqMyTreeNode);
}
}
catch (Exception)
{
}
}
Tracer trCleanup = new Tracer("Cleanup Children Requirements");
while (reqUnassigned.Count > 0)
{
for (int j = 0; j < reqUnassigned.Count; j++)
{
reqMyTreeNode = reqUnassigned[j];
if (dictReq.ContainsKey(reqMyTreeNode.Parent))
{
tnPackage = dictReq[reqMyTreeNode.Parent];
tnPackage.Add(ref reqMyTreeNode);
dictReq.Add(reqMyTreeNode.Key, reqMyTreeNode);
reqUnassigned.Remove(reqMyTreeNode);
j--;
}
}
}
trCleanup.Stop("Cleanup Children Requirements");
cb.ShowProgressReqPkgTree(0, 0, 0, 0, i + " Requirements inserted");
cb.ShowProgressReqPkgTree(0, 0, 0, 0, null);
}