Classes/Array/FloatArray.cpp

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

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

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

FloatArray::~FloatArray()
{
        free(buffer);
}

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

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

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

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

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

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

void FloatArray::setFloat(float value)
{
        if (internIndex >= 0 && internIndex < size )
        {
                buffer[internIndex]=value;
        }
}

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

float FloatArray::getFloat()
{
        if (internIndex >= 0 && internIndex < size )
        {
                return buffer[internIndex];
        }

        return 0;
}

float FloatArray::getFloat(int index)
{
        if (index >= 0 && index < size )
        {
                return buffer[index];
        }

        return 0;
}


void FloatArray::removeFloat(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];
                                }
                        }
                }
        }
}

void FloatArray::addLast(float value)
{
        BinaryTools binaryTools;

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