StringUtils.cpp

/*
This file is part of the BIAS library (Basic ImageAlgorithmS).

Copyright (C) 2003-2009    (see file CONTACT for details)
Multimediale Systeme der Informationsverarbeitung
Institut fuer Informatik
Christian-Albrechts-Universitaet Kiel


BIAS is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

BIAS is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with BIAS; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include "StringUtils.hh"

void BIAS::StringUtils::Explode(const std::string &str,
                                const std::string &seperator,
                                std::vector<std::string> &ret)
{
  ret.clear();

  const int sepLen = seperator.length();

  // these indices mark beginning and end of the current token
  register int posL = 0;
  register int posR = str.find(seperator);

  // iterate over string
  while (posR > -1) {
    // skip empty strings (this can happen, when the seperator occures multiple
    // times successively)
    if (posL != posR) {
      ret.push_back(str.substr(posL, posR - posL));
    }

    // get indices for next iteration
    posL = posR + sepLen;
    posR = str.find(seperator, posL);
  }

  // if the string doesn't end with the seperator, push_back the last token
  if (posR == -1 && (unsigned int)posL < str.length()) {
    ret.push_back(str.substr(posL, str.length() - posL));
  }
}


void BIAS::StringUtils::SplitByChars(const std::string &str,
                                     std::vector<std::string> &ret,
                                     const std::string &charsToSplit)
{
  //std::cout << "StringUtils::SplitByChars() :  ";
  ret.clear();
  size_t nextPos, firstPos = str.find_first_not_of(charsToSplit);
  while (firstPos != std::string::npos) {
    nextPos = str.find_first_of(charsToSplit, firstPos);
    if (nextPos != std::string::npos) {
      ret.push_back(str.substr(firstPos, nextPos-firstPos));
      firstPos = str.find_first_not_of(charsToSplit, nextPos);
    } else {
      ret.push_back(str.substr(firstPos, str.size()-firstPos));
      firstPos = std::string::npos;
    }
    //std::cout << "\" << tokens[tokens.size()-1] << "\"  ";
  }
  //std::cout << endl;
}


void BIAS::StringUtils::Trim(const std::string &str,
                             std::string &ret,
                             const std::string &charsToTrim)
{
  const int left  = str.find_first_not_of(charsToTrim);
  const int right = str.find_last_not_of(charsToTrim);

  if (left != -1 && right != -1) {
    ret = str.substr(left, right - left + 1);
  }
  else { // string only consists of charsToTrim characters or is empty
    ret = "";
  }
}