Classes/LinkedList/ObjectLinkedList3.cpp

#include "ObjectLinkedList.h"
#include "../System/SystemDefine.h"
#include "../Element/DefineObjects.h"
#include "../String/Parse.h"
#include "../Sort/ObjectLinkedListQuickSort.h"
#include "../System/System.h"
#include "../String/StringTools.h"

ObjectLinkedList::ObjectLinkedList()
{
        howfar=0;
}

////////////////////////////////////////////////////////////////////////////////////
//free memory for all Elements that exsist in the LinkedList
////////////////////////////////////////////////////////////////////////////////////

ObjectLinkedList::~ObjectLinkedList()
{
        removeAllElement();
}

////////////////////////////////////////////////////////////////////////////////////
//free memory for all Elements that exsist in the LinkedList
////////////////////////////////////////////////////////////////////////////////////

void ObjectLinkedList::removeAllElement()
{
        if ( howfar != 0 )
        {
                ObjectElement *element=first;

                for ( int s=0; s<howfar ; s++ )
                {
                        ObjectElement *tempElement=element->next;
                        delete element;
                        element=tempElement;
                }
        }

}

////////////////////////////////////////////////////////////////////////////////////
//How many Elements is it in the LinkedList
////////////////////////////////////////////////////////////////////////////////////

int ObjectLinkedList::size()
{
        return howfar;
}

////////////////////////////////////////////////////////////////////////////////////
//add a Element to the LinkedList
////////////////////////////////////////////////////////////////////////////////////
/*
ObjectElement *ObjectLinkedList::addLast(ChunkNameElement *iChunkNameElement)
{
        return addLastMain((void*)iChunkNameElement,DefineChunkNameElement);
}
*/
ObjectElement *ObjectLinkedList::addLast(ExtPropertiesElement *iExtPropertiesElement)
{
        return addLastMain((ObjectElement*)iExtPropertiesElement,DefineExtPropertiesElement);
}

ObjectElement *ObjectLinkedList::addLastMain(void *iObjectElement, int iTypeOfObject)
{
        if (howfar == 0)
        {
          first = new ObjectElement(iObjectElement,iTypeOfObject,Parse::intToString(howfar));
          last=first;
        }
        else
        {
          last->next = new ObjectElement(iObjectElement,iTypeOfObject,Parse::intToString(howfar));      
      last->next->previos=last;
          last=last->next;
        }
        
        howfar++;

        return (ObjectElement*)last->pointer;
}

ObjectElement *ObjectLinkedList::addLast(SGI *sgi, char *iName)
{
        return addLastMainWithName((void*)sgi,DefineSGI, iName);
}
/*
ObjectElement *ObjectLinkedList::addLast(ChunkNameElement *iChunkNameElement, char *iName)
{
        return addLastMainWithName((void*)iChunkNameElement,DefineChunkNameElement, iName);
}
*/
ObjectElement *ObjectLinkedList::addLast(ExtPropertiesElement *iExtPropertiesElement, char *iName)
{
        return addLastMainWithName((ObjectElement*)iExtPropertiesElement,DefineExtPropertiesElement, iName);
}

ObjectElement *ObjectLinkedList::addLastMainWithName(void *iObjectElement, int iTypeOfObject, char *iName)
{

        if (iTypeOfObject==DefineSGI)
        {       
                ObjectElement *objectElement=checkIfElementNameExist(iName);

                if(objectElement!=null)
                {
                        return objectElement;
                }
        }

        if (howfar == 0)
        {
          first = new ObjectElement(iObjectElement,iTypeOfObject,iName);
          last=first;
        }
        else
        {
          last->next = new ObjectElement(iObjectElement,iTypeOfObject,iName);   
      last->next->previos=last;
          last=last->next;
        }
        
        howfar++;

        return (ObjectElement*)last->pointer;
}


////////////////////////////////////////////////////////////////////////////////////
//check if a element with same name exist
////////////////////////////////////////////////////////////////////////////////////

ObjectElement *ObjectLinkedList::checkIfElementNameExist(char *name)
{
        ObjectElement *element=first;

        for ( int s=0; s<howfar ; s++ )
        {
                if (element->name->equals(name))
                {
                        return (ObjectElement*)element;
                }
                element=element->next;
        }

        return (ObjectElement*)null;
}


////////////////////////////////////////////////////////////////////////////////////
//get a Element from the LinkedList
////////////////////////////////////////////////////////////////////////////////////

ObjectElement *ObjectLinkedList::getElement(int index)
{
        ObjectElement *element=first;

        for ( int s=0; s<index ; s++ )
        {
                element=element->next;
        }

        return (ObjectElement*)element->pointer;
}

////////////////////////////////////////////////////////////////////////////////////
//get a ObjectName from the LinkedList
////////////////////////////////////////////////////////////////////////////////////

char *ObjectLinkedList::getObjectName(int index)
{
        ObjectElement *element=first;

        for ( int s=0; s<index ; s++ )
        {
                element=element->next;
        }

        stringLength=element->name->length;

        return element->name->buffer;
}


////////////////////////////////////////////////////////////////////////////////////
//get a ObjectElement from the LinkedList
////////////////////////////////////////////////////////////////////////////////////

ObjectElement *ObjectLinkedList::getObjectElement(int index)
{
        ObjectElement *element=first;

        for ( int s=0; s<index ; s++ )
        {
                element=element->next;
        }

        return (ObjectElement*)element;
}

////////////////////////////////////////////////////////////////////////////////////
//set a Element in the LinkedList
////////////////////////////////////////////////////////////////////////////////////
/*
void ObjectLinkedList::setElement(ChunkNameElement *iChunkNameElement, int index)
{
    if ( index < howfar && index >= 0)
    {
                setElementMain((void*)iChunkNameElement, DefineChunkNameElement, index);
        }
}
*/
void ObjectLinkedList::setElement(ExtPropertiesElement *iExtPropertiesElement, int index)
{
    if ( index < howfar && index >= 0)
    {
                setElementMain((void*)iExtPropertiesElement, DefineExtPropertiesElement, index);
        }
}

void ObjectLinkedList::setElementMain(void *iObjectElement, int iTypeOfObject, int index)
{
        ObjectElement *element=first;

        for ( int s=0; s<index ; s++ )
        {
                element=element->next;
        }

        element->remove();
        element->pointer=(void *)iObjectElement;
        element->typeOfObject=iTypeOfObject;
}

/*
void ObjectLinkedList::setElement(ChunkNameElement *iChunkNameElement, char *iName, int index)
{
    if ( index < howfar && index >= 0)
    {
                setElementMainWithName((void*)iChunkNameElement, DefineChunkNameElement, iName, index);
        }
}
*/
void ObjectLinkedList::setElement(ExtPropertiesElement *iExtPropertiesElement, char *iName, int index)
{
    if ( index < howfar && index >= 0)
    {
                setElementMainWithName((void*)iExtPropertiesElement, DefineExtPropertiesElement, iName, index);
        }
}

void ObjectLinkedList::setElementMainWithName(void *iObjectElement, int iTypeOfObject, char *iName, int index)
{
        ObjectElement *element=first;

        for ( int s=0; s<index ; s++ )
        {
                element=element->next;
        }

        element->remove();
        element->pointer=(void *)iObjectElement;
        element->typeOfObject=iTypeOfObject;
        element->name->setString(iName);
}

////////////////////////////////////////////////////////////////////////////////////
//insert a new object here, used with sorting  
////////////////////////////////////////////////////////////////////////////////////

void ObjectLinkedList::setElement(ObjectElement *iObjectElement, int index)
{
        ObjectElement *element=first;

        for ( int s=0; s<index ; s++ )
        {
                element=element->next;
        }

        element->pointer=iObjectElement->pointer;
        element->typeOfObject=iObjectElement->typeOfObject;
        element->name->setString(iObjectElement->name->buffer);
}

////////////////////////////////////////////////////////////////////////////////////
//have to do with the quicksort
////////////////////////////////////////////////////////////////////////////////////

void ObjectLinkedList::setElementPivot(void *iObjectElement, int iTypeOfObject, char *iName, int index)
{
        ObjectElement *element=first;

        for ( int s=0; s<index ; s++ )
        {
                element=element->next;
        }

        element->pointer=(void *)iObjectElement;
        element->typeOfObject=iTypeOfObject;
        element->name->setString(iName);
}

////////////////////////////////////////////////////////////////////////////////////
//sort element in linkedlist
////////////////////////////////////////////////////////////////////////////////////

void ObjectLinkedList::sortLargestOrder()
{
        ObjectLinkedListQuickSort::setStatement(1);
        ObjectLinkedListQuickSort::sortLargestOrder(this,0,howfar-1);
}

void ObjectLinkedList::sortSmallestOrder()
{
        ObjectLinkedListQuickSort::setStatement(0);
        ObjectLinkedListQuickSort::sortSmallestOrder(this,0,howfar-1);
}


////////////////////////////////////////////////////////////////////////////////////
//remove a element from the linkedlist
////////////////////////////////////////////////////////////////////////////////////

bool ObjectLinkedList::removeElement(int index)
{
        if ( index < howfar && index >= 0)
        {
                int temphowfar=howfar;
                --howfar;
                ObjectElement *lista = first;

                for ( int w=0; w<index ; w++ )
                {
                        lista=lista->next;
                }

                if ( lista == first && temphowfar == 1 )
                {
                        delete first;
                        return true;
                }

                if ( lista == first && temphowfar != 1  )
                {
                        bool s=false;

                        if ( lista->next == last )
                        {
                                s=true;
                        }

                        ObjectElement *temp=first->next;
                        delete first;
                        first=temp;

                        if (s == true)
                        {
                                last=first;
                        }

                        return true;
                }

                if ( lista == last )
                {
                        ObjectElement *temp=last->previos;
                        delete last;
                        last=temp;
                        return true;
                }

                int t=0;

                if ( lista->next == last && lista->previos == first )
                {
                        t=1;
                }


                ObjectElement *tempnext=lista->previos;
                ObjectElement *tempprevios=lista->next;
                delete lista;
                tempnext->next=tempprevios;
                tempprevios->previos=tempnext;

                if ( t == 1 )
                {
                        first=tempnext;
                        last=tempprevios;
                }

                return true;
        }

        return false;
}
1	#include "ObjectLinkedList.h"
2	#include "../System/SystemDefine.h"
3	#include "../Element/DefineObjects.h"
4	#include "../String/Parse.h"
5	#include "../Sort/ObjectLinkedListQuickSort.h"
6	#include "../System/System.h"
7	#include "../String/StringTools.h"
8
9	ObjectLinkedList::ObjectLinkedList()
10	{
11	howfar=0;
12	}
13
14	////////////////////////////////////////////////////////////////////////////////////
15	//free memory for all Elements that exsist in the LinkedList
16	////////////////////////////////////////////////////////////////////////////////////
17
18	ObjectLinkedList::~ObjectLinkedList()
19	{
20	removeAllElement();
21	}
22
23	////////////////////////////////////////////////////////////////////////////////////
24	//free memory for all Elements that exsist in the LinkedList
25	////////////////////////////////////////////////////////////////////////////////////
26
27	void ObjectLinkedList::removeAllElement()
28	{
29	if ( howfar != 0 )
30	{
31	ObjectElement *element=first;
32
33	for ( int s=0; s<howfar ; s++ )
34	{
35	ObjectElement *tempElement=element->next;
36	delete element;
37	element=tempElement;
38	}
39	}
40
41	}
42
43	////////////////////////////////////////////////////////////////////////////////////
44	//How many Elements is it in the LinkedList
45	////////////////////////////////////////////////////////////////////////////////////
46
47	int ObjectLinkedList::size()
48	{
49	return howfar;
50	}
51
52	////////////////////////////////////////////////////////////////////////////////////
53	//add a Element to the LinkedList
54	////////////////////////////////////////////////////////////////////////////////////
55	/*
56	ObjectElement ObjectLinkedList::addLast(ChunkNameElement iChunkNameElement)
57	{
58	return addLastMain((void*)iChunkNameElement,DefineChunkNameElement);
59	}
60	*/
61	ObjectElement ObjectLinkedList::addLast(ExtPropertiesElement iExtPropertiesElement)
62	{
63	return addLastMain((ObjectElement*)iExtPropertiesElement,DefineExtPropertiesElement);
64	}
65
66	ObjectElement ObjectLinkedList::addLastMain(void iObjectElement, int iTypeOfObject)
67	{
68	if (howfar == 0)
69	{
70	first = new ObjectElement(iObjectElement,iTypeOfObject,Parse::intToString(howfar));
71	last=first;
72	}
73	else
74	{
75	last->next = new ObjectElement(iObjectElement,iTypeOfObject,Parse::intToString(howfar));
76	last->next->previos=last;
77	last=last->next;
78	}
79
80	howfar++;
81
82	return (ObjectElement*)last->pointer;
83	}
84
85	ObjectElement ObjectLinkedList::addLast(SGI sgi, char *iName)
86	{
87	return addLastMainWithName((void*)sgi,DefineSGI, iName);
88	}
89	/*
90	ObjectElement ObjectLinkedList::addLast(ChunkNameElement iChunkNameElement, char *iName)
91	{
92	return addLastMainWithName((void*)iChunkNameElement,DefineChunkNameElement, iName);
93	}
94	*/
95	ObjectElement ObjectLinkedList::addLast(ExtPropertiesElement iExtPropertiesElement, char *iName)
96	{
97	return addLastMainWithName((ObjectElement*)iExtPropertiesElement,DefineExtPropertiesElement, iName);
98	}
99
100	ObjectElement ObjectLinkedList::addLastMainWithName(void iObjectElement, int iTypeOfObject, char *iName)
101	{
102
103	if (iTypeOfObject==DefineSGI)
104	{
105	ObjectElement *objectElement=checkIfElementNameExist(iName);
106
107	if(objectElement!=null)
108	{
109	return objectElement;
110	}
111	}
112
113	if (howfar == 0)
114	{
115	first = new ObjectElement(iObjectElement,iTypeOfObject,iName);
116	last=first;
117	}
118	else
119	{
120	last->next = new ObjectElement(iObjectElement,iTypeOfObject,iName);
121	last->next->previos=last;
122	last=last->next;
123	}
124
125	howfar++;
126
127	return (ObjectElement*)last->pointer;
128	}
129
130
131	////////////////////////////////////////////////////////////////////////////////////
132	//check if a element with same name exist
133	////////////////////////////////////////////////////////////////////////////////////
134
135	ObjectElement ObjectLinkedList::checkIfElementNameExist(char name)
136	{
137	ObjectElement *element=first;
138
139	for ( int s=0; s<howfar ; s++ )
140	{
141	if (element->name->equals(name))
142	{
143	return (ObjectElement*)element;
144	}
145	element=element->next;
146	}
147
148	return (ObjectElement*)null;
149	}
150
151
152	////////////////////////////////////////////////////////////////////////////////////
153	//get a Element from the LinkedList
154	////////////////////////////////////////////////////////////////////////////////////
155
156	ObjectElement *ObjectLinkedList::getElement(int index)
157	{
158	ObjectElement *element=first;
159
160	for ( int s=0; s<index ; s++ )
161	{
162	element=element->next;
163	}
164
165	return (ObjectElement*)element->pointer;
166	}
167
168	////////////////////////////////////////////////////////////////////////////////////
169	//get a ObjectName from the LinkedList
170	////////////////////////////////////////////////////////////////////////////////////
171
172	char *ObjectLinkedList::getObjectName(int index)
173	{
174	ObjectElement *element=first;
175
176	for ( int s=0; s<index ; s++ )
177	{
178	element=element->next;
179	}
180
181	stringLength=element->name->length;
182
183	return element->name->buffer;
184	}
185
186
187	////////////////////////////////////////////////////////////////////////////////////
188	//get a ObjectElement from the LinkedList
189	////////////////////////////////////////////////////////////////////////////////////
190
191	ObjectElement *ObjectLinkedList::getObjectElement(int index)
192	{
193	ObjectElement *element=first;
194
195	for ( int s=0; s<index ; s++ )
196	{
197	element=element->next;
198	}
199
200	return (ObjectElement*)element;
201	}
202
203	////////////////////////////////////////////////////////////////////////////////////
204	//set a Element in the LinkedList
205	////////////////////////////////////////////////////////////////////////////////////
206	/*
207	void ObjectLinkedList::setElement(ChunkNameElement *iChunkNameElement, int index)
208	{
209	if ( index < howfar && index >= 0)
210	{
211	setElementMain((void*)iChunkNameElement, DefineChunkNameElement, index);
212	}
213	}
214	*/
215	void ObjectLinkedList::setElement(ExtPropertiesElement *iExtPropertiesElement, int index)
216	{
217	if ( index < howfar && index >= 0)
218	{
219	setElementMain((void*)iExtPropertiesElement, DefineExtPropertiesElement, index);
220	}
221	}
222
223	void ObjectLinkedList::setElementMain(void *iObjectElement, int iTypeOfObject, int index)
224	{
225	ObjectElement *element=first;
226
227	for ( int s=0; s<index ; s++ )
228	{
229	element=element->next;
230	}
231
232	element->remove();
233	element->pointer=(void *)iObjectElement;
234	element->typeOfObject=iTypeOfObject;
235	}
236
237	/*
238	void ObjectLinkedList::setElement(ChunkNameElement iChunkNameElement, char iName, int index)
239	{
240	if ( index < howfar && index >= 0)
241	{
242	setElementMainWithName((void*)iChunkNameElement, DefineChunkNameElement, iName, index);
243	}
244	}
245	*/
246	void ObjectLinkedList::setElement(ExtPropertiesElement iExtPropertiesElement, char iName, int index)
247	{
248	if ( index < howfar && index >= 0)
249	{
250	setElementMainWithName((void*)iExtPropertiesElement, DefineExtPropertiesElement, iName, index);
251	}
252	}
253
254	void ObjectLinkedList::setElementMainWithName(void iObjectElement, int iTypeOfObject, char iName, int index)
255	{
256	ObjectElement *element=first;
257
258	for ( int s=0; s<index ; s++ )
259	{
260	element=element->next;
261	}
262
263	element->remove();
264	element->pointer=(void *)iObjectElement;
265	element->typeOfObject=iTypeOfObject;
266	element->name->setString(iName);
267	}
268
269	////////////////////////////////////////////////////////////////////////////////////
270	//insert a new object here, used with sorting
271	////////////////////////////////////////////////////////////////////////////////////
272
273	void ObjectLinkedList::setElement(ObjectElement *iObjectElement, int index)
274	{
275	ObjectElement *element=first;
276
277	for ( int s=0; s<index ; s++ )
278	{
279	element=element->next;
280	}
281
282	element->pointer=iObjectElement->pointer;
283	element->typeOfObject=iObjectElement->typeOfObject;
284	element->name->setString(iObjectElement->name->buffer);
285	}
286
287	////////////////////////////////////////////////////////////////////////////////////
288	//have to do with the quicksort
289	////////////////////////////////////////////////////////////////////////////////////
290
291	void ObjectLinkedList::setElementPivot(void iObjectElement, int iTypeOfObject, char iName, int index)
292	{
293	ObjectElement *element=first;
294
295	for ( int s=0; s<index ; s++ )
296	{
297	element=element->next;
298	}
299
300	element->pointer=(void *)iObjectElement;
301	element->typeOfObject=iTypeOfObject;
302	element->name->setString(iName);
303	}
304
305	////////////////////////////////////////////////////////////////////////////////////
306	//sort element in linkedlist
307	////////////////////////////////////////////////////////////////////////////////////
308
309	void ObjectLinkedList::sortLargestOrder()
310	{
311	ObjectLinkedListQuickSort::setStatement(1);
312	ObjectLinkedListQuickSort::sortLargestOrder(this,0,howfar-1);
313	}
314
315	void ObjectLinkedList::sortSmallestOrder()
316	{
317	ObjectLinkedListQuickSort::setStatement(0);
318	ObjectLinkedListQuickSort::sortSmallestOrder(this,0,howfar-1);
319	}
320
321
322
323	////////////////////////////////////////////////////////////////////////////////////
324	//remove a element from the linkedlist
325	////////////////////////////////////////////////////////////////////////////////////
326
327	bool ObjectLinkedList::removeElement(int index)
328	{
329	if ( index < howfar && index >= 0)
330	{
331	int temphowfar=howfar;
332	--howfar;
333	ObjectElement *lista = first;
334
335	for ( int w=0; w<index ; w++ )
336	{
337	lista=lista->next;
338	}
339
340	if ( lista == first && temphowfar == 1 )
341	{
342	delete first;
343	return true;
344	}
345
346	if ( lista == first && temphowfar != 1 )
347	{
348	bool s=false;
349
350	if ( lista->next == last )
351	{
352	s=true;
353	}
354
355	ObjectElement *temp=first->next;
356	delete first;
357	first=temp;
358
359	if (s == true)
360	{
361	last=first;
362	}
363
364	return true;
365	}
366
367	if ( lista == last )
368	{
369	ObjectElement *temp=last->previos;
370	delete last;
371	last=temp;
372	return true;
373	}
374
375	int t=0;
376
377	if ( lista->next == last && lista->previos == first )
378	{
379	t=1;
380	}
381
382
383	ObjectElement *tempnext=lista->previos;
384	ObjectElement *tempprevios=lista->next;
385	delete lista;
386	tempnext->next=tempprevios;
387	tempprevios->previos=tempnext;
388
389	if ( t == 1 )
390	{
391	first=tempnext;
392	last=tempprevios;
393	}
394
395	return true;
396	}
397
398	return false;
399	}