Classes/LinkedList/ObjectLinkedList.h

#ifndef __ObjectLinkedList_H__
#define __ObjectLinkedList_H__

#include "../Element/ObjectElement.h"

template <class ClassName>

class ObjectLinkedList
{
  
public:

ObjectLinkedList()
{
        howfar=0;
        stringTools = new StringTools();
}

~ObjectLinkedList()
{
        if (stringTools!=null)
        {
                delete stringTools;
        }

        removeAllElement();     
}

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

void removeAllElement()
{
        if ( howfar != 0 )
        {
                ObjectElement<ClassName> *element=first;

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


ClassName *addLast(ClassName *iObjectElement)
{
        Parse parse;

        if (howfar == 0)
        {
          int length=0;
          char *iName=parse.intToString(howfar, &length); 
          first = new ObjectElement<ClassName>(iObjectElement,iName);
          free(iName);
          last=first;
        }
        else
        {
          int length=0;
          char *iName=parse.intToString(howfar, &length); 
          last->next = new ObjectElement<ClassName>(iObjectElement,iName);      
          free(iName);
      last->next->previos=last;
          last=last->next;
        }
        
        howfar++;

        return last->classNameElement;
}

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

int size()
{
        return howfar;
}

////////////////////////////////////////////////////////////////////////////////////
//add a element to a linkedlist, with a element name
////////////////////////////////////////////////////////////////////////////////////

ClassName *addLast(ClassName *iObjectElement, char *iName)
{
        if (howfar == 0)
        {
          first = new ObjectElement<ClassName>(iObjectElement,iName);
          last=first;
        }
        else
        {
          last->next = new ObjectElement<ClassName>(iObjectElement, iName);     
      last->next->previos=last;
          last=last->next;
        }
        
        howfar++;

        return last->classNameElement;
}

////////////////////////////////////////////////////////////////////////////////////
//add a element to a linkedlist, with a element name
////////////////////////////////////////////////////////////////////////////////////

ClassName *addLast(ClassName *iObjectElement, const String &iName)
{
        if (howfar == 0)
        {
          first = new ObjectElement<ClassName>(iObjectElement,iName);
          last=first;
        }
        else
        {
          last->next = new ObjectElement<ClassName>(iObjectElement, iName);     
      last->next->previos=last;
          last=last->next;
        }
        
        howfar++;

        return last->classNameElement;
}

////////////////////////////////////////////////////////////////////////////////////
//add a element to a linkedlist, with a element name, if the element name already exist 
//dont input this element take the element that already exist.
////////////////////////////////////////////////////////////////////////////////////

ClassName *addLastWithNoDoubleName(ClassName *iObjectElement, char *iName)
{
        ClassName *objectElement=checkIfElementNameExist(iName);

        if(objectElement!=null)
        {
                return objectElement;
        }
        
        if (howfar == 0)
        {
          first = new ObjectElement<ClassName>(iObjectElement,iName);
          last=first;
        }
        else
        {
          last->next = new ObjectElement<ClassName>(iObjectElement, iName);     
      last->next->previos=last;
          last=last->next;
        }
        
        howfar++;

        return last->classNameElement;
}

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

ClassName *checkIfElementNameExist(char *name)
{
        ObjectElement<ClassName> *element=first;

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

        return (ClassName*)null;
}


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

ClassName *getElement(int index)
{
        ObjectElement<ClassName> *element=first;

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

        return element->classNameElement;
}


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

char *getObjectName(int index)
{
        ObjectElement<ClassName> *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<ClassName> *getObjectElement(int index)
{
        ObjectElement<ClassName> *element=first;

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

        return (ObjectElement<ClassName>*)element;
}

////////////////////////////////////////////////////////////////////////////////////
//set a Element in the LinkedList
////////////////////////////////////////////////////////////////////////////////////

void setElement(ClassName *iObjectElement, int index)
{
    if ( index < howfar && index >= 0)
    {
                ObjectElement<ClassName> *element=first;

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

                element->remove();
                element->classNameElement=iObjectElement;
        }
}

void setElement(ClassName *iObjectElement, char *iName, int index)
{
    if ( index < howfar && index >= 0)
    {
                ObjectElement<ClassName> *element=first;

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

                element->remove();
                element->classNameElement=iObjectElement;
                element->name->setString(iName);
        }
}

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

void setElement(ObjectElement<ClassName> *iObjectElement, int index)
{
        ObjectElement<ClassName> *element=first;

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

        element->classNameElement=iObjectElement->classNameElement;
        element->name->setString(iObjectElement->name->buffer);
        element->sideNext=iObjectElement->sideNext;
        element->sidePrevios=iObjectElement->sidePrevios;
}

void setElementPivot(ClassName *iObjectElement, ObjectElement<ClassName> *iSidePrevios, ObjectElement<ClassName> *iSideNext, char *iName, int index)
{
        ObjectElement<ClassName> *element=first;

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

        element->classNameElement=iObjectElement;
        element->name->setString(iName);
        element->sidePrevios=iSidePrevios;
        element->sideNext=iSideNext;
}

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

bool removeElement(int index)
{
        if ( index < howfar && index >= 0)
        {
                int temphowfar=howfar;
                --howfar;
                ObjectElement<ClassName> *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<ClassName> *temp=first->next;
                        delete first;
                        first=temp;

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

                        return true;
                }

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

                int t=0;

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


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

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

                return true;
        }

        return false;
}

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

void sortLargestOrder()
{
        sortLargestOrder(this, 0, howfar-1, 1);
}

void sortSmallestOrder()
{
        sortSmallestOrder(this, 0, howfar-1, 0);
}

/////////////////////////////////////////////////////////////////
// string sorting
/////////////////////////////////////////////////////////////////

int partitionOrder(ObjectLinkedList<ClassName> *list, int start, int top, int statement)
{
    
        ObjectElement<ClassName> *tempPivot = list->getObjectElement(top);
        ClassName *pointer=tempPivot->classNameElement;
        String pivotString=tempPivot->name->buffer;
        ObjectElement<ClassName> *sidePrevios=tempPivot->sidePrevios;
        ObjectElement<ClassName> *sideNext=tempPivot->sideNext;
        char *pivotBuffer = pivotString.buffer;               // Partition around the last value
        int pivotLength = pivotString.length;
 
        int bottom = start-1;                           // Start outside the area to be partitioned
    bool done=true;

        while (done)                            // Until all elements are partitioned...
    {
                while (done)                        // Until we find an out of place element...
                {
                        bottom++;                       // ... move the bottom up.
            if (bottom == top)                  // If we hit the top...
            {
                                done = false;                       // ... we are done.
                break;
                        }
                        
                        if (statement==0)
                        {
                                ObjectElement<ClassName> *objectElement=list->getObjectElement(bottom);
                                char *stringBuffer=objectElement->name->buffer;
                                int stringLength=objectElement->name->length;

                                if (stringTools->isStringSmaller(stringBuffer,stringLength,pivotBuffer,pivotLength))
                                {       
                                        list->setElement(objectElement,top);      // Then put at the top... 6=7
                                break;
                                }                               // ... and start searching from the top.
                        }
                        else
                        {
                                ObjectElement<ClassName> *objectElement=list->getObjectElement(bottom);
                                char *stringBuffer=objectElement->name->buffer;
                                int stringLength=objectElement->name->length;

                                if (stringTools->isStringLarger(stringBuffer,stringLength,pivotBuffer,pivotLength))
                                {                                                                       // Is the bottom out of place?
                                        list->setElement(objectElement,top);      // Then put at the top... 6=7
                        break;
                                }                               // ... and start searching from the top.
                        }
                }

                while (done)                        // Until we find an out of place element...
        {
                        --top;                        // ... move the top down.
            
            if (top == bottom)                  // If we hit the bottom...
            {
                                done = false;                       // ... we are done.
                break;
                        }

                        if (statement==0)
                        {
                                ObjectElement<ClassName> *objectElement=list->getObjectElement(top);
                                char *stringBuffer=objectElement->name->buffer;
                                int stringLength=objectElement->name->length;

                                if (stringTools->isStringLarger(stringBuffer,stringLength,pivotBuffer,pivotLength))
                                {
                                        list->setElement(objectElement,bottom);    // Then put it at the bottom...
                                    break;                                                      
                                }                                       // ...and start searching from the bottom.
                        }
                        else
                        {
                                ObjectElement<ClassName> *objectElement=list->getObjectElement(top);
                                char *stringBuffer=objectElement->name->buffer;
                                int stringLength=objectElement->name->length;

                                if (stringTools->isStringSmaller(stringBuffer,stringLength,pivotBuffer,pivotLength))
                                {
                                        list->setElement(objectElement,bottom);       // Then put it at the bottom...
                                    break;                                                      
                                }                                       // ...and start searching from the bottom.
                        }
                }
        }

        list->setElementPivot(pointer, sidePrevios, sideNext, pivotString.buffer, top); 
    return top;                                 // Return the split point
}

void sortLargestOrder(ObjectLinkedList<ClassName> *list, int start, int end, int statement)
{
        if ( start < end )
        {                                                                                       // If there are two or more elements...
        int split = partitionOrder(list, start, end, statement);    //... partition the sublist...
        sortLargestOrder(list, start, split-1, statement);        // ... and sort both halves.
        sortLargestOrder(list, split+1, end, statement);     
        }
}

void sortSmallestOrder(ObjectLinkedList<ClassName> *list, int start, int end, int statement)
{
        if ( start < end )
        {                                                                                       // If there are two or more elements...
        int split = partitionOrder(list, start, end, statement);    //... partition the sublist...
        sortSmallestOrder(list, start, split-1, statement);        // ... and sort both halves.
        sortSmallestOrder(list, split+1, end, statement);     

        }
}


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

void sortLargestValueOrder()
{
        sortLargestValueOrder(this, 0, howfar-1, 1);
}

void sortSmallestValueOrder()
{
        sortSmallestValueOrder(this, 0, howfar-1, 0);
}

/////////////////////////////////////////////////////////////////
// string sorting
/////////////////////////////////////////////////////////////////

int partitionValueOrder(ObjectLinkedList<ClassName> *list, int start, int top, int statement)
{
    
        ObjectElement<ClassName> *tempPivot = list->getObjectElement(top);
        ClassName *pointer=tempPivot->classNameElement;
        String pivotString=tempPivot->name->buffer;
        ObjectElement<ClassName> *sidePrevios=tempPivot->sidePrevios;
        ObjectElement<ClassName> *sideNext=tempPivot->sideNext;
        char *pivotBuffer = pivotString.buffer;               // Partition around the last value
        int pivotLength = pivotString.length;
 
        int bottom = start-1;                           // Start outside the area to be partitioned
    bool done=true;

        while (done)                            // Until all elements are partitioned...
    {
                while (done)                        // Until we find an out of place element...
                {
                        bottom++;                       // ... move the bottom up.
            if (bottom == top)                  // If we hit the top...
            {
                                done = false;                       // ... we are done.
                break;
                        }
                        
                        if (statement==0)
                        {
                                ObjectElement<ClassName> *objectElement=list->getObjectElement(bottom);
                                char *stringBuffer=objectElement->name->buffer;
                                int stringLength=objectElement->name->length;

                                if (stringTools->isStringValueSmaller(stringBuffer,stringLength,pivotBuffer,pivotLength))
                                {       
                                        list->setElement(objectElement,top);      // Then put at the top... 6=7
                                break;
                                }                               // ... and start searching from the top.
                        }
                        else
                        {
                                ObjectElement<ClassName> *objectElement=list->getObjectElement(bottom);
                                char *stringBuffer=objectElement->name->buffer;
                                int stringLength=objectElement->name->length;

                                if (stringTools->isStringValueLarger(stringBuffer,stringLength,pivotBuffer,pivotLength))
                                {                                                                       // Is the bottom out of place?
                                        list->setElement(objectElement,top);      // Then put at the top... 6=7
                        break;
                                }                               // ... and start searching from the top.
                        }
                }

                while (done)                        // Until we find an out of place element...
        {
                        --top;                        // ... move the top down.
            
            if (top == bottom)                  // If we hit the bottom...
            {
                                done = false;                       // ... we are done.
                break;
                        }

                        if (statement==0)
                        {
                                ObjectElement<ClassName> *objectElement=list->getObjectElement(top);
                                char *stringBuffer=objectElement->name->buffer;
                                int stringLength=objectElement->name->length;

                                if (stringTools->isStringValueLarger(stringBuffer,stringLength,pivotBuffer,pivotLength))
                                {
                                        list->setElement(objectElement,bottom);    // Then put it at the bottom...
                                    break;                                                      
                                }                                       // ...and start searching from the bottom.
                        }
                        else
                        {
                                ObjectElement<ClassName> *objectElement=list->getObjectElement(top);
                                char *stringBuffer=objectElement->name->buffer;
                                int stringLength=objectElement->name->length;

                                if (stringTools->isStringValueSmaller(stringBuffer,stringLength,pivotBuffer,pivotLength))
                                {
                                        list->setElement(objectElement,bottom);       // Then put it at the bottom...
                                    break;                                                      
                                }                                       // ...and start searching from the bottom.
                        }
                }
        }

        list->setElementPivot(pointer, sidePrevios, sideNext, pivotString.buffer, top); 
    return top;                                 // Return the split point
}

void sortLargestValueOrder(ObjectLinkedList<ClassName> *list, int start, int end, int statement)
{
        if ( start < end )
        {                                                                                       // If there are two or more elements...
        int split = partitionValueOrder(list, start, end, statement);    //... partition the sublist...
        sortLargestValueOrder(list, start, split-1, statement);        // ... and sort both halves.
        sortLargestValueOrder(list, split+1, end, statement);     
        }
}

void sortSmallestValueOrder(ObjectLinkedList<ClassName> *list, int start, int end, int statement)
{
        if ( start < end )
        {                                                                                       // If there are two or more elements...
        int split = partitionValueOrder(list, start, end, statement);    //... partition the sublist...
        sortSmallestValueOrder(list, start, split-1, statement);        // ... and sort both halves.
        sortSmallestValueOrder(list, split+1, end, statement);     
        }
}


ObjectElement<ClassName> *first;
ObjectElement<ClassName> *last;

int stringLength;

private:
int howfar;
StringTools *stringTools;
};

#endif
1	#ifndef __ObjectLinkedList_H__
2	#define __ObjectLinkedList_H__
3
4	#include "../Element/ObjectElement.h"
5
6	template <class ClassName>
7
8	class ObjectLinkedList
9	{
10
11	public:
12
13	ObjectLinkedList()
14	{
15	howfar=0;
16	stringTools = new StringTools();
17	}
18
19	~ObjectLinkedList()
20	{
21	if (stringTools!=null)
22	{
23	delete stringTools;
24	}
25
26	removeAllElement();
27	}
28
29	////////////////////////////////////////////////////////////////////////////////////
30	//free memory for all Elements that exsist in the LinkedList
31	////////////////////////////////////////////////////////////////////////////////////
32
33	void removeAllElement()
34	{
35	if ( howfar != 0 )
36	{
37	ObjectElement<ClassName> *element=first;
38
39	for ( int s=0; s<howfar ; s++ )
40	{
41	ObjectElement<ClassName> *tempElement=element->next;
42	delete element;
43	element=tempElement;
44	}
45	}
46	}
47
48
49	ClassName addLast(ClassName iObjectElement)
50	{
51	Parse parse;
52
53	if (howfar == 0)
54	{
55	int length=0;
56	char *iName=parse.intToString(howfar, &length);
57	first = new ObjectElement<ClassName>(iObjectElement,iName);
58	free(iName);
59	last=first;
60	}
61	else
62	{
63	int length=0;
64	char *iName=parse.intToString(howfar, &length);
65	last->next = new ObjectElement<ClassName>(iObjectElement,iName);
66	free(iName);
67	last->next->previos=last;
68	last=last->next;
69	}
70
71	howfar++;
72
73	return last->classNameElement;
74	}
75
76	////////////////////////////////////////////////////////////////////////////////////
77	//How many Elements is it in the LinkedList
78	////////////////////////////////////////////////////////////////////////////////////
79
80	int size()
81	{
82	return howfar;
83	}
84
85	////////////////////////////////////////////////////////////////////////////////////
86	//add a element to a linkedlist, with a element name
87	////////////////////////////////////////////////////////////////////////////////////
88
89	ClassName addLast(ClassName iObjectElement, char *iName)
90	{
91	if (howfar == 0)
92	{
93	first = new ObjectElement<ClassName>(iObjectElement,iName);
94	last=first;
95	}
96	else
97	{
98	last->next = new ObjectElement<ClassName>(iObjectElement, iName);
99	last->next->previos=last;
100	last=last->next;
101	}
102
103	howfar++;
104
105	return last->classNameElement;
106	}
107
108	////////////////////////////////////////////////////////////////////////////////////
109	//add a element to a linkedlist, with a element name
110	////////////////////////////////////////////////////////////////////////////////////
111
112	ClassName addLast(ClassName iObjectElement, const String &iName)
113	{
114	if (howfar == 0)
115	{
116	first = new ObjectElement<ClassName>(iObjectElement,iName);
117	last=first;
118	}
119	else
120	{
121	last->next = new ObjectElement<ClassName>(iObjectElement, iName);
122	last->next->previos=last;
123	last=last->next;
124	}
125
126	howfar++;
127
128	return last->classNameElement;
129	}
130
131	////////////////////////////////////////////////////////////////////////////////////
132	//add a element to a linkedlist, with a element name, if the element name already exist
133	//dont input this element take the element that already exist.
134	////////////////////////////////////////////////////////////////////////////////////
135
136	ClassName addLastWithNoDoubleName(ClassName iObjectElement, char *iName)
137	{
138	ClassName *objectElement=checkIfElementNameExist(iName);
139
140	if(objectElement!=null)
141	{
142	return objectElement;
143	}
144
145	if (howfar == 0)
146	{
147	first = new ObjectElement<ClassName>(iObjectElement,iName);
148	last=first;
149	}
150	else
151	{
152	last->next = new ObjectElement<ClassName>(iObjectElement, iName);
153	last->next->previos=last;
154	last=last->next;
155	}
156
157	howfar++;
158
159	return last->classNameElement;
160	}
161
162	////////////////////////////////////////////////////////////////////////////////////
163	//check if a element with same name exist
164	////////////////////////////////////////////////////////////////////////////////////
165
166	ClassName checkIfElementNameExist(char name)
167	{
168	ObjectElement<ClassName> *element=first;
169
170	for ( int s=0; s<howfar ; s++ )
171	{
172	if (element->name->equals(name))
173	{
174	return (ClassName*)element;
175	}
176	element=element->next;
177	}
178
179	return (ClassName*)null;
180	}
181
182
183	////////////////////////////////////////////////////////////////////////////////////
184	//get a Element from the LinkedList
185	////////////////////////////////////////////////////////////////////////////////////
186
187	ClassName *getElement(int index)
188	{
189	ObjectElement<ClassName> *element=first;
190
191	for ( int s=0; s<index ; s++ )
192	{
193	element=element->next;
194	}
195
196	return element->classNameElement;
197	}
198
199
200	////////////////////////////////////////////////////////////////////////////////////
201	//get a ObjectName from the LinkedList
202	////////////////////////////////////////////////////////////////////////////////////
203
204	char *getObjectName(int index)
205	{
206	ObjectElement<ClassName> *element=first;
207
208	for ( int s=0; s<index ; s++ )
209	{
210	element=element->next;
211	}
212
213	stringLength=element->name->length;
214
215	return element->name->buffer;
216	}
217
218
219	////////////////////////////////////////////////////////////////////////////////////
220	//get a ObjectElement from the LinkedList
221	////////////////////////////////////////////////////////////////////////////////////
222
223	ObjectElement<ClassName> *getObjectElement(int index)
224	{
225	ObjectElement<ClassName> *element=first;
226
227	for ( int s=0; s<index ; s++ )
228	{
229	element=element->next;
230	}
231
232	return (ObjectElement<ClassName>*)element;
233	}
234
235	////////////////////////////////////////////////////////////////////////////////////
236	//set a Element in the LinkedList
237	////////////////////////////////////////////////////////////////////////////////////
238
239	void setElement(ClassName *iObjectElement, int index)
240	{
241	if ( index < howfar && index >= 0)
242	{
243	ObjectElement<ClassName> *element=first;
244
245	for ( int s=0; s<index ; s++ )
246	{
247	element=element->next;
248	}
249
250	element->remove();
251	element->classNameElement=iObjectElement;
252	}
253	}
254
255	void setElement(ClassName iObjectElement, char iName, int index)
256	{
257	if ( index < howfar && index >= 0)
258	{
259	ObjectElement<ClassName> *element=first;
260
261	for ( int s=0; s<index ; s++ )
262	{
263	element=element->next;
264	}
265
266	element->remove();
267	element->classNameElement=iObjectElement;
268	element->name->setString(iName);
269	}
270	}
271
272	////////////////////////////////////////////////////////////////////////////////////
273	//insert a new object here, used with sorting
274	////////////////////////////////////////////////////////////////////////////////////
275
276	void setElement(ObjectElement<ClassName> *iObjectElement, int index)
277	{
278	ObjectElement<ClassName> *element=first;
279
280	for ( int s=0; s<index ; s++ )
281	{
282	element=element->next;
283	}
284
285	element->classNameElement=iObjectElement->classNameElement;
286	element->name->setString(iObjectElement->name->buffer);
287	element->sideNext=iObjectElement->sideNext;
288	element->sidePrevios=iObjectElement->sidePrevios;
289	}
290
291	void setElementPivot(ClassName iObjectElement, ObjectElement<ClassName> iSidePrevios, ObjectElement<ClassName> iSideNext, char iName, int index)
292	{
293	ObjectElement<ClassName> *element=first;
294
295	for ( int s=0; s<index ; s++ )
296	{
297	element=element->next;
298	}
299
300	element->classNameElement=iObjectElement;
301	element->name->setString(iName);
302	element->sidePrevios=iSidePrevios;
303	element->sideNext=iSideNext;
304	}
305
306	////////////////////////////////////////////////////////////////////////////////////
307	//remove a element from the linkedlist
308	////////////////////////////////////////////////////////////////////////////////////
309
310	bool removeElement(int index)
311	{
312	if ( index < howfar && index >= 0)
313	{
314	int temphowfar=howfar;
315	--howfar;
316	ObjectElement<ClassName> *lista = first;
317
318	for ( int w=0; w<index ; w++ )
319	{
320	lista=lista->next;
321	}
322
323	if ( lista == first && temphowfar == 1 )
324	{
325	delete first;
326	return true;
327	}
328
329	if ( lista == first && temphowfar != 1 )
330	{
331	bool s=false;
332
333	if ( lista->next == last )
334	{
335	s=true;
336	}
337
338	ObjectElement<ClassName> *temp=first->next;
339	delete first;
340	first=temp;
341
342	if (s == true)
343	{
344	last=first;
345	}
346
347	return true;
348	}
349
350	if ( lista == last )
351	{
352	ObjectElement<ClassName> *temp=last->previos;
353	delete last;
354	last=temp;
355	return true;
356	}
357
358	int t=0;
359
360	if ( lista->next == last && lista->previos == first )
361	{
362	t=1;
363	}
364
365
366	ObjectElement<ClassName> *tempnext=lista->previos;
367	ObjectElement<ClassName> *tempprevios=lista->next;
368	delete lista;
369	tempnext->next=tempprevios;
370	tempprevios->previos=tempnext;
371
372	if ( t == 1 )
373	{
374	first=tempnext;
375	last=tempprevios;
376	}
377
378	return true;
379	}
380
381	return false;
382	}
383
384	////////////////////////////////////////////////////////////////////////////////////
385	//sort element in the linkedlist
386	////////////////////////////////////////////////////////////////////////////////////
387
388	void sortLargestOrder()
389	{
390	sortLargestOrder(this, 0, howfar-1, 1);
391	}
392
393	void sortSmallestOrder()
394	{
395	sortSmallestOrder(this, 0, howfar-1, 0);
396	}
397
398	/////////////////////////////////////////////////////////////////
399	// string sorting
400	/////////////////////////////////////////////////////////////////
401
402	int partitionOrder(ObjectLinkedList<ClassName> *list, int start, int top, int statement)
403	{
404
405	ObjectElement<ClassName> *tempPivot = list->getObjectElement(top);
406	ClassName *pointer=tempPivot->classNameElement;
407	String pivotString=tempPivot->name->buffer;
408	ObjectElement<ClassName> *sidePrevios=tempPivot->sidePrevios;
409	ObjectElement<ClassName> *sideNext=tempPivot->sideNext;
410	char *pivotBuffer = pivotString.buffer; // Partition around the last value
411	int pivotLength = pivotString.length;
412
413	int bottom = start-1; // Start outside the area to be partitioned
414	bool done=true;
415
416	while (done) // Until all elements are partitioned...
417	{
418	while (done) // Until we find an out of place element...
419	{
420	bottom++; // ... move the bottom up.
421	if (bottom == top) // If we hit the top...
422	{
423	done = false; // ... we are done.
424	break;
425	}
426
427	if (statement==0)
428	{
429	ObjectElement<ClassName> *objectElement=list->getObjectElement(bottom);
430	char *stringBuffer=objectElement->name->buffer;
431	int stringLength=objectElement->name->length;
432
433	if (stringTools->isStringSmaller(stringBuffer,stringLength,pivotBuffer,pivotLength))
434	{
435	list->setElement(objectElement,top); // Then put at the top... 6=7
436	break;
437	} // ... and start searching from the top.
438	}
439	else
440	{
441	ObjectElement<ClassName> *objectElement=list->getObjectElement(bottom);
442	char *stringBuffer=objectElement->name->buffer;
443	int stringLength=objectElement->name->length;
444
445	if (stringTools->isStringLarger(stringBuffer,stringLength,pivotBuffer,pivotLength))
446	{ // Is the bottom out of place?
447	list->setElement(objectElement,top); // Then put at the top... 6=7
448	break;
449	} // ... and start searching from the top.
450	}
451	}
452
453	while (done) // Until we find an out of place element...
454	{
455	--top; // ... move the top down.
456
457	if (top == bottom) // If we hit the bottom...
458	{
459	done = false; // ... we are done.
460	break;
461	}
462
463	if (statement==0)
464	{
465	ObjectElement<ClassName> *objectElement=list->getObjectElement(top);
466	char *stringBuffer=objectElement->name->buffer;
467	int stringLength=objectElement->name->length;
468
469	if (stringTools->isStringLarger(stringBuffer,stringLength,pivotBuffer,pivotLength))
470	{
471	list->setElement(objectElement,bottom); // Then put it at the bottom...
472	break;
473	} // ...and start searching from the bottom.
474	}
475	else
476	{
477	ObjectElement<ClassName> *objectElement=list->getObjectElement(top);
478	char *stringBuffer=objectElement->name->buffer;
479	int stringLength=objectElement->name->length;
480
481	if (stringTools->isStringSmaller(stringBuffer,stringLength,pivotBuffer,pivotLength))
482	{
483	list->setElement(objectElement,bottom); // Then put it at the bottom...
484	break;
485	} // ...and start searching from the bottom.
486	}
487	}
488	}
489
490	list->setElementPivot(pointer, sidePrevios, sideNext, pivotString.buffer, top);
491	return top; // Return the split point
492	}
493
494	void sortLargestOrder(ObjectLinkedList<ClassName> *list, int start, int end, int statement)
495	{
496	if ( start < end )
497	{ // If there are two or more elements...
498	int split = partitionOrder(list, start, end, statement); //... partition the sublist...
499	sortLargestOrder(list, start, split-1, statement); // ... and sort both halves.
500	sortLargestOrder(list, split+1, end, statement);
501	}
502	}
503
504	void sortSmallestOrder(ObjectLinkedList<ClassName> *list, int start, int end, int statement)
505	{
506	if ( start < end )
507	{ // If there are two or more elements...
508	int split = partitionOrder(list, start, end, statement); //... partition the sublist...
509	sortSmallestOrder(list, start, split-1, statement); // ... and sort both halves.
510	sortSmallestOrder(list, split+1, end, statement);
511
512	}
513	}
514
515
516	////////////////////////////////////////////////////////////////////////////////////
517	//sort element in the linkedlist
518	////////////////////////////////////////////////////////////////////////////////////
519
520	void sortLargestValueOrder()
521	{
522	sortLargestValueOrder(this, 0, howfar-1, 1);
523	}
524
525	void sortSmallestValueOrder()
526	{
527	sortSmallestValueOrder(this, 0, howfar-1, 0);
528	}
529
530	/////////////////////////////////////////////////////////////////
531	// string sorting
532	/////////////////////////////////////////////////////////////////
533
534	int partitionValueOrder(ObjectLinkedList<ClassName> *list, int start, int top, int statement)
535	{
536
537	ObjectElement<ClassName> *tempPivot = list->getObjectElement(top);
538	ClassName *pointer=tempPivot->classNameElement;
539	String pivotString=tempPivot->name->buffer;
540	ObjectElement<ClassName> *sidePrevios=tempPivot->sidePrevios;
541	ObjectElement<ClassName> *sideNext=tempPivot->sideNext;
542	char *pivotBuffer = pivotString.buffer; // Partition around the last value
543	int pivotLength = pivotString.length;
544
545	int bottom = start-1; // Start outside the area to be partitioned
546	bool done=true;
547
548	while (done) // Until all elements are partitioned...
549	{
550	while (done) // Until we find an out of place element...
551	{
552	bottom++; // ... move the bottom up.
553	if (bottom == top) // If we hit the top...
554	{
555	done = false; // ... we are done.
556	break;
557	}
558
559	if (statement==0)
560	{
561	ObjectElement<ClassName> *objectElement=list->getObjectElement(bottom);
562	char *stringBuffer=objectElement->name->buffer;
563	int stringLength=objectElement->name->length;
564
565	if (stringTools->isStringValueSmaller(stringBuffer,stringLength,pivotBuffer,pivotLength))
566	{
567	list->setElement(objectElement,top); // Then put at the top... 6=7
568	break;
569	} // ... and start searching from the top.
570	}
571	else
572	{
573	ObjectElement<ClassName> *objectElement=list->getObjectElement(bottom);
574	char *stringBuffer=objectElement->name->buffer;
575	int stringLength=objectElement->name->length;
576
577	if (stringTools->isStringValueLarger(stringBuffer,stringLength,pivotBuffer,pivotLength))
578	{ // Is the bottom out of place?
579	list->setElement(objectElement,top); // Then put at the top... 6=7
580	break;
581	} // ... and start searching from the top.
582	}
583	}
584
585	while (done) // Until we find an out of place element...
586	{
587	--top; // ... move the top down.
588
589	if (top == bottom) // If we hit the bottom...
590	{
591	done = false; // ... we are done.
592	break;
593	}
594
595	if (statement==0)
596	{
597	ObjectElement<ClassName> *objectElement=list->getObjectElement(top);
598	char *stringBuffer=objectElement->name->buffer;
599	int stringLength=objectElement->name->length;
600
601	if (stringTools->isStringValueLarger(stringBuffer,stringLength,pivotBuffer,pivotLength))
602	{
603	list->setElement(objectElement,bottom); // Then put it at the bottom...
604	break;
605	} // ...and start searching from the bottom.
606	}
607	else
608	{
609	ObjectElement<ClassName> *objectElement=list->getObjectElement(top);
610	char *stringBuffer=objectElement->name->buffer;
611	int stringLength=objectElement->name->length;
612
613	if (stringTools->isStringValueSmaller(stringBuffer,stringLength,pivotBuffer,pivotLength))
614	{
615	list->setElement(objectElement,bottom); // Then put it at the bottom...
616	break;
617	} // ...and start searching from the bottom.
618	}
619	}
620	}
621
622	list->setElementPivot(pointer, sidePrevios, sideNext, pivotString.buffer, top);
623	return top; // Return the split point
624	}
625
626	void sortLargestValueOrder(ObjectLinkedList<ClassName> *list, int start, int end, int statement)
627	{
628	if ( start < end )
629	{ // If there are two or more elements...
630	int split = partitionValueOrder(list, start, end, statement); //... partition the sublist...
631	sortLargestValueOrder(list, start, split-1, statement); // ... and sort both halves.
632	sortLargestValueOrder(list, split+1, end, statement);
633	}
634	}
635
636	void sortSmallestValueOrder(ObjectLinkedList<ClassName> *list, int start, int end, int statement)
637	{
638	if ( start < end )
639	{ // If there are two or more elements...
640	int split = partitionValueOrder(list, start, end, statement); //... partition the sublist...
641	sortSmallestValueOrder(list, start, split-1, statement); // ... and sort both halves.
642	sortSmallestValueOrder(list, split+1, end, statement);
643	}
644	}
645
646
647	ObjectElement<ClassName> *first;
648	ObjectElement<ClassName> *last;
649
650	int stringLength;
651
652	private:
653	int howfar;
654	StringTools *stringTools;
655	};
656
657	#endif