377 lines
13 KiB
MQL5
377 lines
13 KiB
MQL5
 | //+------------------------------------------------------------------+
| ||
//| String.mqh |
| |||
//| Copyright 2000-2025, MetaQuotes Ltd. |
| |||
//| https://www.mql5.com |
| |||
//+------------------------------------------------------------------+
| |||
#include <Object.mqh>
| |||
//+------------------------------------------------------------------+
| |||
//| Class CString. |
| |||
//| Appointment: Class-string. |
| |||
//| Derives from class CObject. |
| |||
//+------------------------------------------------------------------+
| |||
class CString : public CObject
| |||
{
| |||
protected:
| |||
string m_string;
| |||
| |||
public:
| |||
CString(void);
| |||
~CString(void);
| |||
//--- methods access
| |||
string Str(void) const { return(m_string); };
| |||
uint Len(void) const { return(StringLen(m_string)); };
| |||
void Copy(string ©) const;
| |||
void Copy(CString *copy) const;
| |||
//--- methods fill
| |||
bool Fill(const short character) { return(StringFill(m_string,character)); };
| |||
void Assign(const string str) { m_string=str; };
| |||
void Assign(const CString *str) { m_string=str.Str(); };
| |||
void Append(const string str);
| |||
void Append(const CString *str);
| |||
uint Insert(const uint pos,const string substring);
| |||
uint Insert(const uint pos,const CString *substring);
| |||
//--- methods compare
| |||
int Compare(const string str) const;
| |||
int Compare(const CString *str) const;
| |||
int CompareNoCase(const string str) const;
| |||
int CompareNoCase(const CString *str) const;
| |||
//--- methods prepare
| |||
string Left(const uint count) const;
| |||
string Right(const uint count) const;
| |||
string Mid(const uint pos,const uint count) const;
| |||
//--- methods truncation/deletion
| |||
int Trim(const string targets);
| |||
int TrimLeft(const string targets);
| |||
int TrimRight(const string targets);
| |||
bool Clear(void) { return(StringInit(m_string)); };
| |||
//--- methods conversion
| |||
bool ToUpper(void) { return(StringToUpper(m_string)); };
| |||
bool ToLower(void) { return(StringToLower(m_string)); };
| |||
void Reverse(void);
| |||
//--- methods find
| |||
int Find(const uint start,const string substring) const;
| |||
int FindRev(const string substring) const;
| |||
uint Remove(const string substring);
| |||
uint Replace(const string substring,const string newstring);
| |||
| |||
protected:
| |||
virtual int Compare(const CObject *node,const int mode=0) const;
| |||
};
| |||
//+------------------------------------------------------------------+
| |||
//| Constructor |
| |||
//+------------------------------------------------------------------+
| |||
CString::CString(void) : m_string("")
| |||
{
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Destructor |
| |||
//+------------------------------------------------------------------+
| |||
CString::~CString(void)
| |||
{
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Copy the string value member to copy |
| |||
//+------------------------------------------------------------------+
| |||
void CString::Copy(string ©) const
| |||
{
| |||
copy=m_string;
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Copy the string value member to copy |
| |||
//+------------------------------------------------------------------+
| |||
void CString::Copy(CString *copy) const
| |||
{
| |||
copy.Assign(m_string);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Add a string to the end |
| |||
//+------------------------------------------------------------------+
| |||
void CString::Append(const string str)
| |||
{
| |||
m_string+=str;
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Add a string to the end |
| |||
//+------------------------------------------------------------------+
| |||
void CString::Append(const CString *str)
| |||
{
| |||
//--- check
| |||
if(!CheckPointer(str))
| |||
return;
| |||
//---
| |||
m_string+=str.Str();
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Insert a string in specified position |
| |||
//+------------------------------------------------------------------+
| |||
uint CString::Insert(const uint pos,const string substring)
| |||
{
| |||
string tmp=StringSubstr(m_string,0,pos);
| |||
//---
| |||
tmp+=substring;
| |||
m_string=tmp+StringSubstr(m_string,pos);
| |||
//--- result
| |||
return(StringLen(m_string));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Insert a string in specified position |
| |||
//+------------------------------------------------------------------+
| |||
uint CString::Insert(const uint pos,const CString *substring)
| |||
{
| |||
//--- check
| |||
if(!CheckPointer(substring))
| |||
return(0);
| |||
//---
| |||
string tmp=StringSubstr(m_string,0,pos);
| |||
//---
| |||
tmp+=substring.Str();
| |||
m_string=tmp+StringSubstr(m_string,pos);
| |||
//--- result
| |||
return(StringLen(m_string));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Comparison with the string |
| |||
//+------------------------------------------------------------------+
| |||
int CString::Compare(const string str) const
| |||
{
| |||
if(m_string<str)
| |||
return(-1);
| |||
if(m_string>str)
| |||
return(1);
| |||
//--- equal
| |||
return(0);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Comparison with the string |
| |||
//+------------------------------------------------------------------+
| |||
int CString::Compare(const CString *str) const
| |||
{
| |||
//--- check
| |||
if(!CheckPointer(str))
| |||
return(0);
| |||
//---
| |||
if(m_string<str.Str())
| |||
return(-1);
| |||
if(m_string>str.Str())
| |||
return(1);
| |||
//--- equal
| |||
return(0);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Comparison with the string without case |
| |||
//+------------------------------------------------------------------+
| |||
int CString::CompareNoCase(const string str) const
| |||
{
| |||
string tmp1,tmp2;
| |||
//---
| |||
tmp1=m_string;
| |||
tmp2=str;
| |||
StringToLower(tmp1);
| |||
StringToLower(tmp2);
| |||
//---
| |||
if(tmp1<tmp2)
| |||
return(-1);
| |||
if(tmp1>tmp2)
| |||
return(1);
| |||
//--- equal
| |||
return(0);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Comparison with the string without case |
| |||
//+------------------------------------------------------------------+
| |||
int CString::CompareNoCase(const CString *str) const
| |||
{
| |||
string tmp1,tmp2;
| |||
//--- check
| |||
if(!CheckPointer(str))
| |||
return(0);
| |||
//---
| |||
tmp1=m_string;
| |||
tmp2=str.Str();
| |||
StringToLower(tmp1);
| |||
StringToLower(tmp2);
| |||
//---
| |||
if(tmp1<tmp2)
| |||
return(-1);
| |||
if(tmp1>tmp2)
| |||
return(1);
| |||
//--- equal
| |||
return(0);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Find occurrences of substring from the specified position |
| |||
//+------------------------------------------------------------------+
| |||
int CString::Find(const uint start,const string substring) const
| |||
{
| |||
return(StringFind(m_string,substring,start));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Find last occurrence of substring |
| |||
//+------------------------------------------------------------------+
| |||
int CString::FindRev(const string substring) const
| |||
{
| |||
int result,pos=-1;
| |||
//---
| |||
do
| |||
{
| |||
result=pos;
| |||
}
| |||
while((pos=StringFind(m_string,substring,pos+1))>=0);
| |||
//--- result
| |||
return(result);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Get a substring consisting of count elements of the left string |
| |||
//+------------------------------------------------------------------+
| |||
string CString::Left(const uint count) const
| |||
{
| |||
return(StringSubstr(m_string,0,count));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Get a substring consisting of count elements of the right string.|
| |||
//+------------------------------------------------------------------+
| |||
string CString::Right(const uint count) const
| |||
{
| |||
return(StringSubstr(m_string,StringLen(m_string)-count,count));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Get a substring consisting of count elements of the pos string |
| |||
//+------------------------------------------------------------------+
| |||
string CString::Mid(const uint pos,const uint count) const
| |||
{
| |||
return(StringSubstr(m_string,pos,count));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Remove from the string, all characters in the begin and |
| |||
//| in the end if they arein targets, or space, \t,\n or \r |
| |||
//+------------------------------------------------------------------+
| |||
int CString::Trim(const string targets)
| |||
{
| |||
return(TrimLeft(targets)+TrimRight(targets));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Remove from the string, all characters in the begin if they are |
| |||
//| in targets, or space, \t,\n or \r |
| |||
//+------------------------------------------------------------------+
| |||
int CString::TrimLeft(const string targets)
| |||
{
| |||
ushort ch;
| |||
//---
| |||
for(int i=0;i<StringLen(m_string);i++)
| |||
{
| |||
ch=StringGetCharacter(m_string,i);
| |||
if(ch<=' ')
| |||
continue;
| |||
for(int j=0;j<StringLen(targets);j++)
| |||
{
| |||
if(ch==StringGetCharacter(targets,j))
| |||
{
| |||
StringSetCharacter(m_string,i,' ');
| |||
ch=' ';
| |||
}
| |||
}
| |||
if(ch!=' ')
| |||
break;
| |||
}
| |||
//--- result
| |||
return(StringTrimLeft(m_string));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Remove from the string, all characters in the end if they are |
| |||
//| in targets, or space, \t,\n or \r |
| |||
//+------------------------------------------------------------------+
| |||
int CString::TrimRight(const string targets)
| |||
{
| |||
ushort ch;
| |||
//---
| |||
for(int i=StringLen(m_string)-1;i>=0;i--)
| |||
{
| |||
ch=StringGetCharacter(m_string,i);
| |||
if(ch<=' ')
| |||
continue;
| |||
for(int j=0;j<StringLen(targets);j++)
| |||
{
| |||
if(ch==StringGetCharacter(targets,j))
| |||
{
| |||
StringSetCharacter(m_string,i,' ');
| |||
ch=' ';
| |||
}
| |||
}
| |||
if(ch!=' ')
| |||
break;
| |||
}
| |||
//--- result
| |||
return(StringTrimRight(m_string));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Deploy the sequence of characters in a string |
| |||
//+------------------------------------------------------------------+
| |||
void CString::Reverse(void)
| |||
{
| |||
ushort ch;
| |||
int i,j;
| |||
//---
| |||
for(i=StringLen(m_string)-1,j=0;i>j;i--,j++)
| |||
{
| |||
ch=StringGetCharacter(m_string,i);
| |||
StringSetCharacter(m_string,i,StringGetCharacter(m_string,j));
| |||
StringSetCharacter(m_string,j,ch);
| |||
}
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Remove all occurrences of the substring |
| |||
//+------------------------------------------------------------------+
| |||
uint CString::Remove(const string substring)
| |||
{
| |||
int result=0,len,pos=-1;
| |||
string tmp;
| |||
//---
| |||
len=StringLen(substring);
| |||
while((pos=StringFind(m_string,substring,pos))>=0)
| |||
{
| |||
tmp=StringSubstr(m_string,0,pos);
| |||
m_string=tmp+StringSubstr(m_string,pos+len);
| |||
result++;
| |||
}
| |||
//--- result
| |||
return(result);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Replace all occurrences of a substring in the specified string |
| |||
//+------------------------------------------------------------------+
| |||
uint CString::Replace(const string substring,const string newstring)
| |||
{
| |||
int result=0,len,pos=-1;
| |||
string tmp;
| |||
//---
| |||
len=StringLen(substring);
| |||
while((pos=StringFind(m_string,substring,pos))>=0)
| |||
{
| |||
tmp=StringSubstr(m_string,0,pos)+newstring;
| |||
m_string=tmp+StringSubstr(m_string,pos+len);
| |||
// to eliminate possible loops
| |||
pos+=StringLen(newstring);
| |||
result++;
| |||
}
| |||
//--- result
| |||
return(result);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Comparison with the string by algorithm |
| |||
//+------------------------------------------------------------------+
| |||
int CString::Compare(const CObject *node,const int mode=0) const
| |||
{
| |||
CString *str=(CString*)node;
| |||
//--- check
| |||
if(str==NULL)
| |||
return(0);
| |||
//---
| |||
switch(mode)
| |||
{
| |||
case 0: return(Compare(str));
| |||
case 1: return(CompareNoCase(str));
| |||
}
| |||
//--- equal
| |||
return(0);
| |||
}
| |||
//+------------------------------------------------------------------+
|