Classes/Array/ObjectArray.h

#ifndef __ObjectArray_H__
#define __ObjectArray_H__

#include "../Element/ObjectElement.h"
#include "../System/SystemDefine.h"
#include "../String/Parse.h"
#include "../String/StringTools.h"
//#include "../Sort/ObjectArrayQuickSort.h"

template <class ClassName>

class ObjectArray 
{
  
public:

ObjectArray()
{
        buffer=null;
        size=0;
        stringTools = new StringTools();
}

ObjectArray(int iSize)
{
        stringTools = new StringTools();

        if (iSize > 0 )
        {
                buffer=(ObjectElement<ClassName>**)malloc(sizeof(ObjectElement<ClassName>*)*iSize);
                size=iSize;
                
                for ( int i=0; i<size ; i++ )
                {
                        buffer[i]=null;
                }
        }
}

~ObjectArray()
{
        for ( int r=0 ; r<size ; r++ )
        {
                ObjectElement<ClassName> *objectElement=buffer[r];
                if (objectElement != null)
                {
                        delete objectElement;
                }
        }

        free(buffer);

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

void resetArray()
{
        for ( int i=0; i<size ; i++ )
        {
                ObjectElement<ClassName> *objectElement=buffer[i];

                if (objectElement!=null)
                {
                        objectElement->classNameElement=null;
                }
        }
}

void setObject(ClassName *object, int index)
{
        Parse parse;
        
        if (index >= 0 && index < size )
        {
                ObjectElement<ClassName> *objectElement=buffer[index];
                
                if ( objectElement != null )
                {
                        objectElement->remove();
                        objectElement->classNameElement=object;
                        int length=0;
                        char *name=parse.intToString(index,&length);
                        objectElement->name=new String(name);
                        free(name);
                }
                else
                {
                        int length=0;
                        char *name=parse.intToString(index, &length);
                        buffer[index]=new ObjectElement<ClassName>(object, name);
                        free(name);
                }
        }
}

void setObject(ClassName *object, char *iName, int index)
{
        if (index >= 0 && index < size )
        {
                ObjectElement<ClassName> *objectElement=buffer[index];
                
                if ( objectElement != null )
                {
                        objectElement->remove();
                        objectElement->classNameElement=object;
                        objectElement->name=new String(iName);
                }
                else
                {
                        buffer[index]=new ObjectElement<ClassName>(object, iName);
                }
        }
}

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

void setElement(ObjectElement<ClassName> *iObjectElement, int index)
{
        if (index >= 0 && index < size )
        {
                ObjectElement<ClassName> *objectElement=buffer[index];
                objectElement->classNameElement=iObjectElement->classNameElement;
                objectElement->name->setString(iObjectElement->name->buffer);
        }
}

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

void setElementPivot(ClassName *object, char *iName, int index)
{
        if (index >= 0 && index < size )
        {
                ObjectElement<ClassName> *objectElement=buffer[index];
                objectElement->classNameElement=object;
                objectElement->name->setString(iName);
        }
}

char *getObjectName(int index)
{
        if (index >= 0 && index < size )
        {
                ObjectElement<ClassName> *objectElement=buffer[index];
                stringLength=objectElement->name->length;
                return objectElement->name->buffer;
        }
        return null;
}

ClassName *getObject(int index)
{
        if (index >= 0 && index < size )
        {
                ObjectElement<ClassName> *objectElement=buffer[index];
                
                if (objectElement!=null)
                {
                        return objectElement->classNameElement;
                }
        }

        return null;
}

ObjectElement<ClassName> *getObjectElement(int index)
{
        if (index >= 0 && index < size )
        {
                ObjectElement<ClassName> *objectElement=buffer[index];
                
                return objectElement;
        }

        return null;
}

void addLast(ClassName *object)
{
        Parse parse;

        if (buffer==null)
        {
                buffer=(ObjectElement<ClassName>**)malloc(sizeof(ObjectElement<ClassName>*)*1);
                buffer[0]=new ObjectElement<ClassName>(object, "0");
                size=1;
        }
        else
        {
                int length=0;
                char *name=parse.intToString(size+1, &length);
                ObjectElement<ClassName> **tempBuffer=addObjectToArray(buffer,size,new ObjectElement<ClassName>(object, name));         
                free(name);
                free(buffer);
                buffer=tempBuffer;
                size++;
        }
}

void addLast(ClassName *object, char *iName)
{
        if (buffer==0)
        {
                buffer=(ObjectElement<ClassName>**)malloc(sizeof(ObjectElement<ClassName>*)*1);
                buffer[0]=(int)new ObjectElement<ClassName>(object, iName);
                size=1;
        }
        else
        {
                ObjectElement<ClassName> **tempBuffer=addObjectToArray(buffer,size,new ObjectElement<ClassName>(object, iName));                
                free(buffer);
                buffer=tempBuffer;
                size++;
        }
}

//////////////////////////////////////////////////////////////////////////////////////
//add object together
//////////////////////////////////////////////////////////////////////////////////////

ObjectElement<ClassName> **addObjectToArray(ObjectElement<ClassName> **source, int sourceSize, ObjectElement<ClassName> *objectPointer)
{
        int forward=0;

        ObjectElement<ClassName> **buffer=(ObjectElement<ClassName>**)malloc(sourceSize*sizeof(ObjectElement<ClassName>*)+sizeof(ObjectElement<ClassName>*));

        for ( int s=0 ; s<sourceSize ; s++ )
        {
                buffer[forward]=source[s];
                forward++;
        }

        buffer[forward]=objectPointer;

        return buffer;
}

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

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

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


int partitionOrder(ObjectArray<ClassName> *list, int start, int top, int statement)
{
    
        ObjectElement<ClassName> *tempPivot = list->getObjectElement(top);
        ClassName *pointer=tempPivot->classNameElement;
        String pivotString=tempPivot->name->buffer; 
        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,pivotString.buffer, top); 
    return top;                                 // Return the split point
}

void sortLargestOrder(ObjectArray<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(ObjectArray<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);     

        }
}

ObjectElement<ClassName> **buffer;
int size;
int stringLength;
StringTools *stringTools;

};

#endif
1	#ifndef __ObjectArray_H__
2	#define __ObjectArray_H__
3
4	#include "../Element/ObjectElement.h"
5	#include "../System/SystemDefine.h"
6	#include "../String/Parse.h"
7	#include "../String/StringTools.h"
8	//#include "../Sort/ObjectArrayQuickSort.h"
9
10	template <class ClassName>
11
12	class ObjectArray
13	{
14
15	public:
16
17	ObjectArray()
18	{
19	buffer=null;
20	size=0;
21	stringTools = new StringTools();
22	}
23
24	ObjectArray(int iSize)
25	{
26	stringTools = new StringTools();
27
28	if (iSize > 0 )
29	{
30	buffer=(ObjectElement<ClassName>*)malloc(sizeof(ObjectElement<ClassName>)*iSize);
31	size=iSize;
32
33	for ( int i=0; i<size ; i++ )
34	{
35	buffer[i]=null;
36	}
37	}
38	}
39
40	~ObjectArray()
41	{
42	for ( int r=0 ; r<size ; r++ )
43	{
44	ObjectElement<ClassName> *objectElement=buffer[r];
45	if (objectElement != null)
46	{
47	delete objectElement;
48	}
49	}
50
51	free(buffer);
52
53	if (stringTools!=null)
54	{
55	delete stringTools;
56	}
57	}
58
59	void resetArray()
60	{
61	for ( int i=0; i<size ; i++ )
62	{
63	ObjectElement<ClassName> *objectElement=buffer[i];
64
65	if (objectElement!=null)
66	{
67	objectElement->classNameElement=null;
68	}
69	}
70	}
71
72	void setObject(ClassName *object, int index)
73	{
74	Parse parse;
75
76	if (index >= 0 && index < size )
77	{
78	ObjectElement<ClassName> *objectElement=buffer[index];
79
80	if ( objectElement != null )
81	{
82	objectElement->remove();
83	objectElement->classNameElement=object;
84	int length=0;
85	char *name=parse.intToString(index,&length);
86	objectElement->name=new String(name);
87	free(name);
88	}
89	else
90	{
91	int length=0;
92	char *name=parse.intToString(index, &length);
93	buffer[index]=new ObjectElement<ClassName>(object, name);
94	free(name);
95	}
96	}
97	}
98
99	void setObject(ClassName object, char iName, int index)
100	{
101	if (index >= 0 && index < size )
102	{
103	ObjectElement<ClassName> *objectElement=buffer[index];
104
105	if ( objectElement != null )
106	{
107	objectElement->remove();
108	objectElement->classNameElement=object;
109	objectElement->name=new String(iName);
110	}
111	else
112	{
113	buffer[index]=new ObjectElement<ClassName>(object, iName);
114	}
115	}
116	}
117
118	////////////////////////////////////////////////////////////////////////////////////
119	//have to do with the quicksort
120	////////////////////////////////////////////////////////////////////////////////////
121
122	void setElement(ObjectElement<ClassName> *iObjectElement, int index)
123	{
124	if (index >= 0 && index < size )
125	{
126	ObjectElement<ClassName> *objectElement=buffer[index];
127	objectElement->classNameElement=iObjectElement->classNameElement;
128	objectElement->name->setString(iObjectElement->name->buffer);
129	}
130	}
131
132	////////////////////////////////////////////////////////////////////////////////////
133	//have to do with the quicksort
134	////////////////////////////////////////////////////////////////////////////////////
135
136	void setElementPivot(ClassName object, char iName, int index)
137	{
138	if (index >= 0 && index < size )
139	{
140	ObjectElement<ClassName> *objectElement=buffer[index];
141	objectElement->classNameElement=object;
142	objectElement->name->setString(iName);
143	}
144	}
145
146	char *getObjectName(int index)
147	{
148	if (index >= 0 && index < size )
149	{
150	ObjectElement<ClassName> *objectElement=buffer[index];
151	stringLength=objectElement->name->length;
152	return objectElement->name->buffer;
153	}
154	return null;
155	}
156
157	ClassName *getObject(int index)
158	{
159	if (index >= 0 && index < size )
160	{
161	ObjectElement<ClassName> *objectElement=buffer[index];
162
163	if (objectElement!=null)
164	{
165	return objectElement->classNameElement;
166	}
167	}
168
169	return null;
170	}
171
172	ObjectElement<ClassName> *getObjectElement(int index)
173	{
174	if (index >= 0 && index < size )
175	{
176	ObjectElement<ClassName> *objectElement=buffer[index];
177
178	return objectElement;
179	}
180
181	return null;
182	}
183
184	void addLast(ClassName *object)
185	{
186	Parse parse;
187
188	if (buffer==null)
189	{
190	buffer=(ObjectElement<ClassName>*)malloc(sizeof(ObjectElement<ClassName>)*1);
191	buffer[0]=new ObjectElement<ClassName>(object, "0");
192	size=1;
193	}
194	else
195	{
196	int length=0;
197	char *name=parse.intToString(size+1, &length);
198	ObjectElement<ClassName> **tempBuffer=addObjectToArray(buffer,size,new ObjectElement<ClassName>(object, name));
199	free(name);
200	free(buffer);
201	buffer=tempBuffer;
202	size++;
203	}
204	}
205
206	void addLast(ClassName object, char iName)
207	{
208	if (buffer==0)
209	{
210	buffer=(ObjectElement<ClassName>*)malloc(sizeof(ObjectElement<ClassName>)*1);
211	buffer[0]=(int)new ObjectElement<ClassName>(object, iName);
212	size=1;
213	}
214	else
215	{
216	ObjectElement<ClassName> **tempBuffer=addObjectToArray(buffer,size,new ObjectElement<ClassName>(object, iName));
217	free(buffer);
218	buffer=tempBuffer;
219	size++;
220	}
221	}
222
223	//////////////////////////////////////////////////////////////////////////////////////
224	//add object together
225	//////////////////////////////////////////////////////////////////////////////////////
226
227	ObjectElement<ClassName> addObjectToArray(ObjectElement<ClassName> source, int sourceSize, ObjectElement<ClassName> *objectPointer)
228	{
229	int forward=0;
230
231	ObjectElement<ClassName> buffer=(ObjectElement<ClassName>)malloc(sourceSizesizeof(ObjectElement<ClassName>)+sizeof(ObjectElement<ClassName>*));
232
233	for ( int s=0 ; s<sourceSize ; s++ )
234	{
235	buffer[forward]=source[s];
236	forward++;
237	}
238
239	buffer[forward]=objectPointer;
240
241	return buffer;
242	}
243
244	////////////////////////////////////////////////////////////////////////////////////
245	//sort element in linkedlist
246	////////////////////////////////////////////////////////////////////////////////////
247
248	void sortLargestOrder()
249	{
250	sortLargestOrder(this, 0, size-1, 1);
251	}
252
253	void sortSmallestOrder()
254	{
255	sortSmallestOrder(this, 0, size-1, 0);
256	}
257
258
259	int partitionOrder(ObjectArray<ClassName> *list, int start, int top, int statement)
260	{
261
262	ObjectElement<ClassName> *tempPivot = list->getObjectElement(top);
263	ClassName *pointer=tempPivot->classNameElement;
264	String pivotString=tempPivot->name->buffer;
265	char *pivotBuffer = pivotString.buffer; // Partition around the last value
266	int pivotLength = pivotString.length;
267
268	int bottom = start-1; // Start outside the area to be partitioned
269	bool done=true;
270
271	while (done) // Until all elements are partitioned...
272	{
273	while (done) // Until we find an out of place element...
274	{
275	bottom++; // ... move the bottom up.
276	if (bottom == top) // If we hit the top...
277	{
278	done = false; // ... we are done.
279	break;
280	}
281
282	if (statement==0)
283	{
284	ObjectElement<ClassName> *objectElement=list->getObjectElement(bottom);
285	char *stringBuffer=objectElement->name->buffer;
286	int stringLength=objectElement->name->length;
287
288	if (stringTools->isStringSmaller(stringBuffer,stringLength,pivotBuffer,pivotLength))
289	{
290	list->setElement(objectElement,top); // Then put at the top... 6=7
291	break;
292	} // ... and start searching from the top.
293	}
294	else
295	{
296	ObjectElement<ClassName> *objectElement=list->getObjectElement(bottom);
297	char *stringBuffer=objectElement->name->buffer;
298	int stringLength=objectElement->name->length;
299
300	if (stringTools->isStringLarger(stringBuffer,stringLength,pivotBuffer,pivotLength))
301	{ // Is the bottom out of place?
302	list->setElement(objectElement,top); // Then put at the top... 6=7
303	break;
304	} // ... and start searching from the top.
305	}
306	}
307
308	while (done) // Until we find an out of place element...
309	{
310	--top; // ... move the top down.
311
312	if (top == bottom) // If we hit the bottom...
313	{
314	done = false; // ... we are done.
315	break;
316	}
317
318	if (statement==0)
319	{
320	ObjectElement<ClassName> *objectElement=list->getObjectElement(top);
321	char *stringBuffer=objectElement->name->buffer;
322	int stringLength=objectElement->name->length;
323
324	if (stringTools->isStringLarger(stringBuffer,stringLength,pivotBuffer,pivotLength))
325	{
326	list->setElement(objectElement,bottom); // Then put it at the bottom...
327	break;
328	} // ...and start searching from the bottom.
329	}
330	else
331	{
332	ObjectElement<ClassName> *objectElement=list->getObjectElement(top);
333	char *stringBuffer=objectElement->name->buffer;
334	int stringLength=objectElement->name->length;
335
336	if (stringTools->isStringSmaller(stringBuffer,stringLength,pivotBuffer,pivotLength))
337	{
338	list->setElement(objectElement,bottom); // Then put it at the bottom...
339	break;
340	} // ...and start searching from the bottom.
341	}
342	}
343	}
344
345	list->setElementPivot(pointer,pivotString.buffer, top);
346	return top; // Return the split point
347	}
348
349	void sortLargestOrder(ObjectArray<ClassName> *list, int start, int end, int statement)
350	{
351	if ( start < end )
352	{ // If there are two or more elements...
353	int split = partitionOrder(list, start, end, statement); //... partition the sublist...
354	sortLargestOrder(list, start, split-1, statement); // ... and sort both halves.
355	sortLargestOrder(list, split+1, end, statement);
356	}
357	}
358
359	void sortSmallestOrder(ObjectArray<ClassName> *list, int start, int end, int statement)
360	{
361	if ( start < end )
362	{ // If there are two or more elements...
363	int split = partitionOrder(list,start,end, statement); //... partition the sublist...
364	sortSmallestOrder(list, start, split-1, statement ); // ... and sort both halves.
365	sortSmallestOrder(list, split+1, end, statement);
366
367	}
368	}
369
370	ObjectElement<ClassName> **buffer;
371	int size;
372	int stringLength;
373	StringTools *stringTools;
374
375	};
376
377	#endif