Classes/String/String.h

#ifndef __String_H__
#define __String_H__

#include "../NetWork/NetWorkTools.h"
#include "Parse.h"
#include "StringTools.h"
#include "NewRow.h"
#include "../Files/FileTools.h"
#include "../DateTime/DateTime.h"
#include "../System/SystemDefine.h"
#include <iostream>

class String
{

public:
        
String()
{
        buffer=null;
        length=0;
}

String(const DateTime &dateTime)
{
        char *tempBuffer=dateTime.buffer;
        buffer=tempBuffer;
        int tempLength=dateTime.length;
        length=tempLength;
}

String(float value)
{
        Parse parse;
        buffer=parse.floatToString(value, &length);
}

String(int value)
{
        Parse parse;

        buffer=parse.intToString(value, &length);
}

String(const NewRow &newRow)
{
        buffer=null;
        char tempCharacter[3]={10,0};
        setString(tempCharacter, 1);
}

String(char *iBuffer)
{
        buffer=null;
        setString(iBuffer);
}

String(const char &iBuffer)
{
        buffer=null;
        setString((char*)iBuffer);
}

String(const String &string)
{
        buffer=null;
        setString((char*)string.buffer, string.length);
}

String(String *string)
{
        buffer=null;
        setString((char*)string->buffer, string->length);
}

String(int intValue, char *buffer2, int buffer2Length)
{
        Parse parse;
        StringTools stringTools;

        if (buffer2!=null)
        {
                char *tempBuffer=parse.intToString(intValue, &length);
                buffer=stringTools.addStringTwoString((char*)buffer2, buffer2Length, (char*)tempBuffer, length);
                length+=buffer2Length;
                free(tempBuffer);
        }
        else
        {
                buffer=parse.intToString(intValue, &length);
        }
}

String(float floatValue, char *buffer2, int buffer2Length)
{
        Parse parse;
        StringTools stringTools;

        if (buffer2!=null)
        {
                char *tempBuffer=parse.floatToString(floatValue, &length);
                buffer=stringTools.addStringTwoString((char*)buffer2, buffer2Length, (char*)tempBuffer, length);
                length+=buffer2Length;
                free(tempBuffer);
        }
        else
        {
                buffer=parse.floatToString(floatValue, &length);
        }
}

String(const NewRow &newRow, char *buffer2, int buffer2Length)
{
        StringTools stringTools;

        if (buffer2!=null)
        {
                char tempCharacter[2]={10,0};
                buffer=stringTools.addStringTwoString((char*)buffer2, buffer2Length, (char*)tempCharacter, 1);
                length=buffer2Length + 1;
        }
        else
        {
                buffer=null;
                char tempCharacter[2]={10,0};
                setString(tempCharacter, 1);
        }
}

String(char *iBuffer, int iBufferLength, char *iBuffer2, int iBuffer2Length)
{
        StringTools stringTools;

        if (iBuffer!=null && iBuffer2!=null)
        {
                buffer=stringTools.addStringTwoString((char*)iBuffer2, iBuffer2Length, (char*)iBuffer, iBufferLength);
                length=iBufferLength+iBuffer2Length;
        }
        else
        {
                buffer=null;
                bool statement=false;

                if (iBuffer!=null)
                {
                        setString(iBuffer, iBufferLength);
                        statement=true;
                }

                if (iBuffer2!=null)
                {
                        setString(iBuffer2, iBuffer2Length);
                        statement=true;
                }

                if (!statement)
                {
                        buffer=null;
                        length=0;
                }
        }

}

~String()
{
        if ( buffer != null )
        {
                free(buffer);
        }
}

String operator+(int value)
{
        return String(value, (char*)buffer, length);
}

String operator+(float value)
{
        return String(value, (char*)buffer, length);
}

String operator+(const String &string)
{
        return String((char*)string.buffer, string.length, (char*)buffer, length);
}

String operator+(String *string)
{
        return String((char*)string->buffer, string->length, (char*)buffer, length);
}

String operator+(char* iBuffer)
{
        StringTools stringTools;

        return String((char*)iBuffer, stringTools.sizeOfStringWithOutEndNull(iBuffer), (char*)buffer, length);
}

String operator+(const NewRow &newRow)
{
        return String(newRow, (char*)buffer, length);
}

String operator+(const char &iBuffer)
{
        StringTools stringTools;

        return String((char*)iBuffer, stringTools.sizeOfStringWithOutEndNull((char*)iBuffer), (char*)buffer, length);
}

void operator+=(int intValue)
{
        Parse parse;
        StringTools stringTools;


        if (buffer!=null)
        {
                char *tBuffer=buffer;
                int intLength=0;
                char *tempBuffer=parse.intToString(intValue, &intLength);
                buffer=stringTools.addStringTwoString((char*)buffer, length, (char*)tempBuffer, intLength);
                length+=intLength;
                free(tempBuffer);
                free(tBuffer);
        }
        else
        {
                buffer=parse.intToString(intValue, &length);
        }
}

void operator+=(float floatValue)
{
        Parse parse;
        StringTools stringTools;

        if (buffer!=null)
        {
                char *tBuffer=buffer;
                int floatLength=0;
                char *tempBuffer=parse.floatToString(floatValue, &floatLength);
                buffer=stringTools.addStringTwoString((char*)buffer, length, (char*)tempBuffer, floatLength);
                length+=floatLength;
                free(tempBuffer);
                free(tBuffer);
        }
        else
        {
                buffer=parse.floatToString(floatValue, &length);
        }
}

void operator+=(const String &string)
{
        copyBuffer(string.buffer, string.length);
}

void operator+=(String * string)
{
        copyBuffer(string->buffer, string->length);
}

void operator+=(char* iBuffer)
{
        StringTools stringTools;

        copyBuffer(iBuffer, stringTools.sizeOfStringWithOutEndNull(iBuffer));
}

void copyBuffer(char *iBuffer, int iBufferLength)
{
        StringTools stringTools;

        if (buffer!=null)
        {
                if (iBuffer != null )
                {
                        char *tBuffer=buffer;
                        buffer=stringTools.addStringTwoString((char*)buffer, length, (char*)iBuffer, iBufferLength);
                        length+=iBufferLength;
                        free(tBuffer);
                }
        }
        else
        {
                if (iBuffer != null)
                {
                        setString(iBuffer, iBufferLength);
                }
        }
}

void operator+=(const NewRow &newRow)
{
        StringTools stringTools;

        if (buffer!=null)
        {
                char *tBuffer=buffer;
                char tempCharacter[2]={10,0};
                buffer=stringTools.addStringTwoString((char*)buffer, length, (char*)tempCharacter, 1);
                length=1;
                free(tBuffer);
        }
        else
        {
                char tempCharacter[2]={10,0};
                setString(tempCharacter, 1);
        }
}

void operator+=(const char character)
{
        StringTools stringTools;

        if (buffer!=null)
        {
                char *tBuffer=buffer;
                char tempCharacter[2]={0,0};
                tempCharacter[0]=character;
                buffer=stringTools.addStringTwoString((char*)buffer, length, (char*)tempCharacter, 1);
                length=1;
                free(tBuffer);
        }
        else
        {
                char tempCharacter[2]={0,0};
                tempCharacter[0]=character;
                setString(tempCharacter, 1);
        }
}

void removeCharacter(int index)
{
        if (index >= 0 && index < length )
        {
                --length;

                if (length > 0)
                {
                        for ( int i=0; i<length ; i++ )
                        {
                                if ( i >= index )
                                {
                                        buffer[i]=buffer[i+1];
                                }
                        }
                }
                else
                {
                        if (buffer!=null)
                        {
                                free(buffer);
                                buffer=null;
                        }
                }
        }
}

void replaceCharacter(const char replace, const char remove)
{
        if (buffer!=null)
        {
                for ( int i=0; i<length ; i++ )
                {
                        if (buffer[i]==remove)
                        {
                                buffer[i]=replace;      
                        }
                }
        }
}

int toInt()
{
        Parse parse;

        return parse.stringToInt(buffer);
}

float toFloat()
{
        Parse parse;

        return parse.stringToFloat(buffer);
}

bool equals(const String &string)
{
        StringTools stringTools;

        return stringTools.compareString(buffer, string.buffer);
}

bool equals(char *iBuffer)
{
        StringTools stringTools;

        return stringTools.compareString(buffer, iBuffer);
}

void setString(const String &string)
{
        setString(string.buffer, string.length);
}

void setString(String *string)
{
        if (string!=null)
        {
                setString(string->buffer, string->length);
        }
}

void setString(char *iBuffer)
{
        StringTools stringTools;

        if (buffer!=null)
        {
                free(buffer);
                buffer=null;
        }

        if (iBuffer != null)
        {
                length=stringTools.sizeOfStringWithOutEndNull(iBuffer);
                buffer=(char*)malloc((sizeof(char)*length)+sizeof(char));
                stringTools.copyString(iBuffer, length, buffer);
        }
}

void setString(char *iBuffer, int iBufferLength)
{
        StringTools stringTools;

        if (buffer!=null)
        {
                free(buffer);
                buffer=null;
        }

        if (iBuffer != null)
        {
                length=iBufferLength;
                buffer=(char*)malloc(sizeof(char)*length+sizeof(char));
                stringTools.copyString(iBuffer, length, buffer);
        }
}

void cutTheBack(char character)
{
        StringTools stringTools;

        buffer=stringTools.cutTheBack(buffer, &length, character);
}

void cutTheBegining(char character)
{
        StringTools stringTools;

        buffer=stringTools.cutTheBegining(buffer, &length, character);
}

int socketSend(int socket)
{
        NetWorkTools netWorkTools;
        return netWorkTools.sendData(socket,buffer,length);
}

bool isBackPartEqualTo(char *fileFormat)
{
        StringTools stringTools;

        return stringTools.checkBack(buffer,length,fileFormat,stringTools.sizeOfStringWithOutEndNull(fileFormat));      
}

bool isFrontPartEqualTo(char *fileFormat)
{
        StringTools stringTools;

        return stringTools.checkFront(buffer, length, fileFormat, stringTools.sizeOfStringWithOutEndNull(fileFormat));  
}

int writeToFile(const String &fileName)
{
        return writeToFile(fileName.buffer);
}

int writeToFileEnd(const String &fileName)
{
        return writeToFileEnd(fileName.buffer);
}

int writelnToFileEnd(const String &fileName)
{
        StringTools stringTools;

        int fileStatus=0;

        if (buffer!=null)
        {
                char tempCharacter[2]={10,0};
                char *newBuffer=stringTools.addStringTwoString((char*)buffer, length, (char*)tempCharacter, 1);
                fileStatus=writeToFileEnd(fileName.buffer,newBuffer, length+1);
                free(newBuffer);
        }

        return fileStatus;
}

int writeToFile(char *fileName)
{
        FileTools fileTools;

        int fileStatus=0;

        if (buffer!=null)
        {
                fileStatus=fileTools.writeFile(fileName,(char*)buffer,length);
        }       

        return fileStatus;
}

int writeToFileEnd(char *fileName)
{
        FileTools fileTools;

        int fileStatus=0;

        if (buffer!=null)
        {
                fileStatus=fileTools.writeToFileEnd(fileName,(char*)buffer,length);
        }       

        return fileStatus;
}

int writeToFileEnd(char *fileName, char *newBuffer, int newLength)
{
        FileTools fileTools;

        int fileStatus=0;

        if (buffer!=null)
        {
                fileStatus=fileTools.writeToFileEnd(fileName,(char*)newBuffer,newLength);
        }       

        return fileStatus;
}


int readFile(char *fileName)  
{
        if (buffer!=null)
        {
                free(buffer);
                buffer=null;
        }

        int fileBuffer=0;

        FileTools fileTools;

//      int fileStatus=FileTools::readStringFile(fileName,&fileBuffer,&length);
        int fileStatus=fileTools.readStringFile(fileName,&fileBuffer,&length);
        buffer=(char*)fileBuffer;

        return fileStatus;
}

bool isNull()
{
        if (buffer==null)
        {
                return true;
        }

        return false;
}

bool theFilePathIsNotUnder(String &filePath)
{
        StringTools stringTools;

        return stringTools.theFilePathIsNotUnder(buffer,length, filePath.buffer, filePath.length);
}

  
char* buffer;
String *string;
int length;

private:

};


#endif
1	bearsoft	1.1	#ifndef __String_H__
2			#define __String_H__
3
4			#include "../NetWork/NetWorkTools.h"
5			#include "Parse.h"
6			#include "StringTools.h"
7			#include "NewRow.h"
8			#include "../Files/FileTools.h"
9			#include "../DateTime/DateTime.h"
10			#include "../System/SystemDefine.h"
11			#include <iostream>
12
13			class String
14			{
15
16			public:
17
18			String()
19			{
20			buffer=null;
21			length=0;
22			}
23
24			String(const DateTime &dateTime)
25			{
26			char *tempBuffer=dateTime.buffer;
27			buffer=tempBuffer;
28			int tempLength=dateTime.length;
29			length=tempLength;
30			}
31
32			String(float value)
33			{
34			Parse parse;
35			buffer=parse.floatToString(value, &length);
36			}
37
38			String(int value)
39			{
40			Parse parse;
41
42			buffer=parse.intToString(value, &length);
43			}
44
45			String(const NewRow &newRow)
46			{
47			buffer=null;
48			char tempCharacter[3]={10,0};
49			setString(tempCharacter, 1);
50			}
51
52			String(char *iBuffer)
53			{
54			buffer=null;
55			setString(iBuffer);
56			}
57
58			String(const char &iBuffer)
59			{
60			buffer=null;
61			setString((char*)iBuffer);
62			}
63
64			String(const String &string)
65			{
66			buffer=null;
67			setString((char*)string.buffer, string.length);
68			}
69
70			String(String *string)
71			{
72			buffer=null;
73			setString((char*)string->buffer, string->length);
74			}
75
76			String(int intValue, char *buffer2, int buffer2Length)
77			{
78			Parse parse;
79			StringTools stringTools;
80
81			if (buffer2!=null)
82			{
83			char *tempBuffer=parse.intToString(intValue, &length);
84			buffer=stringTools.addStringTwoString((char)buffer2, buffer2Length, (char)tempBuffer, length);
85			length+=buffer2Length;
86			free(tempBuffer);
87			}
88			else
89			{
90			buffer=parse.intToString(intValue, &length);
91			}
92			}
93
94			String(float floatValue, char *buffer2, int buffer2Length)
95			{
96			Parse parse;
97			StringTools stringTools;
98
99			if (buffer2!=null)
100			{
101			char *tempBuffer=parse.floatToString(floatValue, &length);
102			buffer=stringTools.addStringTwoString((char)buffer2, buffer2Length, (char)tempBuffer, length);
103			length+=buffer2Length;
104			free(tempBuffer);
105			}
106			else
107			{
108			buffer=parse.floatToString(floatValue, &length);
109			}
110			}
111
112			String(const NewRow &newRow, char *buffer2, int buffer2Length)
113			{
114			StringTools stringTools;
115
116			if (buffer2!=null)
117			{
118			char tempCharacter[2]={10,0};
119			buffer=stringTools.addStringTwoString((char)buffer2, buffer2Length, (char)tempCharacter, 1);
120			length=buffer2Length + 1;
121			}
122			else
123			{
124			buffer=null;
125			char tempCharacter[2]={10,0};
126			setString(tempCharacter, 1);
127			}
128			}
129
130			String(char iBuffer, int iBufferLength, char iBuffer2, int iBuffer2Length)
131			{
132			StringTools stringTools;
133
134			if (iBuffer!=null && iBuffer2!=null)
135			{
136			buffer=stringTools.addStringTwoString((char)iBuffer2, iBuffer2Length, (char)iBuffer, iBufferLength);
137			length=iBufferLength+iBuffer2Length;
138			}
139			else
140			{
141			buffer=null;
142			bool statement=false;
143
144			if (iBuffer!=null)
145			{
146			setString(iBuffer, iBufferLength);
147			statement=true;
148			}
149
150			if (iBuffer2!=null)
151			{
152			setString(iBuffer2, iBuffer2Length);
153			statement=true;
154			}
155
156			if (!statement)
157			{
158			buffer=null;
159			length=0;
160			}
161			}
162
163			}
164
165			~String()
166			{
167			if ( buffer != null )
168			{
169			free(buffer);
170			}
171			}
172
173			String operator+(int value)
174			{
175			return String(value, (char*)buffer, length);
176			}
177
178			String operator+(float value)
179			{
180			return String(value, (char*)buffer, length);
181			}
182
183			String operator+(const String &string)
184			{
185			return String((char)string.buffer, string.length, (char)buffer, length);
186			}
187
188			String operator+(String *string)
189			{
190			return String((char)string->buffer, string->length, (char)buffer, length);
191			}
192
193			String operator+(char* iBuffer)
194			{
195			StringTools stringTools;
196
197			return String((char)iBuffer, stringTools.sizeOfStringWithOutEndNull(iBuffer), (char)buffer, length);
198			}
199
200			String operator+(const NewRow &newRow)
201			{
202			return String(newRow, (char*)buffer, length);
203			}
204
205			String operator+(const char &iBuffer)
206			{
207			StringTools stringTools;
208
209			return String((char)iBuffer, stringTools.sizeOfStringWithOutEndNull((char)iBuffer), (char*)buffer, length);
210			}
211
212			void operator+=(int intValue)
213			{
214			Parse parse;
215			StringTools stringTools;
216
217
218			if (buffer!=null)
219			{
220			char *tBuffer=buffer;
221			int intLength=0;
222			char *tempBuffer=parse.intToString(intValue, &intLength);
223			buffer=stringTools.addStringTwoString((char)buffer, length, (char)tempBuffer, intLength);
224			length+=intLength;
225			free(tempBuffer);
226			free(tBuffer);
227			}
228			else
229			{
230			buffer=parse.intToString(intValue, &length);
231			}
232			}
233
234			void operator+=(float floatValue)
235			{
236			Parse parse;
237			StringTools stringTools;
238
239			if (buffer!=null)
240			{
241			char *tBuffer=buffer;
242			int floatLength=0;
243			char *tempBuffer=parse.floatToString(floatValue, &floatLength);
244			buffer=stringTools.addStringTwoString((char)buffer, length, (char)tempBuffer, floatLength);
245			length+=floatLength;
246			free(tempBuffer);
247			free(tBuffer);
248			}
249			else
250			{
251			buffer=parse.floatToString(floatValue, &length);
252			}
253			}
254
255			void operator+=(const String &string)
256			{
257			copyBuffer(string.buffer, string.length);
258			}
259
260			void operator+=(String * string)
261			{
262			copyBuffer(string->buffer, string->length);
263			}
264
265			void operator+=(char* iBuffer)
266			{
267			StringTools stringTools;
268
269			copyBuffer(iBuffer, stringTools.sizeOfStringWithOutEndNull(iBuffer));
270			}
271
272			void copyBuffer(char *iBuffer, int iBufferLength)
273			{
274			StringTools stringTools;
275
276			if (buffer!=null)
277			{
278			if (iBuffer != null )
279			{
280			char *tBuffer=buffer;
281			buffer=stringTools.addStringTwoString((char)buffer, length, (char)iBuffer, iBufferLength);
282			length+=iBufferLength;
283			free(tBuffer);
284			}
285			}
286			else
287			{
288			if (iBuffer != null)
289			{
290			setString(iBuffer, iBufferLength);
291			}
292			}
293			}
294
295			void operator+=(const NewRow &newRow)
296			{
297			StringTools stringTools;
298
299			if (buffer!=null)
300			{
301			char *tBuffer=buffer;
302			char tempCharacter[2]={10,0};
303			buffer=stringTools.addStringTwoString((char)buffer, length, (char)tempCharacter, 1);
304			length=1;
305			free(tBuffer);
306			}
307			else
308			{
309			char tempCharacter[2]={10,0};
310			setString(tempCharacter, 1);
311			}
312			}
313
314			void operator+=(const char character)
315			{
316			StringTools stringTools;
317
318			if (buffer!=null)
319			{
320			char *tBuffer=buffer;
321			char tempCharacter[2]={0,0};
322			tempCharacter[0]=character;
323			buffer=stringTools.addStringTwoString((char)buffer, length, (char)tempCharacter, 1);
324			length=1;
325			free(tBuffer);
326			}
327			else
328			{
329			char tempCharacter[2]={0,0};
330			tempCharacter[0]=character;
331			setString(tempCharacter, 1);
332			}
333			}
334
335			void removeCharacter(int index)
336			{
337			if (index >= 0 && index < length )
338			{
339			--length;
340
341			if (length > 0)
342			{
343			for ( int i=0; i<length ; i++ )
344			{
345			if ( i >= index )
346			{
347			buffer[i]=buffer[i+1];
348			}
349			}
350			}
351			else
352			{
353			if (buffer!=null)
354			{
355			free(buffer);
356			buffer=null;
357			}
358			}
359			}
360			}
361
362			void replaceCharacter(const char replace, const char remove)
363			{
364			if (buffer!=null)
365			{
366			for ( int i=0; i<length ; i++ )
367			{
368			if (buffer[i]==remove)
369			{
370			buffer[i]=replace;
371			}
372			}
373			}
374			}
375
376			int toInt()
377			{
378			Parse parse;
379
380			return parse.stringToInt(buffer);
381			}
382
383			float toFloat()
384			{
385			Parse parse;
386
387			return parse.stringToFloat(buffer);
388			}
389
390			bool equals(const String &string)
391			{
392			StringTools stringTools;
393
394			return stringTools.compareString(buffer, string.buffer);
395			}
396
397			bool equals(char *iBuffer)
398			{
399			StringTools stringTools;
400
401			return stringTools.compareString(buffer, iBuffer);
402			}
403
404			void setString(const String &string)
405			{
406			setString(string.buffer, string.length);
407			}
408
409			void setString(String *string)
410			{
411			if (string!=null)
412			{
413			setString(string->buffer, string->length);
414			}
415			}
416
417			void setString(char *iBuffer)
418			{
419			StringTools stringTools;
420
421			if (buffer!=null)
422			{
423			free(buffer);
424			buffer=null;
425			}
426
427			if (iBuffer != null)
428			{
429			length=stringTools.sizeOfStringWithOutEndNull(iBuffer);
430			buffer=(char)malloc((sizeof(char)length)+sizeof(char));
431			stringTools.copyString(iBuffer, length, buffer);
432			}
433			}
434
435			void setString(char *iBuffer, int iBufferLength)
436			{
437			StringTools stringTools;
438
439			if (buffer!=null)
440			{
441			free(buffer);
442			buffer=null;
443			}
444
445			if (iBuffer != null)
446			{
447			length=iBufferLength;
448			buffer=(char)malloc(sizeof(char)length+sizeof(char));
449			stringTools.copyString(iBuffer, length, buffer);
450			}
451			}
452
453			void cutTheBack(char character)
454			{
455			StringTools stringTools;
456
457			buffer=stringTools.cutTheBack(buffer, &length, character);
458			}
459
460			void cutTheBegining(char character)
461			{
462			StringTools stringTools;
463
464			buffer=stringTools.cutTheBegining(buffer, &length, character);
465			}
466
467			int socketSend(int socket)
468			{
469			NetWorkTools netWorkTools;
470			return netWorkTools.sendData(socket,buffer,length);
471			}
472
473			bool isBackPartEqualTo(char *fileFormat)
474			{
475			StringTools stringTools;
476
477			return stringTools.checkBack(buffer,length,fileFormat,stringTools.sizeOfStringWithOutEndNull(fileFormat));
478			}
479
480			bool isFrontPartEqualTo(char *fileFormat)
481			{
482			StringTools stringTools;
483
484			return stringTools.checkFront(buffer, length, fileFormat, stringTools.sizeOfStringWithOutEndNull(fileFormat));
485			}
486
487			int writeToFile(const String &fileName)
488			{
489			return writeToFile(fileName.buffer);
490			}
491
492			int writeToFileEnd(const String &fileName)
493			{
494			return writeToFileEnd(fileName.buffer);
495			}
496
497			int writelnToFileEnd(const String &fileName)
498			{
499			StringTools stringTools;
500
501			int fileStatus=0;
502
503			if (buffer!=null)
504			{
505			char tempCharacter[2]={10,0};
506			char newBuffer=stringTools.addStringTwoString((char)buffer, length, (char*)tempCharacter, 1);
507			fileStatus=writeToFileEnd(fileName.buffer,newBuffer, length+1);
508			free(newBuffer);
509			}
510
511			return fileStatus;
512			}
513
514			int writeToFile(char *fileName)
515			{
516			FileTools fileTools;
517
518			int fileStatus=0;
519
520			if (buffer!=null)
521			{
522			fileStatus=fileTools.writeFile(fileName,(char*)buffer,length);
523			}
524
525			return fileStatus;
526			}
527
528			int writeToFileEnd(char *fileName)
529			{
530			FileTools fileTools;
531
532			int fileStatus=0;
533
534			if (buffer!=null)
535			{
536			fileStatus=fileTools.writeToFileEnd(fileName,(char*)buffer,length);
537			}
538
539			return fileStatus;
540			}
541
542			int writeToFileEnd(char fileName, char newBuffer, int newLength)
543			{
544			FileTools fileTools;
545
546			int fileStatus=0;
547
548			if (buffer!=null)
549			{
550			fileStatus=fileTools.writeToFileEnd(fileName,(char*)newBuffer,newLength);
551			}
552
553			return fileStatus;
554			}
555
556
557			int readFile(char *fileName)
558			{
559			if (buffer!=null)
560			{
561			free(buffer);
562			buffer=null;
563			}
564
565			int fileBuffer=0;
566
567			FileTools fileTools;
568
569			// int fileStatus=FileTools::readStringFile(fileName,&fileBuffer,&length);
570			int fileStatus=fileTools.readStringFile(fileName,&fileBuffer,&length);
571			buffer=(char*)fileBuffer;
572
573			return fileStatus;
574			}
575
576			bool isNull()
577			{
578			if (buffer==null)
579			{
580			return true;
581			}
582
583			return false;
584			}
585
586			bool theFilePathIsNotUnder(String &filePath)
587			{
588			StringTools stringTools;
589
590			return stringTools.theFilePathIsNotUnder(buffer,length, filePath.buffer, filePath.length);
591			}
592
593
594			char* buffer;
595			String *string;
596			int length;
597
598			private:
599
600			};
601
602
603			#endif