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	bearsoft	1.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			}