Classes/Binary/BinaryInput.cpp

#include "BinaryInput.h"
#include "../System/System.h"


BinaryInput::BinaryInput()
{
        internBuffer=0;
        sourceBuffer=0;
        endBuffer=0;
        fileSize=0;
        scanBinaryStatus=true;
        wordBuffer=0;
        bigEndian=false;
        fileStatus=0;
        charCounter=0;
        fileTools = new FileTools();
        stringTools = new StringTools();
}

BinaryInput::~BinaryInput()
{
        if (internBuffer != 0 )
        {
                free(internBuffer);
                internBuffer=0;
        }

        if (wordBuffer != 0 )
        {
                free(wordBuffer);
                wordBuffer=0;
        }

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

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

// internBuffer=the start of the ascii buffer
// sourceBuffer=where the pointer is in the internBuffer
// endBuffer=the end of the internBuffer

//////////////////////////////////////////////////////////////////////////////////////
//read a ascii file
//////////////////////////////////////////////////////////////////////////////////////

void BinaryInput::readFile(const String & string)  
{
        readFile(string.buffer);
}


void BinaryInput::readFile(char *filename)  
{
        if ( internBuffer != 0 )
        {
                free(internBuffer);
                internBuffer=0;
        }

        int fileBuffer=0;

        FileTools fileTools;

        fileStatus=fileTools.readStringFile(filename,&fileBuffer,&fileSize);

        internBuffer=(char*)fileBuffer;
        sourceBuffer=(char*)internBuffer;
        endBuffer=(char*)internBuffer;
        endBuffer+=fileSize;
        scanBinaryStatus=true;
}

//////////////////////////////////////////////////////////////////////////////////////
//can i read more words??
//////////////////////////////////////////////////////////////////////////////////////

bool BinaryInput::getScanBinaryStatus()
{
        return scanBinaryStatus;
}


//////////////////////////////////////////////////////////////////////////////////////
//set a String to the InternBuffer
//////////////////////////////////////////////////////////////////////////////////////

void BinaryInput::setInternBuffer(char *iInternBuffer, int size)
{
        if ( iInternBuffer != 0 )
        {
                if ( internBuffer != 0 )
                {
                        free(internBuffer);
                        internBuffer=0;
                }

                internBuffer=iInternBuffer;     
                fileSize=size;
                sourceBuffer=(char*)internBuffer;
                endBuffer=(char*)internBuffer;
                endBuffer+=fileSize;
                scanBinaryStatus=true;
        }
}

//////////////////////////////////////////////////////////////////////////////////////
//takes the start address from the internBuffer and copy its to the sourcebuffer pointer
//////////////////////////////////////////////////////////////////////////////////////

void BinaryInput::resetScanWord()
{
        sourceBuffer=internBuffer;
        scanBinaryStatus=true;
}

char *BinaryInput::getWord(int size)
{
        binaryStatus=false;
        
        if (wordBuffer!=0)
        {
                free(wordBuffer);
                wordBuffer=0;
        }

        if ((sourceBuffer >= internBuffer) && ((sourceBuffer+size) < endBuffer) )
        {
                binaryStatus=true;

                wordBuffer=(char*)malloc(sizeof(char)*size+sizeof(char));
        
                stringTools->copyString(sourceBuffer, size, wordBuffer);
                
                sourceBuffer+=size;
                charCounter+=size;
        }

        return wordBuffer;
}

char *BinaryInput::getWord()
{
        binaryStatus=false;
        
        if (wordBuffer!=0)
        {
                free(wordBuffer);
                wordBuffer=0;
        }

        if ((sourceBuffer >= internBuffer) && ((sourceBuffer+sizeof(char)) <= endBuffer) )
        {
                binaryStatus=true;

                int size=stringTools->sizeOfString(sourceBuffer, endBuffer);

                wordBuffer=(char*)malloc(sizeof(char)*size);

                stringTools->copyString(sourceBuffer, (size-1), wordBuffer);

                sourceBuffer+=size;
                charCounter+=size;
        }

        return wordBuffer;
}

char BinaryInput::getChar()
{
        binaryStatus=false;
        char charValue=0;

        if ((sourceBuffer >= internBuffer) && ((sourceBuffer+sizeof(char)) <= endBuffer))
        {
                binaryStatus=true;
                charValue=sourceBuffer[0];
                sourceBuffer++;
                charCounter++;
        }

        return charValue;
}


short BinaryInput::getShortButGoNotFoward()
{
        short shortValue=getShort();

        if (binaryStatus)
        {
                sourceBuffer-=sizeof(short);
                charCounter-=sizeof(short);
        }

        return shortValue;
}

short BinaryInput::getShort()
{
        binaryStatus=false;
        short shortValue=0;

        if ((sourceBuffer >= internBuffer) && ((sourceBuffer+sizeof(short)) <= endBuffer))
        {
                binaryStatus=true;

                if (bigEndian)
                {
                        char *shortPointer=(char*)&shortValue;

                        shortPointer[1]=sourceBuffer[0];
                        sourceBuffer++;
                        shortPointer[0]=sourceBuffer[0];
                        sourceBuffer++;
                        charCounter+=sizeof(short);
                }
                else
                {
                        short *shortPointer=(short*)&shortValue;
                        short *shortSourceBuffer=(short*)sourceBuffer;
                        shortPointer[0]=shortSourceBuffer[0];
                        sourceBuffer+=sizeof(short);
                        charCounter+=sizeof(short);
                }
        }

        return shortValue;
}

int BinaryInput::getInt()
{
        binaryStatus=false;
        int intValue=0;

        if ((sourceBuffer >= internBuffer) && ((sourceBuffer+sizeof(int)) <= endBuffer))
        {
                binaryStatus=true;

                if (bigEndian)
                {
                        char *intPointer=(char*)&intValue;

                        intPointer[3]=sourceBuffer[0];
                        sourceBuffer++;
                        intPointer[2]=sourceBuffer[0];
                        sourceBuffer++;
                        intPointer[1]=sourceBuffer[0];
                        sourceBuffer++;
                        intPointer[0]=sourceBuffer[0];
                        sourceBuffer++;
                        charCounter+=sizeof(int);
                }
                else
                {
                        int *intPointer=(int*)&intValue;
                        int *intSourceBuffer=(int*)sourceBuffer;
                        intPointer[0]=intSourceBuffer[0];
                        sourceBuffer+=sizeof(int);
                        charCounter+=sizeof(int);
                }
        }

        return intValue;
}


float BinaryInput::getFloat()
{
        binaryStatus=false;
        float floatValue=0;

        if (((sourceBuffer+sizeof(float)) >= internBuffer) && ((sourceBuffer+sizeof(float)) <= endBuffer))
        {
                binaryStatus=true;

                if (bigEndian)
                {
                        char *floatPointer=(char*)&floatValue;

                        floatPointer[3]=sourceBuffer[0];
                        sourceBuffer++;
                        floatPointer[2]=sourceBuffer[0];
                        sourceBuffer++;
                        floatPointer[1]=sourceBuffer[0];
                        sourceBuffer++;
                        floatPointer[0]=sourceBuffer[0];
                        sourceBuffer++;
                        charCounter+=sizeof(float);
                }
                else
                {
                        float *floatPointer=(float*)&floatValue;
                        float *floatSourceBuffer=(float*)sourceBuffer;
                        floatPointer[0]=floatSourceBuffer[0];
                        sourceBuffer+=sizeof(float);
                        charCounter+=sizeof(float);
                }
        }

        return floatValue;
}

void BinaryInput::setBigEndian(bool bigEndian)
{
        this->bigEndian=bigEndian;
}

bool BinaryInput::getBinaryStatus()
{
        return binaryStatus;
}

bool BinaryInput::jumpForward(int jumpValue)
{
        binaryStatus=false;

        if (jumpValue!=0)
        {
                if ( (sourceBuffer+jumpValue) <= endBuffer )
                {
                        binaryStatus=true;
                        sourceBuffer+=jumpValue;
                        charCounter+=jumpValue;
                }       
        }

        return binaryStatus;
}

char *BinaryInput::getInternBuffer()
{
        return internBuffer;
}

int BinaryInput::getInternBufferSize()
{
        return fileSize;
}

int BinaryInput::getFileStatus()
{
        return fileStatus;
}

int BinaryInput::socketSend(int socket)
{
        NetWorkTools *netWorkTools = new NetWorkTools();
        int status=0;

        if (internBuffer!=null)
        {
                status=netWorkTools->sendData(socket,internBuffer,fileSize);
        }

        delete netWorkTools;

        return status;
}

void BinaryInput::setInternBufferPosition(int position)
{
        binaryStatus=false;
        
        if ( ((internBuffer+position) >= internBuffer) && ((internBuffer+position) <= endBuffer))
        {
                sourceBuffer=internBuffer+position;
                binaryStatus=true;
        }
}

void BinaryInput::resetCharCounter()
{
        charCounter=0;
}

int BinaryInput::getCharCounter()
{
        return charCounter;
}
1	#include "BinaryInput.h"
2	#include "../System/System.h"
3
4
5	BinaryInput::BinaryInput()
6	{
7	internBuffer=0;
8	sourceBuffer=0;
9	endBuffer=0;
10	fileSize=0;
11	scanBinaryStatus=true;
12	wordBuffer=0;
13	bigEndian=false;
14	fileStatus=0;
15	charCounter=0;
16	fileTools = new FileTools();
17	stringTools = new StringTools();
18	}
19
20	BinaryInput::~BinaryInput()
21	{
22	if (internBuffer != 0 )
23	{
24	free(internBuffer);
25	internBuffer=0;
26	}
27
28	if (wordBuffer != 0 )
29	{
30	free(wordBuffer);
31	wordBuffer=0;
32	}
33
34	if (fileTools!=null)
35	{
36	delete fileTools;
37	}
38
39	if (stringTools!=null)
40	{
41	delete stringTools;
42	}
43	}
44
45	// internBuffer=the start of the ascii buffer
46	// sourceBuffer=where the pointer is in the internBuffer
47	// endBuffer=the end of the internBuffer
48
49	//////////////////////////////////////////////////////////////////////////////////////
50	//read a ascii file
51	//////////////////////////////////////////////////////////////////////////////////////
52
53	void BinaryInput::readFile(const String & string)
54	{
55	readFile(string.buffer);
56	}
57
58
59	void BinaryInput::readFile(char *filename)
60	{
61	if ( internBuffer != 0 )
62	{
63	free(internBuffer);
64	internBuffer=0;
65	}
66
67	int fileBuffer=0;
68
69	FileTools fileTools;
70
71	fileStatus=fileTools.readStringFile(filename,&fileBuffer,&fileSize);
72
73	internBuffer=(char*)fileBuffer;
74	sourceBuffer=(char*)internBuffer;
75	endBuffer=(char*)internBuffer;
76	endBuffer+=fileSize;
77	scanBinaryStatus=true;
78	}
79
80	//////////////////////////////////////////////////////////////////////////////////////
81	//can i read more words??
82	//////////////////////////////////////////////////////////////////////////////////////
83
84	bool BinaryInput::getScanBinaryStatus()
85	{
86	return scanBinaryStatus;
87	}
88
89
90	//////////////////////////////////////////////////////////////////////////////////////
91	//set a String to the InternBuffer
92	//////////////////////////////////////////////////////////////////////////////////////
93
94	void BinaryInput::setInternBuffer(char *iInternBuffer, int size)
95	{
96	if ( iInternBuffer != 0 )
97	{
98	if ( internBuffer != 0 )
99	{
100	free(internBuffer);
101	internBuffer=0;
102	}
103
104	internBuffer=iInternBuffer;
105	fileSize=size;
106	sourceBuffer=(char*)internBuffer;
107	endBuffer=(char*)internBuffer;
108	endBuffer+=fileSize;
109	scanBinaryStatus=true;
110	}
111	}
112
113	//////////////////////////////////////////////////////////////////////////////////////
114	//takes the start address from the internBuffer and copy its to the sourcebuffer pointer
115	//////////////////////////////////////////////////////////////////////////////////////
116
117	void BinaryInput::resetScanWord()
118	{
119	sourceBuffer=internBuffer;
120	scanBinaryStatus=true;
121	}
122
123	char *BinaryInput::getWord(int size)
124	{
125	binaryStatus=false;
126
127	if (wordBuffer!=0)
128	{
129	free(wordBuffer);
130	wordBuffer=0;
131	}
132
133	if ((sourceBuffer >= internBuffer) && ((sourceBuffer+size) < endBuffer) )
134	{
135	binaryStatus=true;
136
137	wordBuffer=(char)malloc(sizeof(char)size+sizeof(char));
138
139	stringTools->copyString(sourceBuffer, size, wordBuffer);
140
141	sourceBuffer+=size;
142	charCounter+=size;
143	}
144
145	return wordBuffer;
146	}
147
148	char *BinaryInput::getWord()
149	{
150	binaryStatus=false;
151
152	if (wordBuffer!=0)
153	{
154	free(wordBuffer);
155	wordBuffer=0;
156	}
157
158	if ((sourceBuffer >= internBuffer) && ((sourceBuffer+sizeof(char)) <= endBuffer) )
159	{
160	binaryStatus=true;
161
162	int size=stringTools->sizeOfString(sourceBuffer, endBuffer);
163
164	wordBuffer=(char)malloc(sizeof(char)size);
165
166	stringTools->copyString(sourceBuffer, (size-1), wordBuffer);
167
168	sourceBuffer+=size;
169	charCounter+=size;
170	}
171
172	return wordBuffer;
173	}
174
175	char BinaryInput::getChar()
176	{
177	binaryStatus=false;
178	char charValue=0;
179
180	if ((sourceBuffer >= internBuffer) && ((sourceBuffer+sizeof(char)) <= endBuffer))
181	{
182	binaryStatus=true;
183	charValue=sourceBuffer[0];
184	sourceBuffer++;
185	charCounter++;
186	}
187
188	return charValue;
189	}
190
191
192	short BinaryInput::getShortButGoNotFoward()
193	{
194	short shortValue=getShort();
195
196	if (binaryStatus)
197	{
198	sourceBuffer-=sizeof(short);
199	charCounter-=sizeof(short);
200	}
201
202	return shortValue;
203	}
204
205	short BinaryInput::getShort()
206	{
207	binaryStatus=false;
208	short shortValue=0;
209
210	if ((sourceBuffer >= internBuffer) && ((sourceBuffer+sizeof(short)) <= endBuffer))
211	{
212	binaryStatus=true;
213
214	if (bigEndian)
215	{
216	char shortPointer=(char)&shortValue;
217
218	shortPointer[1]=sourceBuffer[0];
219	sourceBuffer++;
220	shortPointer[0]=sourceBuffer[0];
221	sourceBuffer++;
222	charCounter+=sizeof(short);
223	}
224	else
225	{
226	short shortPointer=(short)&shortValue;
227	short shortSourceBuffer=(short)sourceBuffer;
228	shortPointer[0]=shortSourceBuffer[0];
229	sourceBuffer+=sizeof(short);
230	charCounter+=sizeof(short);
231	}
232	}
233
234	return shortValue;
235	}
236
237	int BinaryInput::getInt()
238	{
239	binaryStatus=false;
240	int intValue=0;
241
242	if ((sourceBuffer >= internBuffer) && ((sourceBuffer+sizeof(int)) <= endBuffer))
243	{
244	binaryStatus=true;
245
246	if (bigEndian)
247	{
248	char intPointer=(char)&intValue;
249
250	intPointer[3]=sourceBuffer[0];
251	sourceBuffer++;
252	intPointer[2]=sourceBuffer[0];
253	sourceBuffer++;
254	intPointer[1]=sourceBuffer[0];
255	sourceBuffer++;
256	intPointer[0]=sourceBuffer[0];
257	sourceBuffer++;
258	charCounter+=sizeof(int);
259	}
260	else
261	{
262	int intPointer=(int)&intValue;
263	int intSourceBuffer=(int)sourceBuffer;
264	intPointer[0]=intSourceBuffer[0];
265	sourceBuffer+=sizeof(int);
266	charCounter+=sizeof(int);
267	}
268	}
269
270	return intValue;
271	}
272
273
274	float BinaryInput::getFloat()
275	{
276	binaryStatus=false;
277	float floatValue=0;
278
279	if (((sourceBuffer+sizeof(float)) >= internBuffer) && ((sourceBuffer+sizeof(float)) <= endBuffer))
280	{
281	binaryStatus=true;
282
283	if (bigEndian)
284	{
285	char floatPointer=(char)&floatValue;
286
287	floatPointer[3]=sourceBuffer[0];
288	sourceBuffer++;
289	floatPointer[2]=sourceBuffer[0];
290	sourceBuffer++;
291	floatPointer[1]=sourceBuffer[0];
292	sourceBuffer++;
293	floatPointer[0]=sourceBuffer[0];
294	sourceBuffer++;
295	charCounter+=sizeof(float);
296	}
297	else
298	{
299	float floatPointer=(float)&floatValue;
300	float floatSourceBuffer=(float)sourceBuffer;
301	floatPointer[0]=floatSourceBuffer[0];
302	sourceBuffer+=sizeof(float);
303	charCounter+=sizeof(float);
304	}
305	}
306
307	return floatValue;
308	}
309
310	void BinaryInput::setBigEndian(bool bigEndian)
311	{
312	this->bigEndian=bigEndian;
313	}
314
315	bool BinaryInput::getBinaryStatus()
316	{
317	return binaryStatus;
318	}
319
320	bool BinaryInput::jumpForward(int jumpValue)
321	{
322	binaryStatus=false;
323
324	if (jumpValue!=0)
325	{
326	if ( (sourceBuffer+jumpValue) <= endBuffer )
327	{
328	binaryStatus=true;
329	sourceBuffer+=jumpValue;
330	charCounter+=jumpValue;
331	}
332	}
333
334	return binaryStatus;
335	}
336
337	char *BinaryInput::getInternBuffer()
338	{
339	return internBuffer;
340	}
341
342	int BinaryInput::getInternBufferSize()
343	{
344	return fileSize;
345	}
346
347	int BinaryInput::getFileStatus()
348	{
349	return fileStatus;
350	}
351
352	int BinaryInput::socketSend(int socket)
353	{
354	NetWorkTools *netWorkTools = new NetWorkTools();
355	int status=0;
356
357	if (internBuffer!=null)
358	{
359	status=netWorkTools->sendData(socket,internBuffer,fileSize);
360	}
361
362	delete netWorkTools;
363
364	return status;
365	}
366
367	void BinaryInput::setInternBufferPosition(int position)
368	{
369	binaryStatus=false;
370
371	if ( ((internBuffer+position) >= internBuffer) && ((internBuffer+position) <= endBuffer))
372	{
373	sourceBuffer=internBuffer+position;
374	binaryStatus=true;
375	}
376	}
377
378	void BinaryInput::resetCharCounter()
379	{
380	charCounter=0;
381	}
382
383	int BinaryInput::getCharCounter()
384	{
385	return charCounter;
386	}