Strings In United Bot
I have a string class which I have been developing for a year, it is very advanced amd could be used in United Bot, for example in Kicking a bot you just type kick Magnus instead of the whole "[United Bot] Magnus rocks etc etc etc (Skill=Infinity).
Here i have posted it:
Code:
/*--------------------------------------------------------------------
String Class
For the Ease of Use of the String functions.
Incorporates the String Functions into an
object oriented design.
Author: Jamal Abid; 16; Oman.
//As of 12th December 2003, I became 17
//Yay.
Nationality: Pakistani;
Update History: 17 June 2003 --Created
->Basic Declarations Added
->Barebones Structure erected
-->Basic String Operations can be performerd
-->Dont expect string.h level functionality, yet
->Optimized the structure
-->For efficiency.
-->For readability.
18 June 2003 --Adding Functionality
->Added the Split function
-->Allows you to split a string into two.
-->You may even pass through again to split it
into many, many parts
24 June 2003 --More Functionality
->Added the print function
--> Allows you to print out the string in DOS
->Overloaded the - operator in two ways
-->One takes a string and wipes instances of that
String from the main string.
-->The other takes a char and deletes that char
once from the string and reports the place
-->NOTE: EXPERIMENTAL, NOT IMPLEMENTED IN THIS
RELEASE, JUST CONCEPTUALIZED!
27 June 2003 --A long day of programming...
->Overloaded the = operator to accept pointers to
chars(char arrays) also.
-->Created the Ctor private function to share
code between overloaded versions of the
constructor and the = function which both take
the same parameter and do the same thing...
->Fixed a major bug in the Split function which
rendered 50% of it useless; the second string
had a null character added to its first char,
which made sure it was always a null string.
->Partially implemented the operator - function;
rest will be completed later
-->Renamed it to Delete, it took more parameters
than the arity of the applicable operators
permitted
-->Enumerated the deletion type
->Whoops! The Print method was not needed, the
GetString function was present, must have
overlooked it...
->Created the Compare function
-->No more strcmp, Yay!
-->Compares Irrespective of case and/or
disregards punctuations if so desired.
-->Enumerated the compare type.
-->Added the FullCompare private function.
-->Added the CompareNoPunc private function.
->Added the Capitalize function.
->Added the MakeSmall function.
->Too Tired... Will do the Delete function later.
Oh Cozy bedroom.. where art thou?
28 June 2003 --Completion of basic structure
->Completed the Delete Function today
-->Now has three overloaded functions
--->One takes a string
--->The other takes a char array
--->And the last takes one char
->Removed 56 bugs!
-->These were the errors, things that stopped the
compilation, I am expecting LOTS of runtime
bugs as well
->Will optimize it tomorrow
-->Optimizing approx. 700 something lines of code
is no joke!
-> As of today, almost everything basic has been
coded
--> BUT Delete and Compare DONT WORK!
---> Trying to sort this out will probably take
a whole day to comb through this mess
---->Never write uncommented code
----->This has now been proven! It takes me a
few mins to make out what it is doing..
-> Started Commenting the whole code today
--> YUCK!
29 June 2003 --MAJOR Debugging
->I do not want to comment any further; will do so
later when the class is stable and works
->Now everything runs
-->But there are bugs to be ironed out
--->Compare and delete dont work fully
--->I am trying to fix them.
---->But i think this will take two days...
->The Progress of Fixing (I will write as I fix)
-->Fixed the full compare, now it actually does
compare... 3 bugs were working together to
mess up the result...
-->The problems in delete werent as severe and
hard to track as i thought, fixed the delete,
now it does what its supposed to. Yay!
--->Just found a small bug, gonna fix it NOW.
---->FIXED!!!
-->Now fixed the ALL Part, the Once part remains
30 June 2003 --More Debugging
->Fixed the ALL part of Delete
->I cant get the Delete(String) to work...
-->I am trying to find a way to make sure the
whole string exists.
-->It is not impossible but expect it to be
memory intensive, with many string objects
flying around, especially in the ALL part
->Added the CalcLen private function
-->Calculates the length of a string
-->string.h is not needed now!!
->Made the String(Len) constructor private
1 July 2003 --Its gone too far
->I am taking a two day break, no more work for
today and tomorrow
-->That does NOT mean I wont be touching the code
-->I will be going through it, every now and then
-->But I WONT make any modifications
--->I will just note the problems down and worry
about them later.
->Forget about the break, I am working again
->Now implmented and prefected the functions which
make String.hpp independent
-->string.h now has no use if you want basic
functions
->Its time to optimize
-->I will keep you updated on the process
-->unsigned short int has now been replaced by
unsigned long int
--->Now you can make LONG strings
--->Enjoy!
-->The length is now stored on the free store
--->No big deal
--->The time consuming part was modifying all the
lines of code that want to take its value
---->Had to add ()s and *s to them
-->Now I am trying to get the code to use the
heap
2 July 2003 --The beginning of the End
->Now fully uses the heap.
->On to Optimization
-->Tried Compiling the new "heapified" code
118 ERRORS!!! Will take some time to
correct
-->Down to 20 errors...
-->Errors Gone, Let the optimization begin!
-->Uh oh! Forgot the freeing memory part
-->Will take some time(again...)
4 July 2003 --A day with no comments
->Been working all day yesterday, ironing out the
errors and optimizing, will be doing the
same thing today..
->I have a new design idea, if it works out,
string.h level functionality could be one step
closer in a week of coding. That is IF it works
out, I wil be testing it today and tomorrow
and probably start the actual implementation
on the day after tomorrow.
->Wrote the Find function, its a blast to work
with, enter a char, a start position and an
ending position for the search and tell it
how many of the same chars it finds to skip,
and it returns the position of that char
Cool eh?
6 July --Delays and problems
->Went out with family day before yesterday,
little time for coding
->Yesterday the PC refused to boot, on further
ivestigation I found out it had blown its
Power box, got a new one fitted, no coding
done yesterday.
->Today, the Delete Engine shall be completely
overhauled -IF IT IS NOT EFFICIENT-
7 July --Getting back into the groove
->The new Delete Engine Concept works and is more
efficient and faster than before, not to mention
cleaner.
->Now I am going to complete another part of the
delete engine.
8 July --Trying hard to get back into the groove
->Had to go out with family yesterday, again.
->Work is going slow, I hope it picks up pace
->Delete was never so CLEAN!!
->Implementing the concept further...
->Delete is causing a LOT of problems, I hope it
works soon...
9 July --Programming Delays
->Went out again yesterday.
->Will have to go out tomorrow again.
->Today I am trying to squeeze in as much
programming as my hands and eyes allow.
->Find has a nasty bug which I cannot find and
is messing every dependent function up...
-->Will probably start from scratch, again
-->But I wont change the parameters and return
type they are the best possible
->Am going to change the whole structure from
C++ Style zero style [] operators to 1 style
for example the first element from now on
will not be [0] but [1], this is done to make
the class easier and more natural to use.
10 July --Relief, At Last!
->I fixed the bug in find which messed delete up
it took more than three days to track it down,
but its fixed, actually it was a compound bug
helped by no less than 4 lines of code, all of
them equally guilty!
->Still thinking about whether to convert the
structure to 1 style...
->Delete All still doesnt work!!
11 July --oh great
->Went out yesterday TWO TIMES!
->Luckily, I have two days today and tomorrow
before we go out again...
->The problem was also with delete(offset), I
fixed that too... Now on to delete(all), once
seems to work fine...
->Fixed the Delete, now everything works!
->I can FINALLY start focusing on adding
functionality
->I have an append function in mind, lets see
how that works out...
12 July --Bad Code
->I am having the worst case of code-rot possible,
all my functions which worked fine just a
fortnight ago, now have all simultaneously
broken down, I am fixing them one by one
-->I think what has happened is that my changing
of the basic Engine, has invalidated the
old calls, causing a major break-down
--->But the shocking thing is that there were
no compiler errors...
-->This may be shocking but I think I'll need
a week to fix this mess, its the biggest
I've ever seen.
-->I fixed the problem, whew. It was'nt any
engine malfunctions, just a flawed concept,
let me take a few lines to explain...
--->You see when I coded the operator+ function,
GetString was non-existent, so I used a loop
to get the data, which worked, due to a little
glitch, a null was added in between the two
concatenated strings, literally ending the
string! I fixed it, it took a lot of
debugging with a lot of variable watching
but its done...
-->I can now (again) concentrate on adding more
features
-->NEW FEATURES!!
--->GetPartial gets the string from a start
position to an end position, neat eh?
--->Overloaded + operator now can take quite a
load now, whereas before only String
Addidtion was possible, now you can add
C style strings AND chars.
--->I have stumbled upon a technique which makes
code super-efficient, maybe with further
testing I may be able to implement it.
13 July 2003 --Adding Polish
->Did some tweaking here and there to polish up
the code.
19 December 2003 --Long time no see++
->WOW! 6 months with no C++, i forgot everything
about the language
-->Am trying to recover and start work on project
again
->Fixed the operator+= function
-->It didnt actually add....
-->Dont know how i did it, but i did it
--->probably due to my completely forgetting
about the C++ Language
->Completed the GetPartial Function
-->Renamed it to GetString
--->Now it is an overloaded function
--->It is a part of my plans to overload all the
GetStrings to operator<<s
->I have been reading through my old comments and
somewhere i sid that it is going to take a week
to repair everything, it hs been six months and
the functions are so broken that the WHOLE delete
needs to rewritten, I have removed the old code
and am wroking on the new function
->There are a LOT of greatly flawed concepts here
-->There is only one way out, reanalyze, strip,
recode, test, repeat until done.
--->BUT! TOMORROW...
->Surprisingly, I havent coded a Find String
Function, will do
24 December 2003 --Christmas Eve
->Merry Christmas to all you Christians
->Compare NoPunc Fixed
->New functionality for Compare
-->Embodies all the features of the other compares
-->Is more Robust
->Find now works for strings
-->Uses a complex compare algorithm
-->Returns the position of first char of string
found.
-->Last char position can be worked out by the
user of the String Class by adding the
length of the String that was entered in the
find argument
25 December --Christmas
->Merry Christmas, again
->Stripped and modified a lot of functions
-->Mainly, Find and Delete
-->For the stripped functions the idea has been
penned and will be coded shortly
->There you have it, a spanking new, efficient,
350HP Beast that is Compare. Fully retooled to
perfection
26 December --IT COMPILES!
->After exactly one week of retooling, this
behemoth class actually compiles
->My heart cries whenever i see so many functions
that have no body or just return a dummy value
-->It is because they were inefficient,
malfunctioning (pun unintended)or just plain
bad screwed up
->A lot of redundant functions that have no use
now are lingering around like FullCompare,
CompareNoPunc and CompareNoCase.
-->A lot of code uses them so todays task is
adapting the rest of the code to work with
the new and improved engine
-->Done
27 December 2003--Find me a solution!
->Been working all day with the damned Find
-->Delete depends on it
->Will be testing today
->Code needs serious optimization
-->Maybe tomorrow
28 December 2003--Merry Bug Fix Day!
->I finally picked out the bug which was messing
the WHOLE CLASS up
-->It was in the Delete(ULI, ULI) function
-->It lead me to doubt my complex string
delete algorithm!
29 December 2003 --Big Changes
->Further development of the class now depends
on changing it from 0-style to 1-style
-->It may be easier or more difficult to use
depending on how much 0-style C++ Arrays
are hard-wired into your brain
-->But I am compelled to do it for a variety of
reasons
--->1.Returning no value found. What do find
find functions return if nothing is found?
0. So, zero should not be a valid position
--->2.It is more natural to the human brain
-->I am expecting 100% chaotic breakdown once i
do this
--->So i am waiting till the weekend (Thursday
and Friday over here) to do this dirty work
4 January 2004 --Of Men, Strings And War
->I am going to start the 1 style conversion
-->Let the battle begin!
-->I am making a backup, incase i mess this up
-->Better than rewriting this monster for a
second time!
--->I said rewriting for a second time which
writing for the third time!
Legal Stuff: (c) Jamal Abid 2003-Infinity (forever).
Terms and Conditions (License Agreement)
You CAN Modify this file BUT
->You have to give give credit to me AND any
previous modifiers who have their modifications
added to the file you receive.
->You have to add your own credits (so that any
future modifiers can include your name).
->Give full explanations of your modifications and
date them. You can use the layout used in the
author's comments
->You may not prevent someone else from having
the exact same rights as you.
-->That is you can not give more rights nor
deny them to future recipients of this file
You MAY NOT use this file in the following types
of programs
->Programs that are made for any department of the
Government of any country.
->In areas where the failure of this project can
incur heavy personal, financal or any other types
of losses.
->In projects which are illegal or help any other
illegal project as dictated by the laws of the
country in which this project is being worked on.
You MAY use this program in any other type of
projects (Yes, even commercial projects)
You MAY charge for a modified version of this program.
But you MAY NOT remove or modify this comment
block marked off and surrounded by ----s.
You can also not modify any of the other authors
comments, and you are not allowed to give the right
to others to modify your comment block. Doing so or
modifying these comments is a breach of the
copyright law and this will persecuted to the fullest
extent.
Added your comments in a different comment block
above or below this.
Also, I accept no liability for any losses, nor do I
demand any royalties or a share in the profit, this,
original , version of the file is free. Feel
free to report problems and suggestions etc. to
da_monster@hotmail.com
All rights not expressly granted are reserved by me,
Jamal Abid.
Please read the license before reading
any further, modifying or incorporating
this file. By reading further, modifying,
incorporating and by any means using or transmitting
this file you express that you have read the agreement
and agree to abide by its terms.
Also, I may create a new version of licese and it is
your responsibility to ask for the lastest version of
it. I have no liability or responsibility of notifying
any of the recipients of this file of the change in
license or in the file itself. The latest version of
the license will be enforced. I reserve the right to
make any changes to this license.
Any and all violations shall be persecuted under
the fullest extent of the law.
Report Violations at da_monster@hotmail.com
TO DO: Make Me on the heap and use references to access the
operator[] function.
--------------------------------------------------------------------*/
#include <iostream>
using namespace std;
typedef unsigned long int ULI;
class String
{
public:
String();
String(const char*);
String(const String&);
~String();
void Split(String&, String&, ULI);
bool Compare(const String&, bool, bool);
void Capitalize();
void MakeSmall();
char operator[](ULI) const; //For Data reading
char &operator[](ULI); //For Data writing
//const char *operator<<();
String operator+(const String&);
String operator+(const char*);
String operator+(char);
void operator+=(const String&);
void Delete(const String&, bool, bool, bool, ULI);
void Delete(const char*, bool, bool, bool, ULI);
void Delete(ULI, ULI);
void Delete(ULI);
String &operator=(const String&);
String &operator=(const char*);
ULI GetLen() const;
String GetString(ULI, ULI) const;
const char *GetString() const; //Use this to get the string, for now
ULI Find(char, ULI, ULI, ULI);
ULI Find(const char*, ULI, ULI, bool, bool, ULI);
ULI Find(const String&, ULI, ULI, bool, bool, ULI);
private:
String(ULI Len);
void Ctor(const char*);
void DeletePunc();
ULI CalcLen(const char*) const;
char *itsString;
ULI *itsLen;
};
String::String()
{
itsString=new char[1];
itsString[0]='\0';
itsLen=new ULI(0);
}
String::String(const char *TheString)
{
itsLen=new ULI(0);
Ctor(TheString);
}
String::String(const String &TheString)
{
itsLen=new ULI(TheString.GetLen());
itsString=new char[(*itsLen)+1];
ULI *i=new ULI(0);
for (*i=0; (*i)<(*itsLen);(*i)++)
{
itsString[(*i)]=TheString[(*i)];
}
delete i;
itsString[GetLen()]='\0';
}
String::String(ULI Len)
{
itsString=new char[Len+1];
ULI *i=new ULI(0);
for (*i=0; (*i)<=Len; (*i)++)
{
itsString[(*i)]='\0';
}
delete i;
itsLen=new ULI(Len);
}
String::~String ()
{
delete[] itsString;
delete itsLen;
}
void String::Split(String &FirstString, String &SecondString, ULI Place)
{
ULI *i=new ULI(0);
const String &Me=*this;
String *FirstHeap=new String(Place);
String &First=*FirstHeap;
for((*i)=0; (*i)<(First.GetLen()); (*i)++)
{
First[(*i)]=Me[(*i)];
}
ULI *MyLen=new ULI(this->GetLen());
ULI *LenStringTwo=new ULI(((*MyLen)-Place));
String *SecondHeap=new String((*LenStringTwo)-1);
String &Second=*SecondHeap;
ULI *j=new ULI(0);
for((*j)=0; (*j)<(*LenStringTwo); (*i)++, (*j)++)
{
Second[(*j)]=Me[(*i)];
}
delete i;
delete j;
delete MyLen;
delete LenStringTwo;
FirstString=First;
SecondString=Second;
delete FirstHeap;
delete SecondHeap;
}
bool String::Compare(const String &TheString, bool CaseSensitive, bool PuncSensitive)
{
String *MeHeap=new String(*this);
String *CompareStringHeap=new String(TheString);
String &Me=*MeHeap;
String &CompareString=*CompareStringHeap;
ULI *MyLen=new ULI(Me.GetLen());
ULI *YourLen=new ULI(CompareString.GetLen());
bool Result=false;
if((*MyLen)==(*YourLen))
{
if(!CaseSensitive)
{
Me.Capitalize();
CompareString.Capitalize();
}
if(!PuncSensitive)
{
Me.DeletePunc();
CompareString.DeletePunc();
}
ULI *i=new ULI(0);
ULI *CharsCaught=new ULI(0);
for((*i)=0; (*i)<(*MyLen); (*i)++)
{
if(Me[(*i)]==TheString[(*i)])
{
(*CharsCaught)++;
}
}
if((*CharsCaught)==(*MyLen))
{
Result=true;
}
delete CharsCaught;
}
delete MeHeap;
delete CompareStringHeap;
return Result;
}
void String::Capitalize()
{
String *MeHeap=new String(*this);
String &Me=*MeHeap;
ULI *MyLen=new ULI(Me.GetLen());
char *Mine=new char('\0');
int *MyASCII=new int(0);
ULI *i=new ULI(0);
for(*i=0; (*i)<(*MyLen); (*i)++)
{
*Mine=Me[(*i)];
*MyASCII=int(*Mine);
if((*MyASCII)==97)
{
Me[(*i)]='A';
}
if((*MyASCII)==98)
{
Me[(*i)]='B';
}
if((*MyASCII)==99)
{
Me[(*i)]='C';
}
if((*MyASCII)==100)
{
Me[(*i)]='D';
}
if((*MyASCII)==101)
{
Me[(*i)]='E';
}
if((*MyASCII)==102)
{
Me[(*i)]='F';
}
if((*MyASCII)==103)
{
Me[(*i)]='G';
}
if((*MyASCII)==104)
{
Me[(*i)]='H';
}
if((*MyASCII)==105)
{
Me[(*i)]='I';
}
if((*MyASCII)==106)
{
Me[(*i)]='J';
}
if((*MyASCII)==107)
{
Me[(*i)]='K';
}
if((*MyASCII)==108)
{
Me[(*i)]='L';
}
if((*MyASCII)==109)
{
Me[(*i)]='M';
}
if((*MyASCII)==110)
{
Me[(*i)]='N';
}
if((*MyASCII)==111)
{
Me[(*i)]='O';
}
if((*MyASCII)==112)
{
Me[(*i)]='P';
}
if((*MyASCII)==113)
{
Me[(*i)]='Q';
}
if((*MyASCII)==114)
{
Me[(*i)]='R';
}
if((*MyASCII)==115)
{
Me[(*i)]='S';
}
if((*MyASCII)==116)
{
Me[(*i)]='T';
}
if((*MyASCII)==117)
{
Me[(*i)]='U';
}
if((*MyASCII)==118)
{
Me[(*i)]='V';
}
if((*MyASCII)==119)
{
Me[(*i)]='W';
}
if((*MyASCII)==120)
{
Me[(*i)]='X';
}
if((*MyASCII)==121)
{
Me[(*i)]='Y';
}
if((*MyASCII)==122)
{
Me[(*i)]='Z';
}
}
*this=Me;
delete MeHeap;
delete MyLen;
delete Mine;
delete MyASCII;
}
void String::MakeSmall()
{
String *MeHeap=new String(*this);
String &Me=*MeHeap;
ULI *MyLen=new ULI(Me.GetLen());
char *Mine=new char('\0');
int *MyASCII=new int(0);
ULI *i=new ULI(0);
for(*i=0; (*i)<(*MyLen); (*i)++)
{
*Mine=Me[(*i)];
*MyASCII=int(*Mine);
if((*MyASCII)==65)
{
Me[(*i)]='a';
}
if((*MyASCII)==66)
{
Me[(*i)]='b';
}
if((*MyASCII)==67)
{
Me[(*i)]='c';
}
if((*MyASCII)==68)
{
Me[(*i)]='d';
}
if((*MyASCII)==69)
{
Me[(*i)]='e';
}
if((*MyASCII)==70)
{
Me[(*i)]='f';
}
if((*MyASCII)==71)
{
Me[(*i)]='g';
}
if((*MyASCII)==72)
{
Me[(*i)]='h';
}
if((*MyASCII)==73)
{
Me[(*i)]='i';
}
if((*MyASCII)==74)
{
Me[(*i)]='j';
}
if((*MyASCII)==75)
{
Me[(*i)]='k';
}
if((*MyASCII)==76)
{
Me[(*i)]='l';
}
if((*MyASCII)==77)
{
Me[(*i)]='m';
}
if((*MyASCII)==78)
{
Me[(*i)]='n';
}
if((*MyASCII)==79)
{
Me[(*i)]='o';
}
if((*MyASCII)==80)
{
Me[(*i)]='p';
}
if((*MyASCII)==81)
{
Me[(*i)]='q';
}
if((*MyASCII)==82)
{
Me[(*i)]='r';
}
if((*MyASCII)==83)
{
Me[(*i)]='s';
}
if((*MyASCII)==84)
{
Me[(*i)]='t';
}
if((*MyASCII)==85)
{
Me[(*i)]='u';
}
if((*MyASCII)==86)
{
Me[(*i)]='v';
}
if((*MyASCII)==87)
{
Me[(*i)]='w';
}
if((*MyASCII)==88)
{
Me[(*i)]='x';
}
if((*MyASCII)==89)
{
Me[(*i)]='y';
}
if((*MyASCII)==90)
{
Me[(*i)]='z';
}
}
*this=Me;
delete MeHeap;
delete MyLen;
delete Mine;
delete MyASCII;
delete i;
}
char String::operator[](ULI Number) const
{
if (Number>(*itsLen))
{
return itsString[(*itsLen)];
}
else
{
return itsString[Number];
}
}
char &String::operator[](ULI Number)
{
if (Number>(*itsLen))
{
return itsString[(*itsLen)];
}
else
{
return itsString[Number];
}
}
/*
const char *String::operator<<()
{
return itsString;
}
*/
String String::operator+(const String &TheString)
{
String *MeHeap=new String(*this);
String &Me=*MeHeap;
ULI *TotalLen=new ULI(Me.GetLen()+TheString.GetLen());
String AddedString(*TotalLen);
delete TotalLen;
ULI *i=new ULI(0);
for(*i=0; (*i)<(Me.GetLen()-1); (*i)++)
{
AddedString[(*i)]=Me[(*i)];
}
delete MeHeap;
ULI *j=new ULI(0);
for(*j=0; (*j)<TheString.GetLen(); (*i)++, (*j)++)
{
AddedString[(*i)]=TheString[(*j)];
}
delete i;
delete j;
return AddedString;
}
String String::operator+(const char *CharString)
{
String *TheStringHeap=new String(*CharString);
String &TheString=*TheStringHeap;
String Return((*this)+CharString);
delete TheStringHeap;
return Return;
}
String String::operator+(char TheChar)
{
}
void String::operator+=(const String &TheString)
{
ULI *TheStringLen=new ULI(TheString.GetLen()-1);
ULI *MyLen=new ULI((*itsLen)-1);
ULI *TotalLen=new ULI((*MyLen)+(*TheStringLen));
String *NewStringHeap=new String((*TotalLen)+1);
String &NewString=*NewStringHeap;
ULI *i=new ULI(0);
ULI *j=new ULI(0);
for (*i=0; (*i)<(*MyLen); (*i)++)
{
NewString[(*i)]=itsString[(*i)];
}
for (*j=0; (*j)<(*TheStringLen); (*i)++, (*j)++)
{
NewString[(*i)]=TheString[(*j)];
}
NewString[(*TotalLen)]='\0';
*this=NewString;
delete TheStringLen;
delete MyLen;
delete TotalLen;
delete NewStringHeap;
delete i;
delete j;
}
void String::Delete(const String &TheString, bool CaseSensitive, bool PuncSensitive, bool All, ULI Skip)
{
//TODO: Find a way to ignore case and punctuation marks without
// actually altering the string.
//FOUND A WAY: USE THE FIND FUNCTION AND PASS THE PUNC AND CASE
// SENSITIVE ARGUMENTS OVER TO THE FIND FUNCTION AND
// ACT ON THAT
//PROBLEM WITH CONCEPT: PUNCTUATION CHANGES LENGTH HOW TO COMPUTE NEW
// LENGTH AND WHERE IS THE PUNCTUATION??
//TODO: Implement a skip feature also.
if(PuncSensitive)
{
String *Me=new String(*this);
String *DeleteString=new String(TheString);
ULI *StartPos=new ULI(0);
ULI *EndPos=new ULI(0);
if(All)
{
do
{
Delete(TheString, CaseSensitive, PuncSensitive,0, Skip);
}
while(!((*StartPos)==0)); //while a new string is found
}
else
{
*StartPos=Find(TheString, 0, Me->GetLen(), CaseSensitive, PuncSensitive, Skip);
*EndPos=((*StartPos)+TheString.GetLen())-2;
Delete(*StartPos, *EndPos);
}
delete StartPos;
delete EndPos;
delete Me;
delete DeleteString;
}
else
{
/*
//Pseudo Code: (for task understanding)
//Test Where the Punctuation is
//See by how the string changes
//
String *MeHeap=new String(*this);
String &Me=*MeHeap;
ULI *MyLen=new ULI(Me.GetLen());
Me.DeletePunc();
ULI *MyLenNoPunc=new ULI(Me.GetLen());
ULI *NoOfPuncs=new ULI((*MyLen)-(*MyLenNoPunc));
ULI *PuncPos=new ULI[(*NoOfPuncs)][2];
ULI *i=new ULI(0);
ULI *j=new ULI(0);
ULI *k=new ULI(0);
int *Type=new int(0);
ULI *Pos=new ULI(0);
for((*i)=0; (*i)<(*NoOfPuncs); (*i)++)
{
PuncPos[(*i)][0]=0;
PuncPos[(*i)[1]=0;
}
ULI *Skip=new ULI(0);
do
{
*Pos=Find(',', 0, Me.GetLen(), 1, 1, *Skip);
(*Skip)++;
*PuncPos[0][0]=
}
while(!((*Pos)==0));
delete Skip;
delete Type;
delete MeHeap;
delete MyLen;
delete MyLenNoPunc;
delete NoOfPuncs;
delete Pos;
delete i;
delete j;
delete k;
*/
}
}
void String::Delete(const char *TheString, bool CaseSensitive, bool PuncSensitive, bool All, ULI Skip)
{
String *NewString=new String(TheString);
Delete(*NewString, CaseSensitive, PuncSensitive, All, Skip);
delete NewString;
}
void String::Delete(ULI StartPos, ULI EndPos)
{
ULI *i=new ULI(StartPos);
ULI *j=new ULI(*i);
for((*i)=StartPos; (*i)<=EndPos; (*i)++)
{
Delete(*j);
}
delete i;
delete j;
}
String &String::operator=(const String &TheString)
{
if (this==&TheString)
{
return *this;
}
else
{
delete[] itsString;
delete itsLen;
itsLen=new ULI(TheString.GetLen());
itsString=new char[(*itsLen)+1];
ULI *i=new ULI(0);
for (*i=0; (*i)<(*itsLen); (*i)++)
{
itsString[(*i)]=TheString[(*i)];
}
itsString[(*itsLen)]='\0';
return *this;
delete i;
}
}
String &String::operator=(const char *CharArray)
{
delete[] itsString;
Ctor(CharArray);
}
ULI String::GetLen() const
{
return *itsLen;
}
String String::GetString(ULI StartPos, ULI EndPos) const
{
if(StartPos>EndPos)
{
String *MeHeap=new String(*this);
String &Me=*MeHeap;
String *PartialHeap=new String((EndPos-StartPos)+1);
String &Partial=*PartialHeap;
ULI *i=new ULI(StartPos-1);
for(*i=(StartPos-1); (*i)<(EndPos-1); (*i)++)
{
Partial[(*i)]=Me[(*i)];
}
delete MeHeap;
delete PartialHeap;
delete i;
return Partial;
}
else
{
return String("");
}
}
const char *String::GetString() const //OBSOLETE!! WILL BE DELETED SOON
{
return itsString;
}
void String::Ctor(const char *TheString)
{
*itsLen=CalcLen(TheString);
itsString=new char[(*itsLen)+1];
ULI *i=new ULI(0);
for (*i=0; (*i)<(*itsLen); (*i)++)
{
itsString[(*i)]=TheString[(*i)];
}
itsString[(*itsLen)]='\0';
delete i;
}
ULI String::CalcLen(const char *TheString) const
{
char *Null=new char('a');
ULI Counter=0;
while(!((*Null)=='\0'))
{
*Null=TheString[Counter];
++Counter;
}
delete Null;
return Counter;
}
ULI String::Find(char TheChar, ULI StartPos, ULI EndPos, ULI Skip)
{
String *MeHeap=new String(*this);
String &Me=*MeHeap;
ULI *MyLen=new ULI(Me.GetLen());
ULI *CharsCaught=new ULI(0);
ULI *Start=new ULI(StartPos-1);
ULI *Stop=new ULI(EndPos-1);
ULI *i=new ULI(*Start);
ULI Pos=0;
ULI *Prev=new ULI(Pos);
Skip++;
for((*i)=(*Start); (*i)<=(*Stop); (*i)++)
{
if(Me[(*i)]==TheChar)
{
if((*CharsCaught)<Skip)
{
Pos=*i;
++(*CharsCaught);
}
}
}
if((*CharsCaught)<=(Skip-1))
{
Pos=Me.GetLen();
}
delete Prev;
delete MeHeap;
delete MyLen;
delete CharsCaught;
delete i;
return Pos;
}
ULI String::Find(const String &TheString, ULI StartPos, ULI EndPos, bool CaseSensitive, bool PuncSensitive, ULI Skip)
{
String *MeHeap=new String(*this);
String &Me=*MeHeap;
String *FindStringHeap=new String(TheString);
String &FindString=*FindStringHeap;
ULI MyLen=Me.GetLen();
ULI TheStringLen=TheString.GetLen();
char MyChar='\0';
char TheStringChar='\0';
int i=0;
int j=0;
int Pos=0;
if(!CaseSensitive)
{
Me.Capitalize();
FindString.Capitalize();
}
for(i=0; i<MyLen; i++)
{
MyChar=Me[i];
TheStringChar=FindString[j];
if(MyChar==TheStringChar)
{
if(j==0) //If it is first char found, record its position
{
Pos=i;
}
j++;
}
else
{
j=0;
}
if(j==(TheStringLen/*-1*/))
{
if(Skip==0)
{
delete MeHeap;
delete FindStringHeap;
return Pos;
}
else
{
Skip--;
}
}
}
delete MeHeap;
delete FindStringHeap;
return 0;
}
ULI String::Find(const char *TheString, ULI StartPos, ULI EndPos, bool CaseSensitive, bool PuncSensitive, ULI Skip)
{
ULI Pos=0;
String *FindString=new String(TheString);
Pos=Find(*FindString, StartPos, EndPos, CaseSensitive, PuncSensitive, Skip);
delete FindString;
return Pos;
}
void String::Delete(ULI Pos)
{
String *MeHeap=new String(*this);
String &Me=*MeHeap;
String *NewStringHeap=new String(Me.GetLen()-1);
String &NewString=*NewStringHeap;
ULI *i=new ULI(0);
ULI *j=new ULI(0);
while((*i)<Pos)
{
NewString[(*i)]=Me[(*i)];
++(*i);
}
*j=*i;
(*i)++;
for(*j=(*i)-1; (*j)<Me.GetLen(); (*i)++, (*j)++)
{
NewString[(*j)]=Me[(*i)];
}
delete MeHeap;
*this=NewString;
delete NewStringHeap;
delete i;
delete j;
}
void String::DeletePunc()
{
this->Delete(',', 0, 0, 1, 0);
this->Delete('.', 0, 0, 1, 0);
this->Delete('\'', 0, 0, 1, 0);
this->Delete('-', 0, 0, 1, 0);
this->Delete('_', 0, 0, 1, 0);
this->Delete('\"', 0, 0, 1, 0);
this->Delete('(', 0, 0, 1, 0);
this->Delete(')', 0, 0, 1, 0);
this->Delete('?', 0, 0, 1, 0);
this->Delete('!', 0, 0, 1, 0);
this->Delete(',', 0, 0, 1, 0);
}
This is from a backup i took in January, the new version has most functions stripped out and is in the progress of streamlining so this backup is posted.
So is it of any use, i would be delighted to offer more snippets on anything, just tell me, i would like to give 100% of what i can offer to United Bot Development.:D
-Jamal |
