StringManipulator Class Reference

#include <StringManipulator.h>

Public Types
using	Index = unsigned int
using	StringVector = std::vector< std::string >

Public Member Functions
	StringManipulator (std::string &strin, bool copy)
	StringManipulator (const std::string &sin)
	StringManipulator (const char *chin)
void	setLogLevel (Index logLevel)
Index	logLevel () const
const std::string &	str () const
const char *	c_str () const
std::string::size_type	size () const
template<typename T >
int	replace (std::string substr, const T &xsub)
template<typename T >
int	replaceFixedWidth (std::string substr, const T &xsub, Index width)
const std::vector< std::string > &	split (std::string seps, bool fullSplit=false)
const StringVector &	patternSplit (std::string spat)
const StringVector &	splits () const
bool	isDigits () const
bool	isUnsignedInt () const
bool	isInt () const
bool	isFloat () const
int	toInt (int valbad=0) const
unsigned int	toUnsignedInt (unsigned int valbad=0) const
float	toFloat (float valbad=0) const

Static Public Member Functions
template<typename T >
static char	getFill (typename std::enable_if< std::is_integral< T >::value, const T & >::type val)
template<typename T >
static char	getFill (typename std::enable_if<!std::is_integral< T >::value, const T & >::type val)
static std::string	floatToString (float val, int prec, bool trunc, std::string sdot="", std::string smin="")

Private Attributes
int	m_LogLevel = 0
std::string &	m_str
std::string	m_strCopy
StringVector	m_splits

Detailed Description

Definition at line 15 of file StringManipulator.h.

Member Typedef Documentation

using StringManipulator::Index = unsigned int

Definition at line 19 of file StringManipulator.h.

using StringManipulator::StringVector = std::vector<std::string>

Definition at line 20 of file StringManipulator.h.

Constructor & Destructor Documentation

StringManipulator::StringManipulator ( std::string &  strin, bool  copy  )

inline

Definition at line 49 of file StringManipulator.h.

  : m_str(copy ? m_strCopy : strin), m_strCopy(strin) { }

StringManipulator::StringManipulator ( const std::string &  sin )

inlineexplicit

Definition at line 53 of file StringManipulator.h.

: m_str(m_strCopy), m_strCopy(sin) { }

StringManipulator::StringManipulator ( const char *  chin )

inlineexplicit

Definition at line 56 of file StringManipulator.h.

: m_str(m_strCopy), m_strCopy(chin) { }

Member Function Documentation

const char* StringManipulator::c_str ( ) const

inline

Definition at line 66 of file StringManipulator.h.

{ return m_str.c_str(); }

string StringManipulator::floatToString ( float  val, int  prec, bool  trunc, std::string  sdot = "", std::string  smin = ""  )

static

Definition at line 110 of file StringManipulator.cxx.

                                                                         {
  ostringstream ssout;
  ssout.setf(std::ios::fixed);
  ssout.precision(prec);
  ssout << val;
  string sout = ssout.str();
  if ( trunc && sout.size() ) {
    string::size_type ipos = sout.size() - 1;
    while ( ipos > 0 ) {
      if ( sout[ipos] == '.' ) {
        --ipos;
        break;
      } else if ( sout[ipos] == '0' ) --ipos;
      else break;
    }
    sout = sout.substr(0, ipos + 1);
    if ( sdot.size() && sdot != "." ) {
      for ( ipos=0; ipos<sout.size(); ++ipos ) {
        if ( sout[ipos] == '.' ) {
          sout.replace(ipos, 1, sdot);
          ipos += sdot.size() - 1;
        }
      }
    }
    if ( smin.size() && smin != "." ) {
      for ( ipos=0; ipos<sout.size(); ++ipos ) {
        if ( sout[ipos] == '-' ) {
          sout.replace(ipos, 1, smin);
          ipos += smin.size() - 1;
        }
      }
    }
  }
  return sout;
}

template<typename T >

static char StringManipulator::getFill ( typename std::enable_if< std::is_integral< T >::value, const T & >::type  val )

inlinestatic

Definition at line 27 of file StringManipulator.h.

                                                                           {
    return val < 0 ? '-' : '0';
  }

template<typename T >

static char StringManipulator::getFill ( typename std::enable_if<!std::is_integral< T >::value, const T & >::type  val )

inlinestatic

Definition at line 33 of file StringManipulator.h.

                                                                            {
    return '_';
  }

bool StringManipulator::isDigits

(

)

const

Definition at line 148 of file StringManipulator.cxx.

                                       {
  if ( str().empty() ) return false;
  for ( char c : str() ) if ( ! std::isdigit(c) ) return false;
  return true;
}

bool StringManipulator::isFloat

(

)

const

Definition at line 174 of file StringManipulator.cxx.

                                      {
  if ( str().size() == 0 ) return false;
  char* pch = nullptr;
  strtof(c_str(), &pch);
  return pch[0] == '\0';
}

bool StringManipulator::isInt

(

)

const

Definition at line 156 of file StringManipulator.cxx.

                                    {
  if ( str().empty() ) return false;
  char c = str()[0];
  string schk = (c == '+' || c == '-') ? str().substr(1) : str();
  return StringManipulator(schk).isDigits();
}

bool StringManipulator::isUnsignedInt

(

)

const

Definition at line 165 of file StringManipulator.cxx.

                                            {
  if ( str().empty() ) return false;
  char c = str()[0];
  string schk = c == '+' ? str().substr(1) : str();
  return StringManipulator(schk).isDigits();
}

Index StringManipulator::logLevel ( ) const

inline

Definition at line 60 of file StringManipulator.h.

{ return m_LogLevel; }

const StringVector & StringManipulator::patternSplit

(

std::string

spat

)

Definition at line 51 of file StringManipulator.cxx.

                                                               {
  const string myname = "StringManipulator::patternSplit: ";
  string word;
  bool inPat = false;
  m_splits.clear();
  if ( spat.size() < 2 ) return m_splits;
  char chStart = spat[0];
  char chEnd = spat[spat.size() - 1 ];
  string seps = spat.substr(1, spat.size() - 2 );
  // Build the sequence of words and word vectors used to create the
  // full vector of strings.
  StringVV wordvv;
  for ( char ch : m_str ) {
    // In gap between patterns.
    if ( ! inPat ) {
      if ( ch == chStart ) {
        wordvv.push_back(StringVector(1, word));
        word = "";
        inPat = true;
      } else {
        word += ch;
      }
    // In a pattern.
    } else {
      if ( ch == chEnd ) {
        StringManipulator sman(word,false);
        wordvv.push_back(sman.split(seps));
        word = "";
        inPat = false;
      } else {
        word += ch;
      }
    }
  }
  if ( word.size() ) wordvv.push_back(StringVector(1, word));
  if ( logLevel() >= 1 ) {
    cout << myname << "Word sequence count: " << wordvv.size() << endl;
  }
  // Construct the vector of strings from the wors sequence.
  StringVector& strs1(m_splits);
  strs1.push_back("");
  for ( const StringVector& wordvec : wordvv ) {
    StringVector strs2;
    for ( string str1 : strs1 ) {
      for ( string word : wordvec ) {
        strs2.push_back(str1 + word);
      }
    }
    strs1 = strs2;
  }
  if ( logLevel() >= 1 ) {
    cout << myname << "Split count: " << m_splits.size() << endl;
  }
  return m_splits;
}

template<typename T >

int StringManipulator::replace	(	std::string	substr,
		const T &	xsub
	)

Definition at line 136 of file StringManipulator.h.

                                                                 {
  std::string ssubin;
  bool havesub = false;
  std::string::size_type ipos = m_str.find(ssubout);
  int count = 0;
  while ( ipos != std::string::npos ) {
    if ( ! havesub ) {
      std::ostringstream sssubin;
      sssubin << xsubin;
      ssubin = sssubin.str();
    }
    std::string::size_type lout = ssubout.size();
    m_str.replace(ipos, lout, ssubin);
    ipos = m_str.find(ssubout, ipos+lout);
    ++count;
  }
  return count;
}

template<typename T >

int StringManipulator::replaceFixedWidth	(	std::string	substr,
		const T &	xsub,
		Index	width
	)

Definition at line 159 of file StringManipulator.h.

                                                                   {
  std::string ssubin;
  char cfill = getFill<T>(xsubin);
  bool havesub = false;
  std::string::size_type ipos = m_str.find(ssubout);
  int count = 0;
  while ( ipos != std::string::npos ) {
    if ( ! havesub ) {
      std::ostringstream sssubin;
      sssubin.fill(cfill);
      sssubin.width(width);
      sssubin << xsubin;
      ssubin = sssubin.str();
    }
    std::string::size_type lout = ssubout.size();
    m_str.replace(ipos, lout, ssubin);
    ipos = m_str.find(ssubout, ipos+lout);
    ++count;
  }
  return count;
}

void StringManipulator::setLogLevel ( Index  logLevel )

inline

Definition at line 59 of file StringManipulator.h.

{ m_LogLevel = logLevel; }

std::string::size_type StringManipulator::size ( ) const

inline

Definition at line 69 of file StringManipulator.h.

{ return str().size(); }

const StringVector & StringManipulator::split	(	std::string	seps,
		bool	fullSplit = false
	)

Definition at line 19 of file StringManipulator.cxx.

                                                                        {
  m_splits.clear();
  if ( seps.size() == 0 ) {
    m_splits.push_back(m_str);
    return m_splits;
  }
  // Replace all separators with the first,
  string str = m_str;
  char csep = seps[0];
  for ( char ch : seps.substr(1) ) {
    for ( char& rch : str ) if ( rch == ch ) rch = csep;
  }
  // Split.
  string word;
  bool isSep = false;
  for ( char ch : m_str ) {
    isSep = ch == csep;
    if ( isSep ) {
      if ( fullSplit || word.size() ) {
        m_splits.push_back(word);
        word = "";
      }
    } else {
      word += ch;
    }
  }
  if ( word.size() || (fullSplit && isSep) ) m_splits.push_back(word);
  return m_splits;
}

const StringVector& StringManipulator::splits ( ) const

inline

Definition at line 98 of file StringManipulator.h.

{ return m_splits; }

const std::string& StringManipulator::str ( ) const

inline

Definition at line 63 of file StringManipulator.h.

{ return m_str; }

float StringManipulator::toFloat

(

float

valbad = 0

)

const

Definition at line 197 of file StringManipulator.cxx.

                                                   {
  if ( str().size() == 0 ) return badval;
  char* pch = nullptr;
  float val = strtof(c_str(), &pch);
  return pch[0] == '\0' ? val : badval;
}

int StringManipulator::toInt

(

int

valbad = 0

)

const

Definition at line 183 of file StringManipulator.cxx.

                                             {
  if ( ! isInt() ) return badval;
  return std::strtol(c_str(), nullptr, 10);
}

unsigned int StringManipulator::toUnsignedInt

(

unsigned int

valbad = 0

)

const

Definition at line 190 of file StringManipulator.cxx.

                                                                       {
  if ( ! isUnsignedInt() ) return badval;
  return std::strtoul(c_str(), nullptr, 10);
}

Member Data Documentation

int StringManipulator::m_LogLevel = 0

private

Definition at line 126 of file StringManipulator.h.

StringVector StringManipulator::m_splits

private

Definition at line 129 of file StringManipulator.h.

std::string& StringManipulator::m_str

private

Definition at line 127 of file StringManipulator.h.

std::string StringManipulator::m_strCopy

private

Definition at line 128 of file StringManipulator.h.

---

The documentation for this class was generated from the following files:

• dunecore/dunecore/DuneCommon/Utility/StringManipulator.h
• dunecore/dunecore/DuneCommon/Utility/StringManipulator.cxx