public void ElementEqualsPositiveTest()
{
var se1 = new SetElement <int>(1);
var se2 = new SetElement <int>(1);
Assert.IsTrue(se1.Equals(se2));
}
public void ElementEqualsSetNegativeTest()
{
var se1 = new SetElement <int>(1);
var s1 = new Set <int>();
Assert.IsFalse(se1.Equals(s1));
}
public void ElementEqualsNegativeTest()
{
var se1 = new SetElement <int>(1);
var se2 = new SetElement <int>(2);
Assert.IsFalse(se1.Equals(se2));
}
/// <summary>
/// Run the delegates for Element and Diagram for the current element.
/// - changeScope.Item Only Element itself and Diagrams of element, not beneath element
/// - changeScope... Element and all beneath Element
/// </summary>
/// <param name="rep"></param>
/// <param name="el"></param>
/// <param name="setEl"></param>
/// <param name="setDia"></param>
/// <param name="parameterStrings"></param>
/// <param name="changeScope"></param>
public static void DoRecursiveEl(Repository rep, EA.Element el, SetElement setEl, SetDiagram setDia,
string[] parameterStrings, ChangeScope changeScope)
{
// perform change for element
setEl?.Invoke(rep, el, parameterStrings);
// perform changes for diagrams beneath element
foreach (EA.Diagram dia in el.Diagrams)
{
if (dia != null)
{
setDia?.Invoke(rep, dia, parameterStrings);
}
}
// only the item itself, no recursion
if (changeScope == ChangeScope.Item)
{
return;
}
//run all elements
foreach (EA.Element elTrgt in el.Elements)
{
DoRecursiveEl(rep, elTrgt, setEl, setDia, parameterStrings, changeScope);
}
}
public void SetContainsElementNegativeTest()
{
var s1 = new Set <int>();
var se1 = new SetElement <int>(1);
Assert.IsFalse(s1.Contains(se1));
}
/// <summary>
/// Determines if the set contains a specific value.
/// </summary>
public bool Contains(T item)
{
SetElement cursor = head;
if (cursor != null)
{
while (item.CompareTo(cursor.Value) != 0)
{
if (item.CompareTo(cursor.Value) < 0)
{
if (cursor.Left == null)
{
return(false);
}
cursor = cursor.Left;
}
else if (item.CompareTo(cursor.Value) > 0)
{
if (cursor.Right == null)
{
return(false);
}
cursor = cursor.Right;
}
}
return(true);
}
return(false);
}
public SetElement MakeSet(T value)
{
SetElement element = new SetElement(value);
dict[value] = element;
return(element);
}
/// <summary>
/// Удаляет первое вхождение указанного объекта из множества
/// </summary>
/// <param name="item"> Объект, который необходимо удалить из множества</param>
/// <returns> Значение true, если объект item успешно удален из множества;
/// в противном случае и если значение item не найдено — значение false </returns>
public bool Remove(T item)
{
if (!Contains(item))
{
return(false);
}
var temp = head;
if (Equals(temp.value, item))
{
head = head.next;
Count--;
return(true);
}
while (!Equals(temp.next.value, item))
{
temp = temp.next;
}
if (temp.next.next == null)
{
temp.next = null;
}
else
{
temp.next = temp.next.next;
}
Count--;
return(true);
}
public void ElementContainsTest()
{
var se1 = new SetElement <int>(1);
var se2 = new SetElement <int>(2);
Assert.IsFalse(se1.Contains(se2));
}
public void Remove(T value)
{
if (this.head == null)
{
throw new EmptySetException("Set is empty");
}
if (this.head.Value.Equals(value))
{
this.head = this.head.Next;
return;
}
SetElement i = this.head;
while (i.Next != null)
{
if (i.Next.Value.Equals(value))
{
i.Next = i.Next.Next;
return;
}
i = i.Next;
}
throw new NonExistentItemException("there is no element with the specified value in the Set");
}
public bool Contains(T value)
{
if (this.head == null)
{
return(false);
}
if (this.head.Value.Equals(value))
{
return(true);
}
SetElement i = this.head;
while (i.Next != null)
{
i = i.Next;
if (i.Value.Equals(value))
{
return(true);
}
}
return(false);
}
public void SetContainsElementPositiveTest()
{
var s1 = new Set <int>();
var se1 = new SetElement <int>(1);
s1.Add(se1);
Assert.IsTrue(s1.Contains(se1));
}
/// <summary cref="IValueVisitor.Visit(SetElement)"/>
public void Visit(SetElement value)
{
if (!value.TryResolveConstantIndex(out int index))
{
throw new InvalidCodeGenerationException();
}
MakeCompoundRegisterStore(value, index, value.Value);
}
public void VertexElementEqualityPositiveTest()
{
var vertex1 = new Vertex();
var el1 = new SetElement <Vertex>(vertex1);
var el2 = new SetElement <Vertex>(vertex1);
Assert.IsTrue(el1.Equals(el2));
}
private SetElement MinimumElement(SetElement setElement)
{
if (setElement.Left == null)
{
return(setElement);
}
return(MinimumElement(setElement.Left));
}
public void VertexElementEqualityNegativeTest()
{
var vertex1 = new Vertex();
var el1 = new SetElement <Vertex>(vertex1);
var vertex2 = new Vertex();
var el2 = new SetElement <Vertex>(vertex2);
Assert.IsFalse(el1.Equals(el2));
}
private static T GetMinimumDataFromCurrentSetElement(SetElement currentSetElement)
{
while (currentSetElement.LeftSetElement != null)
{
currentSetElement = currentSetElement.LeftSetElement;
}
return(currentSetElement.Data);
}
public static void DoRecursiveEl(EA.Repository rep, EA.Element el, SetElement setEl, SetDiagram setDia, string[] s)
{
// perform
setEl(rep, el, s);
//run all elements
foreach (EA.Element elTrgt in el.Elements)
{
DoRecursiveEl(rep, elTrgt, setEl, setDia, s);
}
}
public static void DoRecursiveEl(EA.Repository rep, EA.Element el, SetElement setEl, SetDiagram setDia, string[] s)
{
// perform
setEl(rep, el, s);
//run all elements
foreach (EA.Element elTrgt in el.Elements)
{
DoRecursiveEl(rep, elTrgt, setEl, setDia, s);
}
}
public void SetEqualsNegativeTest()
{
var s1 = new Set <int>();
var se1 = new SetElement <int>(1);
s1.Add(se1);
var s2 = new Set <int>();
Assert.IsFalse(s1.Equals(s2));
}
public void EdgeElementEqualityPositiveTest()
{
var vertex1 = new Vertex();
var vertex2 = new Vertex();
var el1 = new SetElement <Tuple2 <Vertex, Vertex> >(new Tuple2 <Vertex, Vertex>(vertex1,
vertex2));
var el2 = new SetElement <Tuple2 <Vertex, Vertex> >(new Tuple2 <Vertex, Vertex>(vertex1,
vertex2));
Assert.IsTrue(el1.Equals(el2));
}
public void SetEqualsPositiveTest()
{
var s1 = new Set <int>();
var se1 = new SetElement <int>(1);
s1.Add(se1);
var s2 = new Set <int>();
s2.Add(se1);
Assert.IsTrue(s1.Equals(s2));
}
public SetElement AddSet(double x, double value)
{
var set = new SetElement
{
X = x,
Value = value
};
Add(set);
return(set);
}
/// <summary>
/// Изменяет текущий набор таким образом, чтобы он содержал только элементы, которые есть либо в нем, либо в указанной коллекции, но не одновременно там и там
/// </summary>
/// <param name="other"> Коллекция для сравнения с текущим набором</param>
public void SymmetricExceptWith(IEnumerable <T> other)
{
var setNew = this;
var setTemp = new Set <T>();
setTemp.UnionWith(setNew);
setNew.UnionWith(other);
setTemp.IntersectWith(other);
setNew.ExceptWith(setTemp);
head = setNew.head;
Count = setNew.Count;
}
private SetElement DeleteElementFromSet(SetElement setElement, T item)
{
if (setElement == null)
{
return(setElement);
}
if (item.CompareTo(setElement.Value) < 0)
{
setElement.Left = DeleteElementFromSet(setElement.Left, item);
}
else if (item.CompareTo(setElement.Value) > 0)
{
setElement.Right = DeleteElementFromSet(setElement.Right, item);
}
else if (setElement.Left != null && setElement.Right != null)
{
SetElement tempElement = MinimumElement(setElement.Right);
setElement.Value = tempElement.Value;
setElement.Right = DeleteElementFromSet(setElement.Right, setElement.Value);
}
else
{
if (setElement.Left != null)
{
SetElement tempElement = setElement;
setElement = setElement.Left;
if (head == tempElement)
{
head = setElement;
}
}
else if (setElement.Right != null)
{
SetElement tempElement = setElement;
setElement = setElement.Right;
if (head == tempElement)
{
head = setElement;
}
}
else
{
SetElement tempElement = setElement;
setElement = null;
if (head == tempElement)
{
head = setElement;
}
}
}
return(setElement);
}
public void Add(T value)
{
SetElement newElement = new SetElement(value);
if (this.head == null)
{
this.head = newElement;
return;
}
newElement.Next = this.head;
this.head = newElement;
}
/// <summary>
/// Изменяет текущий набор, чтобы он содержал только элементы, которые также имеются в заданной коллекции
/// </summary>
/// <param name="other"> Коллекция, с которой сравнивают</param>
public void IntersectWith(IEnumerable <T> other)
{
var setNew = new Set <T>();
foreach (var element in other)
{
if (Contains(element))
{
setNew.Add(element);
}
}
head = setNew.head;
Count = setNew.Count;
}
public void Print()
{
if (this.head == null)
{
Console.WriteLine("Set is empty");
}
SetElement i = this.head;
while (i != null)
{
Console.WriteLine(i.Value + " ");
i = i.Next;
}
}
public SetElement Union(SetElement root1, SetElement root2)
{
if (root2.Size > root1.Size)
{
root2.Size += root1.Size;
root1.Parent = root2;
return(root2);
}
else
{
root1.Size += root2.Size;
root2.Parent = root1;
return(root1);
}
}
override public string ToString()
{
StringBuilder sb = new StringBuilder();
HashSet <T> already_printed = new HashSet <T>();
foreach (T v in dict.Keys)
{
SetElement r = Find(v);
if (!already_printed.Contains(r.value))
{
sb.Append(r.value.ToString() + " : " + r.size + "\n");
already_printed.Add(r.value);
}
}
return(sb.ToString());
}
/// <summary>
/// Adds an item to the current set and returns a value indicating that the item was added successfully.
/// </summary>
public bool Add(T item)
{
++count;
var newElement = new SetElement
{
Value = item
};
SetElement cursor = head;
if (cursor != null)
{
while (true)
{
if (item.CompareTo(cursor.Value) < 0)
{
if (cursor.Left == null)
{
cursor.Left = newElement;
newElement.Parent = cursor;
break;
}
cursor = cursor.Left;
}
else if (item.CompareTo(cursor.Value) > 0)
{
if (cursor.Right == null)
{
cursor.Right = newElement;
newElement.Parent = cursor;
break;
}
cursor = cursor.Right;
}
else
{
--count;
return(false);
}
}
}
else
{
head = newElement;
}
return(true);
}
public static void DoRecursivePkg(EA.Repository rep, EA.Package pkg, SetPackage setPkg, SetElement setEl, SetDiagram setDia, string[] s)
{
// perform package
setPkg?.Invoke(rep, pkg, s);
// perform diagrams of package
foreach (EA.Diagram dia in pkg.Diagrams)
{
if (dia != null) setDia(rep, dia, s);
}
// run elements of package
foreach (EA.Element el in pkg.Elements)
{
if (setEl != null) DoRecursiveEl(rep, el, setEl, setDia, s);
}
// run packages of package
foreach (EA.Package pkgTrgt in pkg.Packages)
{
DoRecursivePkg(rep, pkgTrgt, setPkg, setEl, setDia, s);
}
}
public static Path FromFile(string filename, Ship ship)
{
ushort speed = (ushort)ship.Status.WalkingSpeed;
float lastx = ship.Position.x;
float lasty = ship.Position.y;
float lastz = ship.Position.z;
Rotator lastyaw = ship.Yaw;
Path path = new Path();
using (FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read))
using (XmlTextReader reader = new XmlTextReader(fs))
{
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
switch (reader.Name.ToUpperInvariant())
{
case "POINT":
lastx = float.Parse(reader["x"], CultureInfo.InvariantCulture);
lasty = float.Parse(reader["y"], CultureInfo.InvariantCulture);
lastz = float.Parse(reader["z"], CultureInfo.InvariantCulture);
lastyaw = int.Parse(reader["yaw"], CultureInfo.InvariantCulture);
PointElement p = new PointElement(path,
lastx, lasty, lastz, lastyaw);
break;
case "RESETPOSITION":
lastx = float.Parse(reader["x"], CultureInfo.InvariantCulture);
lasty = float.Parse(reader["y"], CultureInfo.InvariantCulture);
lastz = float.Parse(reader["z"], CultureInfo.InvariantCulture);
lastyaw = int.Parse(reader["yaw"], CultureInfo.InvariantCulture);
ResetElement r = new ResetElement(path,
lastx, lasty, lastz, lastyaw);
break;
case "SET":
speed = ushort.Parse(reader["speed"], CultureInfo.InvariantCulture);
SetElement s = new SetElement(path, speed);
break;
case "SHIPYARD":
ShipYard y = new ShipYard(path,
new Point(lastx, lasty, lastz), lastyaw,
new Point(
float.Parse(reader["x"], CultureInfo.InvariantCulture),
float.Parse(reader["y"], CultureInfo.InvariantCulture),
float.Parse(reader["z"], CultureInfo.InvariantCulture)),
byte.Parse(reader["to"], CultureInfo.InvariantCulture),
uint.Parse(reader["shiptime"], CultureInfo.InvariantCulture),
uint.Parse(reader["docktime"], CultureInfo.InvariantCulture));
break;
case "START":
ship.Position = new Point(lastx, lasty, lastz);
ship.Yaw = ship.Yaw;
path.resetpoint = path.Elements.Count;
ship.Status.WalkingSpeed = speed;
break;
}
break;
}
}
}
return path;
}
