📄 api_string.cpp
字号:
{
Remove(0, n);
}
}
return( n );
}
///////////////////////////////////////////////////////////
// //
// //
// //
///////////////////////////////////////////////////////////
//---------------------------------------------------------
int CSG_String::Find(SG_Char Character, bool fromEnd)
{
return( m_pString->Find(Character, fromEnd) );
}
//---------------------------------------------------------
int CSG_String::Find(const SG_Char *String)
{
return( m_pString->Find(String) );
}
//---------------------------------------------------------
bool CSG_String::Contains(const SG_Char *String)
{
return( m_pString->Contains(String) );
}
///////////////////////////////////////////////////////////
// //
// //
// //
///////////////////////////////////////////////////////////
//---------------------------------------------------------
CSG_String CSG_String::AfterFirst(SG_Char Character) const
{
return( CSG_String(m_pString->AfterFirst(Character).c_str()) );
}
//---------------------------------------------------------
CSG_String CSG_String::AfterLast(SG_Char Character) const
{
return( CSG_String(m_pString->AfterLast(Character).c_str()) );
}
//---------------------------------------------------------
CSG_String CSG_String::BeforeFirst(SG_Char Character) const
{
return( CSG_String(m_pString->BeforeFirst(Character).c_str()) );
}
//---------------------------------------------------------
CSG_String CSG_String::BeforeLast(SG_Char Character) const
{
return( CSG_String(m_pString->BeforeLast(Character).c_str()) );
}
///////////////////////////////////////////////////////////
// //
// //
// //
///////////////////////////////////////////////////////////
//---------------------------------------------------------
CSG_String CSG_String::Right(size_t count) const
{
return( CSG_String(m_pString->Right(count).c_str()) );
}
//---------------------------------------------------------
CSG_String CSG_String::Mid(size_t first, size_t count) const
{
return( CSG_String(m_pString->Mid(first, count).c_str()) );
}
//---------------------------------------------------------
CSG_String CSG_String::Left(size_t count) const
{
return( CSG_String(m_pString->Left(count).c_str()) );
}
///////////////////////////////////////////////////////////
// //
// //
// //
///////////////////////////////////////////////////////////
//---------------------------------------------------------
int CSG_String::asInt(void) const
{
int Value = 0;
asInt(Value);
return( Value );
// return( asInt(Value) ? Value : 0 );
}
bool CSG_String::asInt(int &Value) const
{
long lValue;
if( m_pString->ToLong(&lValue) )
{
Value = (int)lValue;
return( true );
}
Value = (int)lValue;
return( false );
}
//---------------------------------------------------------
double CSG_String::asDouble(void) const
{
double Value = 0.0;
asDouble(Value);
return( Value );
// return( asDouble(Value) ? Value : 0.0 );
}
bool CSG_String::asDouble(double &Value) const
{
return( m_pString->ToDouble(&Value) );
}
///////////////////////////////////////////////////////////
// //
// //
// //
///////////////////////////////////////////////////////////
//---------------------------------------------------------
CSG_Strings::CSG_Strings(void)
{
m_nStrings = 0;
m_Strings = NULL;
}
//---------------------------------------------------------
CSG_Strings::CSG_Strings(const CSG_Strings &Strings)
{
m_nStrings = 0;
m_Strings = NULL;
Assign(Strings);
}
//---------------------------------------------------------
CSG_Strings::CSG_Strings(int nStrings, const SG_Char **Strings)
{
m_nStrings = 0;
m_Strings = NULL;
for(int i=0; i<m_nStrings; i++)
{
Add(Strings[i]);
}
}
//---------------------------------------------------------
CSG_Strings::~CSG_Strings(void)
{
Clear();
}
//---------------------------------------------------------
void CSG_Strings::Clear(void)
{
for(int i=0; i<m_nStrings; i++)
{
delete(m_Strings[i]);
}
if( m_Strings )
{
SG_Free(m_Strings);
}
m_nStrings = 0;
m_Strings = NULL;
}
//---------------------------------------------------------
bool CSG_Strings::Assign(const CSG_Strings &Strings)
{
Clear();
for(int i=0; i<m_nStrings; i++)
{
Add(Strings[i]);
}
return( true );
}
//---------------------------------------------------------
CSG_Strings & CSG_Strings::operator = (const CSG_Strings &Strings)
{
Assign(Strings);
return( *this );
}
//---------------------------------------------------------
bool CSG_Strings::Add(const CSG_String &String)
{
m_Strings = (CSG_String **)SG_Realloc(m_Strings, (m_nStrings + 1) * sizeof(CSG_String *));
m_Strings[m_nStrings] = new CSG_String(String);
m_nStrings++;
return( true );
}
//---------------------------------------------------------
bool CSG_Strings::Set_Count(int nStrings)
{
Clear();
for(int i=0; i<m_nStrings; i++)
{
Add(SG_T(""));
}
return( true );
}
///////////////////////////////////////////////////////////
// //
// //
// //
///////////////////////////////////////////////////////////
//---------------------------------------------------------
CSG_String SG_Get_CurrentTimeStr(bool bWithDate)
{
CSG_String s;
wxDateTime t;
t.SetToCurrent();
if( bWithDate )
{
s.Append(t.FormatISODate());
s.Append(SG_T("/"));
}
s.Append(t.FormatISOTime());
return( s );
}
///////////////////////////////////////////////////////////
// //
// //
// //
///////////////////////////////////////////////////////////
//---------------------------------------------------------
CSG_String SG_Double_To_Degree(double Value)
{
SG_Char c;
int d, h;
double s;
CSG_String String;
if( Value < 0.0 )
{
Value = -Value;
c = SG_T('-');
}
else
{
c = SG_T('+');
}
Value = fmod(Value, 360.0);
d = (int)Value;
Value = 60.0 * (Value - d);
h = (int)Value;
Value = 60.0 * (Value - h);
s = Value;
String.Printf(SG_T("%c%03d\xb0%02d'%02f''"), c, d, h, s);
return( String );
}
//---------------------------------------------------------
double SG_Degree_To_Double(const SG_Char *String)
{
double d, h, s, sig;
CSG_String sVal(String);
sig = 1.0;
d = h = s = 0.0;
if( sVal.BeforeFirst('\xb0').asDouble(d) )
{
if( d < 0.0 )
{
sig = -1.0;
d = -d;
}
sVal.AfterFirst('\xb0' ).asDouble(h);
sVal.AfterFirst('\'').asDouble(s);
}
else
{
sVal.asDouble(d);
}
return( sig * (d + h / 60.0 + s / (60.0 * 60.0)) );
}
//---------------------------------------------------------
CSG_String SG_Double_To_Date(double Value)
{
int y, m, d;
y = (int)(Value / 10000); Value -= y * 10000;
m = (int)(Value / 100); Value -= m * 100;
d = (int)(Value / 1);
return( CSG_String::Format(SG_T("%02d.%02d.%04d"), d, m, y) );
}
//---------------------------------------------------------
double SG_Date_To_Double(const SG_Char *String)
{
int d, m, y;
if( String )
{
CSG_String s(String), sValue;
sValue = s.AfterLast ('.');
y = sValue.asInt();
sValue = s.BeforeLast ('.'); s = sValue;
sValue = s.AfterLast ('.');
m = sValue.asInt();
sValue = s.BeforeLast ('.'); s = sValue;
d = sValue.asInt();
if( d < 1 ) d = 1; else if( d > 31 ) d = 31;
if( m < 1 ) m = 1; else if( m > 12 ) d = 12;
return( 10000 * y + 100 * m + 1 * d );
}
return( 0.0 );
}
///////////////////////////////////////////////////////////
// //
// //
// //
///////////////////////////////////////////////////////////
//---------------------------------------------------------
int SG_Get_Significant_Decimals(double Value, int maxDecimals)
{
int Decimals;
double Reminder;
Value = fabs(Value);
for(Decimals=0; Decimals<maxDecimals; Decimals++)
{
Reminder = Value - (int)(Value);
if( Reminder == 0.0 )
{
return( Decimals );
}
Value = 10.0 * Value;
}
return( maxDecimals );
}
///////////////////////////////////////////////////////////
// //
// //
// //
///////////////////////////////////////////////////////////
//---------------------------------------------------------
CSG_String SG_Get_String(double Value, int Precision, bool bScientific)
{
CSG_String s;
s.Printf(SG_T("%.*f"), Precision, Value);
s.Replace(SG_T(","), SG_T("."));
return( s );
}
///////////////////////////////////////////////////////////
// //
// //
// //
///////////////////////////////////////////////////////////
//---------------------------------------------------------
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -