Gabriele Cosmo
366 lines
8.4 KiB
Plaintext
366 lines
8.4 KiB
Plaintext
//
|
|
// ********************************************************************
|
|
// * License and Disclaimer *
|
|
// * *
|
|
// * The Geant4 software is copyright of the Copyright Holders of *
|
|
// * the Geant4 Collaboration. It is provided under the terms and *
|
|
// * conditions of the Geant4 Software License, included in the file *
|
|
// * LICENSE and available at http://cern.ch/geant4/license . These *
|
|
// * include a list of copyright holders. *
|
|
// * *
|
|
// * Neither the authors of this software system, nor their employing *
|
|
// * institutes,nor the agencies providing financial support for this *
|
|
// * work make any representation or warranty, express or implied, *
|
|
// * regarding this software system or assume any liability for its *
|
|
// * use. Please see the license in the file LICENSE and URL above *
|
|
// * for the full disclaimer and the limitation of liability. *
|
|
// * *
|
|
// * This code implementation is the result of the scientific and *
|
|
// * technical work of the GEANT4 collaboration. *
|
|
// * By using, copying, modifying or distributing the software (or *
|
|
// * any work based on the software) you agree to acknowledge its *
|
|
// * use in resulting scientific publications, and indicate your *
|
|
// * acceptance of all terms of the Geant4 Software license. *
|
|
// ********************************************************************
|
|
//
|
|
// G4String inline methods implementation
|
|
//
|
|
// Author: G.Cosmo, 11 November 1999
|
|
//---------------------------------------------------------------------
|
|
|
|
inline G4String::G4String() {}
|
|
|
|
inline G4String::G4String(const char* astring)
|
|
: std_string(astring)
|
|
{}
|
|
|
|
inline G4String::G4String(const char* astring, str_size len)
|
|
: std_string(astring, len)
|
|
{}
|
|
|
|
inline G4String::G4String(char ch)
|
|
{
|
|
char str[2];
|
|
str[0] = ch;
|
|
str[1] = '\0';
|
|
std_string::operator=(str);
|
|
}
|
|
|
|
inline G4String::G4String(const G4String& str)
|
|
: std_string(str)
|
|
{}
|
|
|
|
inline G4String::G4String(const std::string& str)
|
|
: std_string(str)
|
|
{}
|
|
|
|
inline G4String& G4String::operator=(const G4String& str)
|
|
{
|
|
if(&str == this)
|
|
{
|
|
return *this;
|
|
}
|
|
std_string::operator=(str);
|
|
return *this;
|
|
}
|
|
|
|
inline G4String& G4String::operator=(const std::string& str)
|
|
{
|
|
std_string::operator=(str);
|
|
return *this;
|
|
}
|
|
|
|
inline G4String& G4String::operator=(const char* str)
|
|
{
|
|
std_string::operator=(str);
|
|
return *this;
|
|
}
|
|
|
|
// "cmp" optional parameter is NOT implemented !
|
|
// N.B.: The hash value returned is generally DIFFERENT from the
|
|
// one returned by the original RW function.
|
|
// Users should not rely on the specific return value.
|
|
//
|
|
inline char G4String::operator()(str_size i) const { return operator[](i); }
|
|
|
|
inline char& G4String::operator()(str_size i)
|
|
{
|
|
return std_string::operator[](i);
|
|
}
|
|
|
|
inline G4String G4String::operator()(str_size start, str_size extent)
|
|
{
|
|
return G4String(substr(start, extent));
|
|
}
|
|
|
|
inline G4String& G4String::operator+=(const char* str)
|
|
{
|
|
std_string::operator+=(str);
|
|
return *this;
|
|
}
|
|
|
|
inline G4String& G4String::operator+=(const std::string& str)
|
|
{
|
|
std_string::operator+=(str);
|
|
return *this;
|
|
}
|
|
|
|
inline G4String& G4String::operator+=(const char& ch)
|
|
{
|
|
std_string::operator+=(ch);
|
|
return *this;
|
|
}
|
|
|
|
inline G4bool G4String::operator==(const G4String& str) const
|
|
{
|
|
if(length() != str.length())
|
|
return false;
|
|
return (std_string::compare(str) == 0);
|
|
}
|
|
|
|
inline G4bool G4String::operator==(const char* str) const
|
|
{
|
|
return (std_string::compare(str) == 0);
|
|
}
|
|
|
|
inline G4bool G4String::operator!=(const G4String& str) const
|
|
{
|
|
return !(*this == str);
|
|
}
|
|
|
|
inline G4bool G4String::operator!=(const char* str) const
|
|
{
|
|
return !(*this == str);
|
|
}
|
|
|
|
inline G4String::operator const char*() const { return c_str(); }
|
|
|
|
inline G4int G4String::strcasecompare(const char* s1, const char* s2) const
|
|
{
|
|
char* buf1 = new char[strlen(s1) + 1];
|
|
char* buf2 = new char[strlen(s2) + 1];
|
|
|
|
for(str_size i = 0; i <= strlen(s1); ++i)
|
|
{
|
|
buf1[i] = tolower(char(s1[i]));
|
|
}
|
|
for(str_size j = 0; j <= strlen(s2); ++j)
|
|
{
|
|
buf2[j] = tolower(char(s2[j]));
|
|
}
|
|
|
|
G4int res = strcmp(buf1, buf2);
|
|
delete[] buf1;
|
|
delete[] buf2;
|
|
return res;
|
|
}
|
|
|
|
inline G4int G4String::compareTo(const char* str, caseCompare mode) const
|
|
{
|
|
return (mode == exact) ? strcmp(c_str(), str) : strcasecompare(c_str(), str);
|
|
}
|
|
|
|
inline G4int G4String::compareTo(const G4String& str, caseCompare mode) const
|
|
{
|
|
return compareTo(str.c_str(), mode);
|
|
}
|
|
|
|
inline G4String& G4String::prepend(const char* str)
|
|
{
|
|
insert(0, str);
|
|
return *this;
|
|
}
|
|
|
|
inline G4String& G4String::append(const G4String& str)
|
|
{
|
|
std_string::operator+=(str);
|
|
return *this;
|
|
}
|
|
|
|
inline std::istream& G4String::readLine(std::istream& strm, G4bool skipWhite)
|
|
{
|
|
char tmp[1024];
|
|
if(skipWhite)
|
|
{
|
|
strm >> std::ws;
|
|
strm.getline(tmp, 1024);
|
|
*this = tmp;
|
|
}
|
|
else
|
|
{
|
|
strm.getline(tmp, 1024);
|
|
*this = tmp;
|
|
}
|
|
return strm;
|
|
}
|
|
|
|
inline G4String& G4String::replace(unsigned int start, unsigned int nbytes,
|
|
const char* buff, unsigned int n2)
|
|
{
|
|
std_string::replace(start, nbytes, buff, n2);
|
|
return *this;
|
|
}
|
|
|
|
inline G4String& G4String::replace(str_size pos, str_size n, const char* str)
|
|
{
|
|
std_string::replace(pos, n, str);
|
|
return *this;
|
|
}
|
|
|
|
inline G4String& G4String::remove(str_size n)
|
|
{
|
|
if(n < size())
|
|
{
|
|
erase(n, size() - n);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
inline G4String& G4String::remove(str_size pos, str_size N)
|
|
{
|
|
erase(pos, N + pos);
|
|
return *this;
|
|
}
|
|
|
|
inline std::size_t G4String::first(char ch) const { return find(ch); }
|
|
|
|
inline std::size_t G4String::last(char ch) const { return rfind(ch); }
|
|
|
|
inline G4bool G4String::contains(const std::string& str) const
|
|
{
|
|
return (std_string::find(str) != std_string::npos);
|
|
}
|
|
|
|
inline G4bool G4String::contains(char ch) const
|
|
{
|
|
return (std_string::find(ch) != std_string::npos);
|
|
}
|
|
|
|
inline G4String G4String::strip(G4int strip_Type, char ch)
|
|
{
|
|
G4String retVal = *this;
|
|
if(length() == 0)
|
|
{
|
|
return retVal;
|
|
}
|
|
str_size i = 0;
|
|
switch(strip_Type)
|
|
{
|
|
case leading:
|
|
{
|
|
for(i = 0; i < length(); ++i)
|
|
{
|
|
if(std_string::operator[](i) != ch)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
retVal = substr(i, length() - i);
|
|
}
|
|
break;
|
|
case trailing:
|
|
{
|
|
G4int j = 0;
|
|
for(j = G4int(length() - 1); j >= 0; --j)
|
|
{
|
|
if(std_string::operator[](j) != ch)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
retVal = substr(0, j + 1);
|
|
}
|
|
break;
|
|
case both:
|
|
{
|
|
for(i = 0; i < length(); ++i)
|
|
{
|
|
if(std_string::operator[](i) != ch)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
G4String tmp(substr(i, length() - i));
|
|
G4int k = 0;
|
|
for(k = G4int(tmp.length() - 1); k >= 0; --k)
|
|
{
|
|
if(tmp.std_string::operator[](k) != ch)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
retVal = tmp.substr(0, k + 1);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return retVal;
|
|
}
|
|
|
|
inline void G4String::toLower()
|
|
{
|
|
for(str_size i = 0; i < size(); ++i)
|
|
{
|
|
// GB:HP-UX-aCC,Linux-KCC
|
|
std_string::operator[](i) = tolower(char(std_string::operator[](i)));
|
|
// at(i) = tolower(at(i));
|
|
}
|
|
}
|
|
|
|
inline void G4String::toUpper()
|
|
{
|
|
for(str_size i = 0; i < size(); ++i)
|
|
{
|
|
// GB:HP-UX-aCC,Linux-KCC
|
|
std_string::operator[](i) = toupper(char(std_string::operator[](i)));
|
|
// at(i) = toupper(at(i));
|
|
}
|
|
}
|
|
|
|
inline G4bool G4String::isNull() const { return empty(); }
|
|
|
|
// "caseCompare" optional parameter is NOT implemented !
|
|
//
|
|
inline str_size G4String::index(const G4String& str, str_size ln, str_size st,
|
|
G4String::caseCompare) const
|
|
{
|
|
return std_string::find(str.c_str(), st, ln);
|
|
}
|
|
|
|
inline str_size G4String::index(const char* str, G4int pos) const
|
|
{
|
|
return std_string::find(str, pos);
|
|
}
|
|
|
|
inline str_size G4String::index(char ch, G4int pos) const
|
|
{
|
|
return std_string::find(ch, pos);
|
|
}
|
|
|
|
inline const char* G4String::data() const { return c_str(); }
|
|
|
|
inline unsigned int G4String::hash(caseCompare) const
|
|
{
|
|
const char* str = c_str();
|
|
unsigned long h = 0;
|
|
for(; *str; ++str)
|
|
{
|
|
h = 5 * h + *str;
|
|
}
|
|
|
|
return str_size(h);
|
|
}
|
|
|
|
inline unsigned int G4String::stlhash() const
|
|
{
|
|
const char* str = c_str();
|
|
unsigned long h = 0;
|
|
for(; *str; ++str)
|
|
{
|
|
h = 5 * h + *str;
|
|
}
|
|
|
|
return str_size(h);
|
|
}
|