private static void ComponentFinished(BSBaseComponent iComp)
{
List <BSBaseComponent> successors = SuccessorsForComponent(iComp) as List <BSBaseComponent>;
_sReadyElements.Add(iComp);
if (_sReadyElements.Count == _sComponents.Count)
{
_SimulationFinished();
return;
}
Parallel.ForEach(successors, (succ) =>
{
bool shouldStart = false;
lock (succ)
{
succ.Inputs.Push(iComp.Output);
shouldStart = _IsReadyToGo(succ);
}
if (shouldStart)
{
succ.Start();
ComponentFinished(succ);
}
});
}
/// <summary>
/// Adds another component to the components list.
/// </summary>
/// <param name="iComponent">A component to add</param>
/// <exception cref="ArgumentNullException"/>
public static void AddComponent(BSBaseComponent iComponent)
{
if (null == iComponent)
{
throw new ArgumentNullException();
}
BSManager._sComponents.Add(iComponent);
}
/// <summary>
/// A handler for the user's double click on drawing area event.
/// If double click occured on the component - would show component's
/// settings form (if component has one).
/// </summary>
/// <param name="iPoint">Double click position in drawing area coordinates.</param>
public static void UserDoubleClickedOnPoint(Point iPoint)
{
BSBaseComponent compAtPoint = FindComponentAtPoint(iPoint);
if (compAtPoint != null)
{
compAtPoint.ShowSettingsForm();
}
}
/// <summary>
/// Returns a list of predecessors for a given component (empty list if there are no predecessors).
/// </summary>
/// <param name="iComponent">A component, predecessors of which are being searched.</param>
/// <returns>List of predecessors for a given component.</returns>
/// <exception cref="KeyNotFoundException"/>
public static IList <BSBaseComponent> PredecessorsForComponent(BSBaseComponent iComponent)
{
if (!ContainsComponent(iComponent))
{
throw new KeyNotFoundException();
}
if (!ContainsPredecessorsForTheComponent(iComponent))
{
_sPredecessorsDict[iComponent] = new List <BSBaseComponent>();
}
return(_sPredecessorsDict[iComponent]);
}
public void LinksComponentsSuccessfullyIfEverythingIsGood()
{
BSManager.AddComponentWithNameAndRectangle(inputComponentName, new Rectangle(0, 0, width, height));
BSBaseComponent input = BSManager.Components[0];
BSManager.AddComponentWithNameAndRectangle(preprocessorComponentName, new Rectangle(width + distanceBetweenRects, 0, width, height));
BSBaseComponent preprocessor = BSManager.Components[1];
BSManager.LinkComponentsAtPoints(new Point(rnd.Next(width), rnd.Next(height)),
new Point(rnd.Next(width + distanceBetweenRects, 2 * width + distanceBetweenRects), rnd.Next(height)));
IList <BSBaseComponent> actualSuccs = BSManager.SuccessorsForComponent(input), actualPreds = BSManager.PredecessorsForComponent(preprocessor);
Assert.AreEqual(1, actualSuccs.Count); Assert.AreEqual(1, actualPreds.Count);
Assert.AreSame(preprocessor, actualSuccs[0]);
Assert.AreSame(input, actualPreds[0]);
}
/// <summary>
/// Tries to link two components, located at <paramref name="iSourceCompPoint"/> and <paramref name="iDestCompPoint"/> points.
/// Raises ComponentsCantBeLinkedException in this cases:
/// - components have been linked before;
/// - component at <paramref name="iSourceCompPoint"/> isn't an input providing component, or component at <paramref name="iDestCompPoint"/>;
/// - it's actually the same component.
/// isn't an input consuming component.
/// Raises ArgumentException if there isn't any component at some of the points.
/// </summary>
/// <param name="iSourceCompPoint">A point inside source component.</param>
/// <param name="iDestCompPoint">A point inside destination component.</param>
/// <exception cref="ArgumentException"/>
/// <exception cref="BSWork.BSComponents.ComponentsCantBeLinkedException"/>
// TODO: Add caching mechanism!
public static void LinkComponentsAtPoints(Point iSourceCompPoint, Point iDestCompPoint)
{
BSBaseComponent source = FindComponentAtPoint(iSourceCompPoint);
BSBaseComponent dest = FindComponentAtPoint(iDestCompPoint);
if (source == null || dest == null)
{
throw new ArgumentException("Some of the points (or both) isn't inside any component.");
}
if ((source == dest) || !IsInputComponent(source) || !IsOutputComponent(dest) || _ComponentsAreLinked(source, dest))
{
throw new ComponentsCantBeLinkedException();
}
AddSuccessorForComponent(source, dest);
AddPredecessorForComponent(dest, source);
}
public void AddsNewComponentCorrectly()
{
Random rnd = new Random();
string randomComponentName = BSManager.ComponentsNamesDict.Keys.ElementAt(rnd.Next(BSManager.ComponentsNamesDict.Keys.Count));
IComponentsFactory correspondingComponentFactory = BSManager.ComponentsNamesDict[randomComponentName];
Rectangle componentRectangle = new Rectangle(rnd.Next(), rnd.Next(), rnd.Next(), rnd.Next());
BSBaseComponent expectedComp = correspondingComponentFactory.NewComponent(componentRectangle);
BSManager.AddComponentWithNameAndRectangle(randomComponentName, componentRectangle);
IList <BSBaseComponent> actualCompsList = BSManager.Components;
Assert.AreEqual(1, actualCompsList.Count);
BSBaseComponent actualComp = actualCompsList.First();
Assert.AreEqual(expectedComp.GetType(), actualComp.GetType());
Assert.AreEqual(componentRectangle, actualComp.OnScreenRectangle);
}
private static void _AddPredOrSuccForComponent(BSBaseComponent iComponent, BSBaseComponent iPredOrSucc, Dictionary <BSBaseComponent, List <BSBaseComponent> > iDict)
{
if (null == iComponent)
{
throw new ArgumentNullException("iComponent");
}
if (null == iPredOrSucc)
{
throw new ArgumentNullException("iPredOrSucc");
}
if (!ContainsComponent(iComponent) || !ContainsComponent(iPredOrSucc))
{
throw new ArgumentException("No such component.");
}
if (!iDict.ContainsKey(iComponent))
{
_InitiateValueForTheComponent(iComponent, iDict);
}
_AddPredOrSuccWithoutChecks(iComponent, iPredOrSucc, iDict);
}
/// <summary>
/// Adds a succesor for a given component (successor must be already added before).
/// </summary>
/// <param name="iComponent">A component to add sucessor to.</param>
/// <param name="iSuccessor">Successor.</param>
/// <exception cref="ArgumentNullException"/>
/// <exception cref="ArgumentException"/>
public static void AddSuccessorForComponent(BSBaseComponent iComponent, BSBaseComponent iSuccessor)
{
_AddPredOrSuccForComponent(iComponent, iSuccessor, _sSuccessorsDict);
}
private static bool _IsReadyToGo(BSBaseComponent iComponent)
{
return(iComponent.Inputs.Count == PredecessorsForComponent(iComponent).Count);
}
private static void _InitiateValueForTheComponent(BSBaseComponent iComponent, Dictionary <BSBaseComponent, List <BSBaseComponent> > iDict)
{
iDict.Add(iComponent, new List <BSBaseComponent>());
}
private static void _AddPredOrSuccWithoutChecks(BSBaseComponent iComponent, BSBaseComponent iSuccessor, Dictionary <BSBaseComponent, List <BSBaseComponent> > iDict)
{
iDict[iComponent].Add(iSuccessor);
}
/// <summary>
/// Returns true if a component has been already added, false otherwise.
/// </summary>
/// <param name="iComponent"></param>
/// <returns>true or false.</returns>
public static bool ContainsComponent(BSBaseComponent iComponent)
{
return _sComponents.Contains(iComponent);
}
/// <summary>
/// Returns true if a component has been already added, false otherwise.
/// </summary>
/// <param name="iComponent"></param>
/// <returns>true or false.</returns>
public static bool ContainsComponent(BSBaseComponent iComponent)
{
return(_sComponents.Contains(iComponent));
}
/// <summary>
/// Returns true if one or more predecessors have been already added, false otherwise.
/// </summary>
/// <param name="iComponent"></param>
/// <returns>true or false.</returns>
public static bool ContainsPredecessorsForTheComponent(BSBaseComponent iComponent)
{
return(_sPredecessorsDict.ContainsKey(iComponent));
}
private static bool IsOutputComponent(BSBaseComponent iComp)
{
return(iComp.ComponentType.Contains('O'));
}
private static bool IsOutputComponent(BSBaseComponent iComp)
{
return iComp.ComponentType.Contains('O');
}
/// <summary>
/// Returns a list of successors for a given component (empty list if there are no successors).
/// </summary>
/// <param name="iComponent">A component, succesors of which are being searched.</param>
/// <returns>List of successors for a given component.</returns>
/// <exception cref="KeyNotFoundException"/>
public static IList<BSBaseComponent> SuccessorsForComponent(BSBaseComponent iComponent)
{
if (!ContainsComponent(iComponent)) throw new KeyNotFoundException();
if (!ContainsSuccessorsForTheComponent(iComponent))
_sSuccessorsDict[iComponent] = new List<BSBaseComponent>();
return _sSuccessorsDict[iComponent];
}
private static void _AddPredOrSuccForComponent(BSBaseComponent iComponent, BSBaseComponent iPredOrSucc, Dictionary<BSBaseComponent, List<BSBaseComponent>> iDict)
{
if (null == iComponent) throw new ArgumentNullException("iComponent");
if (null == iPredOrSucc) throw new ArgumentNullException("iPredOrSucc");
if (!ContainsComponent(iComponent) || !ContainsComponent(iPredOrSucc)) throw new ArgumentException("No such component.");
if (!iDict.ContainsKey(iComponent))
{
_InitiateValueForTheComponent(iComponent, iDict);
}
_AddPredOrSuccWithoutChecks(iComponent, iPredOrSucc, iDict);
}
/// <summary>
/// Adds another component to the components list.
/// </summary>
/// <param name="iComponent">A component to add</param>
/// <exception cref="ArgumentNullException"/>
public static void AddComponent(BSBaseComponent iComponent)
{
if (null == iComponent) throw new ArgumentNullException();
BSManager._sComponents.Add(iComponent);
}
private static bool _IsReadyToGo(BSBaseComponent iComponent)
{
return iComponent.Inputs.Count == PredecessorsForComponent(iComponent).Count;
}
private static void _InitiateValueForTheComponent(BSBaseComponent iComponent, Dictionary<BSBaseComponent, List<BSBaseComponent>> iDict)
{
iDict.Add(iComponent, new List<BSBaseComponent>());
}
private static bool _ComponentsAreLinked(BSBaseComponent source, BSBaseComponent dest)
{
return ContainsPredecessorsForTheComponent(dest) && _sPredecessorsDict[dest].Contains(source);
}
private static void _AddPredOrSuccWithoutChecks(BSBaseComponent iComponent, BSBaseComponent iSuccessor, Dictionary<BSBaseComponent, List<BSBaseComponent>> iDict)
{
iDict[iComponent].Add(iSuccessor);
}
private static bool _ComponentsAreLinked(BSBaseComponent source, BSBaseComponent dest)
{
return(ContainsPredecessorsForTheComponent(dest) && _sPredecessorsDict[dest].Contains(source));
}
/// <summary>
/// Adds a predecessor for a given component (predecessor must be already added before).
/// </summary>
/// <param name="iComponent">A component to add predecessor to.</param>
/// <param name="iPredecessor">Predecessor.</param>
/// <exception cref="ArgumentNullException"/>
/// <exception cref="ArgumentException"/>
public static void AddPredecessorForComponent(BSBaseComponent iComponent, BSBaseComponent iPredecessor)
{
_AddPredOrSuccForComponent(iComponent, iPredecessor, _sPredecessorsDict);
}
/// <summary>
/// Returns true if one or more successors have been already added, false otherwise.
/// </summary>
/// <param name="iComponent"></param>
/// <returns>true or false.</returns>
public static bool ContainsSuccessorsForTheComponent(BSBaseComponent iComponent)
{
return _sSuccessorsDict.ContainsKey(iComponent);
}
private static void ComponentFinished(BSBaseComponent iComp)
{
List<BSBaseComponent> successors = SuccessorsForComponent(iComp) as List<BSBaseComponent>;
_sReadyElements.Add(iComp);
if (_sReadyElements.Count == _sComponents.Count)
{
_SimulationFinished();
return;
}
Parallel.ForEach(successors, (succ) =>
{
bool shouldStart = false;
lock (succ)
{
succ.Inputs.Push(iComp.Output);
shouldStart = _IsReadyToGo(succ);
}
if (shouldStart)
{
succ.Start();
ComponentFinished(succ);
}
});
}
