Classes/Array/IntArray.cpp

#include "../Sort/ArrayQuickSort.h"
#include "../Binary/BinaryTools.h"
#include "IntArray.h"
#include "../System/SystemDefine.h"

IntArray::IntArray()
{
        buffer=0;
        size=0;
        internIndex=0;
        clearBuffer(0);
}

IntArray::IntArray(int iSize)
{
        buffer=(int*)malloc(sizeof(int)*iSize);
        size=iSize;
        internIndex=0;
        clearBuffer(0);
}

IntArray::~IntArray()
{
        if (buffer!=0)
        {
                free(buffer);
        }
}

void IntArray::clearBuffer(int clearValue)
{
        for ( int i=0; i<size ; i++ )
        {
                buffer[i]=clearValue;
        }
}

void IntArray::resetInternIndex()
{
        internIndex=0;
}

void IntArray::internIndexForward()
{
        if (internIndex >= 0 && (internIndex+1) < size )
        {
                internIndex++;
        }
}

int IntArray::getInternIndex()
{
        return internIndex;
}

void IntArray::sortLargestOrder()
{
        ArrayQuickSort::setStatement(0);
        ArrayQuickSort::sortLargestOrder(buffer,0,size-1);
}

void IntArray::sortSmallestOrder()
{
        ArrayQuickSort::setStatement(1);
        ArrayQuickSort::sortSmallestOrder(buffer,0,size-1);
}

void IntArray::setInt(int value,int index)
{
        if (index >= 0 && index < size )
        {
                buffer[index]=value;
        }
}

void IntArray::setInt(int value)
{
        if (internIndex >= 0 && internIndex < size )
        {
                buffer[internIndex]=value;
        }
}

void IntArray::removeInt(int index)
{
        if (index >= 0 && index < size )
        {
                --size;

                if (size > 0)
                {
                        for ( int i=0; i<size ; i++ )
                        {
                                if ( i >= index )
                                {
                                        buffer[i]=buffer[i+1];
                                }
                        }
                }
        }
}

int IntArray::getInt()
{
        if (internIndex >= 0 && internIndex < size )
        {
                return buffer[internIndex];
        }

        return 0;
}

int IntArray::getInt(int index)
{
        if (index >= 0 && index < size )
        {
                return buffer[index];
        }

        return 0;
}

void IntArray::addLast(int value)
{
        BinaryTools binaryTools;

        if (buffer==0)
        {
                buffer=(int*)malloc(sizeof(int)*1);
                buffer[0]=value;
                size=1;
        }
        else
        {
                int *tempBuffer=binaryTools.addIntValueToArray(buffer,size,value);              
                free(buffer);
                buffer=tempBuffer;
                size++;
        }
}

1	#include "../Sort/ArrayQuickSort.h"
2	#include "../Binary/BinaryTools.h"
3	#include "IntArray.h"
4	#include "../System/SystemDefine.h"
5
6	IntArray::IntArray()
7	{
8	buffer=0;
9	size=0;
10	internIndex=0;
11	clearBuffer(0);
12	}
13
14	IntArray::IntArray(int iSize)
15	{
16	buffer=(int)malloc(sizeof(int)iSize);
17	size=iSize;
18	internIndex=0;
19	clearBuffer(0);
20	}
21
22	IntArray::~IntArray()
23	{
24	if (buffer!=0)
25	{
26	free(buffer);
27	}
28	}
29
30	void IntArray::clearBuffer(int clearValue)
31	{
32	for ( int i=0; i<size ; i++ )
33	{
34	buffer[i]=clearValue;
35	}
36	}
37
38	void IntArray::resetInternIndex()
39	{
40	internIndex=0;
41	}
42
43	void IntArray::internIndexForward()
44	{
45	if (internIndex >= 0 && (internIndex+1) < size )
46	{
47	internIndex++;
48	}
49	}
50
51	int IntArray::getInternIndex()
52	{
53	return internIndex;
54	}
55
56	void IntArray::sortLargestOrder()
57	{
58	ArrayQuickSort::setStatement(0);
59	ArrayQuickSort::sortLargestOrder(buffer,0,size-1);
60	}
61
62	void IntArray::sortSmallestOrder()
63	{
64	ArrayQuickSort::setStatement(1);
65	ArrayQuickSort::sortSmallestOrder(buffer,0,size-1);
66	}
67
68	void IntArray::setInt(int value,int index)
69	{
70	if (index >= 0 && index < size )
71	{
72	buffer[index]=value;
73	}
74	}
75
76	void IntArray::setInt(int value)
77	{
78	if (internIndex >= 0 && internIndex < size )
79	{
80	buffer[internIndex]=value;
81	}
82	}
83
84	void IntArray::removeInt(int index)
85	{
86	if (index >= 0 && index < size )
87	{
88	--size;
89
90	if (size > 0)
91	{
92	for ( int i=0; i<size ; i++ )
93	{
94	if ( i >= index )
95	{
96	buffer[i]=buffer[i+1];
97	}
98	}
99	}
100	}
101	}
102
103	int IntArray::getInt()
104	{
105	if (internIndex >= 0 && internIndex < size )
106	{
107	return buffer[internIndex];
108	}
109
110	return 0;
111	}
112
113	int IntArray::getInt(int index)
114	{
115	if (index >= 0 && index < size )
116	{
117	return buffer[index];
118	}
119
120	return 0;
121	}
122
123	void IntArray::addLast(int value)
124	{
125	BinaryTools binaryTools;
126
127	if (buffer==0)
128	{
129	buffer=(int)malloc(sizeof(int)1);
130	buffer[0]=value;
131	size=1;
132	}
133	else
134	{
135	int *tempBuffer=binaryTools.addIntValueToArray(buffer,size,value);
136	free(buffer);
137	buffer=tempBuffer;
138	size++;
139	}
140	}
141