Gabriele Cosmo
477 lines
10 KiB
Plaintext
477 lines
10 KiB
Plaintext
//
|
|
// ********************************************************************
|
|
// * DISCLAIMER *
|
|
// * *
|
|
// * The following disclaimer summarizes all the specific disclaimers *
|
|
// * of contributors to this software. The specific disclaimers,which *
|
|
// * govern, are listed with their locations in: *
|
|
// * http://cern.ch/geant4/license *
|
|
// * *
|
|
// * 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. *
|
|
// * *
|
|
// * This code implementation is the intellectual property of the *
|
|
// * GEANT4 collaboration. *
|
|
// * By copying, distributing or modifying the Program (or any work *
|
|
// * based on the Program) you indicate your acceptance of this *
|
|
// * statement, and all its terms. *
|
|
// ********************************************************************
|
|
//
|
|
//
|
|
// $Id: G4String.icc,v 1.4 2003/03/25 14:56:17 gcosmo Exp $
|
|
// GEANT4 tag $Name: geant4-05-01 $
|
|
//
|
|
//
|
|
//---------------------------------------------------------------
|
|
// GEANT 4 class implementation file
|
|
//
|
|
// G4String
|
|
//---------------------------------------------------------------
|
|
|
|
// **************************************************************
|
|
// G4SubString
|
|
// **************************************************************
|
|
|
|
G4SubString::G4SubString(const G4SubString&s)
|
|
{
|
|
mystring=s.mystring;
|
|
mystart=s.mystart;
|
|
extent=s.extent;
|
|
}
|
|
|
|
G4SubString::G4SubString(G4String& str, str_size s, str_size e)
|
|
: mystring(&str),mystart(s),extent(e)
|
|
{
|
|
}
|
|
|
|
G4SubString& G4SubString::operator=(const G4String&s)
|
|
{
|
|
G4String str(s);
|
|
return operator=(str);
|
|
}
|
|
|
|
G4SubString& G4SubString::operator=(const G4SubString&s)
|
|
{
|
|
mystring->replace(mystart,extent,s.mystring->data(),s.length());
|
|
extent=s.length();
|
|
return *this;
|
|
}
|
|
|
|
G4SubString& G4SubString::operator=(const char*s)
|
|
{
|
|
mystring->replace(mystart,extent,s,strlen(s));
|
|
extent=strlen(s);
|
|
return *this;
|
|
}
|
|
|
|
char& G4SubString::operator()(str_size i)
|
|
{
|
|
return mystring->operator[](mystart+i);
|
|
}
|
|
|
|
char G4SubString::operator()(str_size i) const
|
|
{
|
|
return mystring->operator[](mystart+i);
|
|
}
|
|
|
|
char& G4SubString::operator[](str_size i)
|
|
{
|
|
return mystring->operator[](mystart+i);
|
|
}
|
|
|
|
char G4SubString::operator[](str_size i) const
|
|
{
|
|
return mystring->operator[](mystart+i);
|
|
}
|
|
|
|
G4int G4SubString::operator!() const
|
|
{
|
|
return extent==0 ? 1 : 0;
|
|
}
|
|
|
|
G4bool G4SubString::operator==(G4String s) const
|
|
{
|
|
return mystring->substr(mystart,extent) == s ? true:false;
|
|
}
|
|
|
|
G4bool G4SubString::operator==(const char* s) const
|
|
{
|
|
return mystring->substr(mystart,extent) == G4std::string(s) ? true:false;
|
|
}
|
|
|
|
G4bool G4SubString::operator!=(G4String s) const
|
|
{
|
|
return mystring->substr(mystart,extent) != G4std::string(s) ? true:false;
|
|
}
|
|
|
|
G4bool G4SubString::operator!=(const char* s) const
|
|
{
|
|
return mystring->substr(mystart,extent) != G4std::string(s) ? true:false;
|
|
}
|
|
|
|
str_size G4SubString::length() const
|
|
{
|
|
return extent;
|
|
}
|
|
|
|
str_size G4SubString::start() const
|
|
{
|
|
return mystart;
|
|
}
|
|
|
|
G4bool G4SubString::isNull() const
|
|
{
|
|
return extent==0 ? true : false;
|
|
}
|
|
|
|
// **************************************************************
|
|
// G4String
|
|
// **************************************************************
|
|
|
|
G4String::G4String () {}
|
|
|
|
G4String::G4String ( const char * astring )
|
|
: std_string ( astring ) {}
|
|
|
|
G4String::G4String ( char c )
|
|
{
|
|
char str[2];
|
|
str[0]=c;
|
|
str[1]='\0';
|
|
std_string::operator=(str);
|
|
}
|
|
|
|
G4String::G4String ( const G4String& s )
|
|
: std_string(s) {}
|
|
|
|
G4String::G4String ( const G4SubString& s )
|
|
: std_string(*(s.mystring),s.mystart,s.extent) {}
|
|
|
|
G4String::G4String ( const G4std::string &s )
|
|
: std_string(s) {}
|
|
|
|
G4String& G4String::operator=(const G4String& s)
|
|
{
|
|
std_string::operator=(s);
|
|
return *this;
|
|
}
|
|
|
|
G4String& G4String::operator=(const G4std::string &s)
|
|
{
|
|
std_string::operator=(s);
|
|
return *this;
|
|
}
|
|
|
|
G4String& G4String::operator=(const char* s)
|
|
{
|
|
std_string::operator=(s);
|
|
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.
|
|
//
|
|
char G4String::operator () (str_size i) const
|
|
{
|
|
return operator[](i);
|
|
}
|
|
|
|
char& G4String::operator () (str_size i)
|
|
{
|
|
return std_string::operator[](i);
|
|
}
|
|
|
|
G4String& G4String::operator+=(const G4SubString&s)
|
|
{
|
|
G4String tmp(s);
|
|
std_string::operator+=(tmp);
|
|
return *this;
|
|
}
|
|
|
|
G4String& G4String::operator+=(const char*s)
|
|
{
|
|
std_string::operator+=(s);
|
|
return *this;
|
|
}
|
|
|
|
G4String& G4String::operator+=(const G4std::string &s)
|
|
{
|
|
std_string::operator+=(s);
|
|
return *this;
|
|
}
|
|
|
|
G4String& G4String::operator+=(const char &c)
|
|
{
|
|
std_string::operator+=(c);
|
|
return *this;
|
|
}
|
|
|
|
G4bool G4String::operator==(const G4String &s) const
|
|
{
|
|
const std_string *a=this;
|
|
const std_string *b=&s;
|
|
return *a==*b;
|
|
}
|
|
|
|
G4bool G4String::operator==(const char* s) const
|
|
{
|
|
const std_string *a=this;
|
|
const std_string b=s;
|
|
return *a==b;
|
|
}
|
|
|
|
G4bool G4String::operator!=(const G4String &s) const
|
|
{
|
|
const std_string *a=this;
|
|
const std_string *b=&s;
|
|
return *a!=*b;
|
|
}
|
|
|
|
G4bool G4String::operator!=(const char* s) const
|
|
{
|
|
const std_string *a=this;
|
|
const std_string b=s;
|
|
return *a!=b;
|
|
}
|
|
|
|
G4String::operator const char*() const
|
|
{
|
|
return c_str();
|
|
}
|
|
|
|
G4int G4String::strcasecompare(const char* s1, const char* s2) const
|
|
{
|
|
#ifndef G4USE_STD_NAMESPACE
|
|
return strcasecmp(s1,s2);
|
|
#else
|
|
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;
|
|
#endif
|
|
}
|
|
|
|
G4int G4String::compareTo(const char* s, caseCompare mode)
|
|
{
|
|
if(mode==exact)
|
|
return strcmp(c_str(),s);
|
|
else
|
|
return strcasecompare(c_str(),s);
|
|
}
|
|
|
|
G4int G4String::compareTo(const G4String& s, caseCompare mode)
|
|
{
|
|
if(mode==exact)
|
|
return strcmp(c_str(),s.c_str());
|
|
else
|
|
return strcasecompare(c_str(),s.c_str());
|
|
}
|
|
|
|
G4String& G4String::prepend (const char* str)
|
|
{
|
|
insert(0,str);
|
|
return *this;
|
|
}
|
|
|
|
G4String& G4String::append(const G4String& s)
|
|
{
|
|
std_string::operator+=(s);
|
|
return *this;
|
|
}
|
|
|
|
G4std::istream&
|
|
G4String::readLine (G4std::istream& s, G4bool skipWhite)
|
|
{
|
|
char tmp[1024];
|
|
if ( skipWhite ) {
|
|
s >> G4std::ws;
|
|
s.getline(tmp,1024);
|
|
*this=tmp;
|
|
}
|
|
else {
|
|
s.getline(tmp,1024);
|
|
*this=tmp;
|
|
}
|
|
return s;
|
|
}
|
|
|
|
G4String& G4String::replace (unsigned int start, unsigned int nbytes,
|
|
const char* buff, unsigned int n2 )
|
|
{
|
|
std_string::replace ( start, nbytes, buff, n2 );
|
|
return *this;
|
|
}
|
|
|
|
G4String& G4String::replace(str_size pos, str_size n, const char* s)
|
|
{
|
|
std_string::replace(pos,n,s);
|
|
return *this;
|
|
}
|
|
|
|
G4String& G4String::remove(str_size n)
|
|
{
|
|
if(n<size())
|
|
erase(n,size()-n);
|
|
return *this;
|
|
}
|
|
|
|
G4String& G4String::remove(str_size pos, str_size N)
|
|
{
|
|
erase(pos,N+pos);
|
|
return *this;
|
|
}
|
|
|
|
G4int G4String::first(char c) const
|
|
{
|
|
return find(c);
|
|
}
|
|
|
|
G4int G4String::last(char c) const
|
|
{
|
|
return rfind(c);
|
|
}
|
|
|
|
G4bool G4String::contains(G4std::string s) const
|
|
{
|
|
G4int i=std_string::find(s);
|
|
if(i != G4int(std_string::npos))
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
G4bool G4String::contains(char c) const
|
|
{
|
|
G4int i=std_string::find(c);
|
|
if(i != G4int(std_string::npos))
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
G4String G4String::strip (G4int stripType, char c)
|
|
{
|
|
G4String retVal = *this;
|
|
if(length()==0) return retVal;
|
|
str_size i;
|
|
switch ( stripType ) {
|
|
case leading:
|
|
{
|
|
for(i=0;i<length();i++)
|
|
if (std_string::operator[](i) != c) break;
|
|
retVal = substr(i,length()-i);
|
|
}
|
|
break;
|
|
case trailing:
|
|
{
|
|
G4int j;
|
|
for(j=length()-1;j>=0;j--)
|
|
if (std_string::operator[](j) != c) break;
|
|
retVal = substr(0,j+1);
|
|
}
|
|
break;
|
|
case both:
|
|
{
|
|
for(i=0;i<length();i++)
|
|
if (std_string::operator[](i) != c) break;
|
|
G4String tmp(substr(i,length()-i));
|
|
G4int k;
|
|
for(k=tmp.length()-1;k>=0;k--)
|
|
if (tmp.std_string::operator[](k) != c) break;
|
|
retVal = tmp.substr(0,k+1);
|
|
}
|
|
}
|
|
return retVal;
|
|
}
|
|
|
|
void G4String::toLower ( void )
|
|
{
|
|
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));
|
|
}
|
|
}
|
|
|
|
void G4String::toUpper ( void )
|
|
{
|
|
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));
|
|
}
|
|
}
|
|
|
|
G4bool G4String::isNull() const
|
|
{
|
|
return empty ();
|
|
}
|
|
|
|
// "caseCompare" optional parameter is NOT implemented !
|
|
//
|
|
str_size G4String::index( const G4String& s, str_size ln,
|
|
str_size st, G4String::caseCompare ) const
|
|
{
|
|
return std_string::find( s.c_str(), st, ln );
|
|
}
|
|
|
|
str_size G4String::index (const char* str, G4int pos) const
|
|
{
|
|
return std_string::find(str,pos);
|
|
}
|
|
|
|
str_size G4String::index (char c, G4int pos) const
|
|
{
|
|
return std_string::find(c,pos);
|
|
}
|
|
|
|
G4SubString G4String::operator()(str_size start, str_size extent)
|
|
{
|
|
return G4SubString(*this,start,extent);
|
|
}
|
|
|
|
const char* G4String::data() const
|
|
{
|
|
return c_str();
|
|
}
|
|
|
|
unsigned int G4String::hash( caseCompare ) const
|
|
{
|
|
const char*s=c_str();
|
|
unsigned long h = 0;
|
|
for ( ; *s; ++s)
|
|
h = 5*h + *s;
|
|
|
|
return str_size(h);
|
|
}
|
|
|
|
unsigned int G4String::stlhash() const
|
|
{
|
|
const char*s=c_str();
|
|
unsigned long h = 0;
|
|
for ( ; *s; ++s)
|
|
h = 5*h + *s;
|
|
|
|
return str_size(h);
|
|
}
|
|
|
|
unsigned G4String::hash(const G4String& s)
|
|
{
|
|
return s.hash();
|
|
}
|