public void ContainsTest()
{
var list = new OrderedList <int>(new int[] { 10, 5, 7, 5, 2, 15 });
Assert.IsTrue(list.Contains(7));
Assert.IsTrue(list.Contains(5));
Assert.IsFalse(list.Contains(42));
}
/// <include file='IniSectionCollection.xml' path='//Method[@name="Add"]/docs/*' />
public void Add(IniSection section)
{
if (_sectionNames.Contains(section))
{
throw new ArgumentException("IniSection already exists");
}
_sectionNames.Add(section.Name, section);
}
public void Remove_removes_items()
{
var s = "a string";
var list = new OrderedList<string>();
list.Add(s);
Assert.IsTrue(list.Contains(s));
Assert.IsTrue(list.Remove(s));
Assert.IsFalse(list.Contains(s));
}
public Path FindPath(Node start, Node end)
{
var openedNodesList = new OrderedList <NodePathfindingData>(_grid.Width * _grid.Height, new NodesComparer());
var closedNodesSet = new HashSet <NodePathfindingData>();
var startNodeData = _nodes[start.X, start.Y];
var endNodeData = _nodes[end.X, end.Y];
openedNodesList.Add(startNodeData);
while (openedNodesList.Count > 0)
{
var currentNode = openedNodesList[0];
openedNodesList.RemoveAt(0);
closedNodesSet.Add(currentNode);
if (currentNode.Node == end)
{
return(new Path(startNodeData, endNodeData));
}
var nearbyNodes = _grid.GetNearbyNodes(currentNode.Node);
for (var i = 0; i < nearbyNodes.Count; i++)
{
var nearbyNode = _nodes[nearbyNodes[i].X, nearbyNodes[i].Y];
if (!nearbyNode.Node.IsWalkable || closedNodesSet.Contains(nearbyNode))
{
continue;
}
int cost = currentNode.DistanceFromStartNode + GetDistance(currentNode, nearbyNode);
if (cost >= nearbyNode.DistanceFromStartNode && openedNodesList.Contains(nearbyNode))
{
continue;
}
nearbyNode.DistanceFromStartNode = cost;
nearbyNode.DistanceToEndNode = GetDistance(nearbyNode, endNodeData);
nearbyNode.Parent = currentNode;
if (!openedNodesList.Contains(nearbyNode))
{
openedNodesList.Add(nearbyNode);
}
}
}
return(null);
}
public void Setup(MarkdownPipelineBuilder pipeline)
{
OrderedList <InlineParser> parsers = pipeline.InlineParsers;
if (!parsers.Contains <ComponentParser>())
{
parsers.Add(new ComponentParser());
}
}
public static MarkdownPipelineBuilder UseKeyboard(this MarkdownPipelineBuilder pipeline, KeyboardOptions options)
{
OrderedList <IMarkdownExtension> extensions = pipeline.Extensions;
if (!extensions.Contains <KeyboardExtension>())
{
extensions.Add(new KeyboardExtension(options));
}
return(pipeline);
}
public static MarkdownPipelineBuilder UseCommentMarks(this MarkdownPipelineBuilder pipeline)
{
OrderedList <IMarkdownExtension> extensions = pipeline.Extensions;
if (!extensions.Contains <CommentMarkExtension>())
{
extensions.Add(new CommentMarkExtension());
}
return(pipeline);
}
public virtual string Get(string key)
{
string result = null;
if (keys.Contains(key))
{
result = keys[key].ToString();
}
return(result);
}
/// <include file='IConfig.xml' path='//Method[@name="Get"]/docs/*' />
public string Get(string key)
{
string result = null;
if (keys.Contains(key))
{
result = (string)keys[key];
}
return(result);
}
public static MarkdownPipelineBuilder UseBamComponents(this MarkdownPipelineBuilder pipeline, ComponentOptions options)
{
OrderedList <IMarkdownExtension> extensions = pipeline.Extensions;
if (!extensions.Contains <ComponentExtension>())
{
extensions.Add(new ComponentExtension(options));
}
return(pipeline);
}
private void NotifyItemsChanged(OrderedList <T> selection, OrderedList <T> newSelection)
{
foreach (T obj in (List <T>)selection)
{
if (!newSelection.Contains(obj))
{
obj.IsSelected = false;
}
}
foreach (T obj in (List <T>)newSelection)
{
if (!selection.Contains(obj))
{
obj.IsSelected = true;
}
}
}
/// <summary>
/// Get/Set key - value pairs in our OrderedList
/// </summary>
/// <param name="key">
/// A <see cref="System.String"/>
/// </param>
public string this[string key]
{
get {
if (envList.Contains(key))
{
lock (syncRoot) {
return(envList[key].ToString());
}
}
else
{
return(null);
}
}
set {
lock (syncRoot) {
envList[key] = value;
}
}
}
public IList <PointInt32> FindPath(IMover mover, PointInt32 start, PointInt32 target)
{
if (m_Map.IsBlocked(mover, target))
{
return(null);
}
m_Nodes.Clear();
m_Nodes[start].Cost = 0f;
m_Nodes[start].Depth = 0;
m_Closed.Clear();
m_Open.Clear();
m_Open.Add(m_Nodes[start]);
m_Nodes[target].Parent = null;
int maxDepth = 0;
while ((maxDepth < m_MaxSearchDistance) && (m_Open.Count != 0))
{
var current = m_Open.First();
if (current == m_Nodes[target])
{
break;
}
m_Open.Remove(current);
m_Closed.Add(current);
for (int x = -1; x < 2; x++)
{
for (int y = -1; y < 2; y++)
{
if (((x != 0) || (y != 0)) && (m_AllowDiagMovement || ((x == 0) || (y == 0))))
{
var point = new PointInt32(current.Point.X + x, current.Point.Y + y);
if (IsValidLocation(mover, start, point))
{
float nextStepCost = current.Cost + m_Map.GetCost(mover, current.Point, point);
var neighbour = m_Nodes[point];
m_Map.PathfinderCallback(point);
if (nextStepCost < neighbour.Cost)
{
if (m_Open.Contains(neighbour))
{
m_Open.Remove(neighbour);
}
if (m_Closed.Contains(neighbour))
{
m_Closed.Remove(neighbour);
}
}
if (!(m_Open.Contains(neighbour) || m_Closed.Contains(neighbour)))
{
neighbour.Cost = nextStepCost;
neighbour.Heuristic = m_Heuristic.GetCost(m_Map, mover, point, start, target);
maxDepth = System.Math.Max(maxDepth, neighbour.SetParent(current));
m_Open.Add(neighbour);
}
}
}
}
}
}
if (m_Nodes[target].Parent == null)
{
return(null);
}
var path = new List <PointInt32>();
for (var targetNode = m_Nodes[target]; targetNode != m_Nodes[start]; targetNode = targetNode.Parent)
{
path.Insert(0, targetNode.Point);
}
path.Insert(0, start);
return(path);
}
