void TestList() {
List<int> a;
a.Add(3);
a.Add(5);
assert(a.Count() == 2);
assert(a.Contains(3));
assert(a.Contains(5));
assert(a[0] == 3);
List<int> b(a);
b.Add(a);
assert(b.Count() == 4);
a.Remove(3);
assert(a.Count() == 1);
assert(a.Contains(3) == false);
assert(a[0] = 5);
a.Insert(4, 0);
a.Insert(6, 1);
a.Insert(7, a.Count() - 1);
assert(a[0] == 4);
assert(a[1] == 6);
assert(a[2] == 7);
a.Remove(6);
assert(a[2] == 5);
}
void Vertex::RemoveIfNonNeighbor(Vertex *n) {
// removes n from neighbor list if n isn't a neighbor.
if(!neighbor.Contains(n)) return;
for(int i=0;i<face.num;i++) {
if(face[i]->HasVertex(n)) return;
}
neighbor.Remove(n);
}
void GameObject::OnHierarchyGameObjectsSelected(
List<GameObject*> &selectedEntities )
{
if (IsEditorGameObject() || IsScene()) return;
bool selected = selectedEntities.Contains(this);
bool wasSelected = IsSelected();
m_isSelectedInHierarchy = selected;
if (!wasSelected && selected)
{
m_selectionGameObject = new EditorSelectionGameObject(this);
m_selectionGameObject->SetParent(SceneManager::GetActiveScene());
}
else if (wasSelected && !selected && m_selectionGameObject)
{
delete m_selectionGameObject;
m_selectionGameObject = nullptr;
}
}
int main() {
// Demo the use of our LinkedList class.
LinkedList<int> l; // TData is int....
l.AddFirst(1); // ... so all the Add methods take ints.
l.AddFirst(2);
l.AddFirst(3);
l.AddLast(4);
l.AddLast(5);
// Use the .Get method to access individual elements.
// How efficient is this loop? Not as efficient.
// The loop takes too long to walk through all elements of linked lists
// if the size of linked list is large.
for (int i = 0; i < l.Size(); i++) {
cout << l.Get(i) << endl;
}
cout << "Remove: " << endl;
// The .RemoveFirst/Last/At methods return the data removed.
while (l.Size() > 0) {
cout << l.RemoveFirst() << endl;
}
cout << endl;
// It is easy to get the "border" cases wrong in a linked structure. Let's
// test to see what happens when adding to a list that had just been emptied.
l.AddFirst(1);
l.AddFirst(2);
l.AddFirst(3);
l.AddLast(4);
l.AddLast(5);
cout << "After adding back to the emptied list:" << endl;
for (int i = 0; i < l.Size(); i++) {
cout << l.Get(i) << endl;
}
// Does that look correct?
cout << endl;
cout << "Contains 14? " << endl;
// Demo the Contains method. Will this be true or false?
cout << l.Contains(14) << endl;
cout << endl;
// So far we have used the LinkedList directly, so the List base class
// doesn't seem necessary. Through polymorphism, we can declare a List
// pointer to a LinkedList object.
List<int> *p = new LinkedList<int>();
// We can now only call List<int> methods on p... which, fortunately, is all
// of our important functions.
p->AddLast(4);
p->AddLast(8);
p->AddLast(15);
p->AddLast(16);
p->AddLast(23);
p->AddLast(42);
cout << "Pointer to a List contains 16? " << p->Contains(16) << endl;
// So far we don't have much of a reason to do this type of polymorphism.
// But we will...
// Lecture part 2: iterators!
// Picture the normal iterator loop:
// for (_____::iterator itr = _____.begin(); itr != _____.end(); itr++) {
// do something with *itr or itr->
/*
If we want our LinkedList to follow this trend, what do we need to
implement?
1. An inner class named iterator, so our full scoped name will be
LinkedList<TData>::iterator
2. Operators ++, ==, !=, *, and -> in the iterator class.
3. Member methods .begin() and .end() in LinkedList.
When those are implemented, we can then...
*/
cout << endl << "ITERATORS!!!" << endl;
for (LinkedList<int>::iterator itr = l.begin(); itr != l.end(); itr++) {
cout << *itr << endl;
}
}
void main()
{
List L;
L.AddHead(1);
L.AddTail(2);
L.AddHead(3);
L.AddTail(4);
L.AddHead(5);
L.Print();
L.Insert();
L.Print();
L.Print(2);
L.Print(8);
List T;
T = L;
T.Print();
List Sum = -L + T;
Sum.Print();
int a[10] = { 8, 6, 7, 4 };
Sum.AddTailRange(a, 10);
Sum.Print();
cout << boolalpha << Sum.Contains(70) << endl;
cout << Sum << endl;
Sum[2].data = 500;
cout << Sum << endl;
cout << Sum.GetElementAt(5)->data << endl;
List Sum2 = Sum;
cout << boolalpha << Sum2.Equals(Sum) << endl;
Sum[1].data = 500;
cout << boolalpha << Sum2.Equals(Sum) << endl;
cout << "Index of 3 is: " << Sum.IndexOf(3) << endl;
cout << "Last index of 3 is: " << Sum.LastIndexOf(3) << endl;
Sum.InsertRange(a, 5, 1);
cout << Sum << endl;
Sum.Remove(5);
Sum.RemoveAll(500);
Sum.RemoveAll(0);
cout << Sum << endl;
cout << Sum.GetLength() << endl;
Sum.Revers();
cout << Sum << endl;
int * b = Sum.ToArray();
for (int i = 0; i < Sum.GetLength(); i++)
cout << b[i] << " ";
cout << endl;
delete[] b;
Sum.Sort();
cout << Sum << endl;
}
Ptr<workflow::WfFunctionDeclaration> Workflow_GenerateEventHandler(description::IEventInfo* eventInfo)
{
auto func = MakePtr<WfFunctionDeclaration>();
func->anonymity = WfFunctionAnonymity::Anonymous;
func->returnType = GetTypeFromTypeInfo(TypeInfoRetriver<void>::CreateTypeInfo().Obj());
vint count = eventInfo->GetHandlerType()->GetElementType()->GetGenericArgumentCount() - 1;
bool standardName = false;
if (count == 2)
{
auto senderType = eventInfo->GetHandlerType()->GetElementType()->GetGenericArgument(1)->GetTypeDescriptor();
auto argumentType = eventInfo->GetHandlerType()->GetElementType()->GetGenericArgument(2)->GetTypeDescriptor();
if (senderType == GetTypeDescriptor<GuiGraphicsComposition>())
{
auto expectedType = GetTypeDescriptor<GuiEventArgs>();
List<ITypeDescriptor*> types;
types.Add(argumentType);
for (vint i = 0; i < types.Count(); i++)
{
auto type = types[i];
if (type == expectedType)
{
standardName = true;
break;
}
vint baseCount = type->GetBaseTypeDescriptorCount();
for (vint j = 0; j < baseCount; j++)
{
auto baseType = type->GetBaseTypeDescriptor(j);
if (!types.Contains(baseType))
{
types.Add(baseType);
}
}
}
}
}
if (standardName)
{
{
auto arg = MakePtr<WfFunctionArgument>();
arg->name.value = L"sender";
arg->type = GetTypeFromTypeInfo(eventInfo->GetHandlerType()->GetElementType()->GetGenericArgument(1));
func->arguments.Add(arg);
}
{
auto arg = MakePtr<WfFunctionArgument>();
arg->name.value = L"arguments";
arg->type = GetTypeFromTypeInfo(eventInfo->GetHandlerType()->GetElementType()->GetGenericArgument(2));
func->arguments.Add(arg);
}
}
else
{
auto type = TypeInfoRetriver<Value>::CreateTypeInfo();
for (vint i = 0; i < count; i++)
{
auto arg = MakePtr<WfFunctionArgument>();
arg->name.value = L"<argument>" + itow(i + 1);
arg->type = GetTypeFromTypeInfo(type.Obj());
func->arguments.Add(arg);
}
}
return func;
}
