/*StringTokenizer.h*/
#ifndef INCLUDE_STRINGTOKENIZER_H
#define INCLUDE_STRINGTOKENIZER_H
#include <string>
using namespace std;

class StringTokenizer {
public:
    StringTokenizer(const std::string& _str, const std::string& _delim);
    ~StringTokenizer(){};
    int countTokens();
    bool hasMoreTokens();
    string nextToken();
    int nextIntToken();
    double nextFloatToken();
    string nextToken(const std::string& delim);
    string remainingString();
    string filterNextToken(const std::string& filterStr);
private:
    string token_str;
    string delim;
};
=====================
/*
********************************************************
* *
* * StringTokenizer.cpp
********************************************************
*/


#include "StringTokenizer.h"

StringTokenizer::StringTokenizer(const string& _str, const string& _delim) {

if ((_str.length() == 0) || (_delim.length() == 0)) return;

token_str = _str;
delim = _delim;

/*
Remove sequential delimiter
*/
unsigned int curr_pos = 0;

while(true) {
if ((curr_pos = token_str.find(delim,curr_pos)) != string::npos) {
curr_pos += delim.length();

while(token_str.find(delim,curr_pos) == curr_pos) {
token_str.erase(curr_pos,delim.length());
  }
}
else
break;
}

/*
Trim leading delimiter
*/
if (token_str.find(delim,0) == 0) {
token_str.erase(0,delim.length());
}

/*
Trim ending delimiter
*/
curr_pos = 0;
if ((curr_pos = token_str.rfind(delim)) != string::npos) {
if (curr_pos != (token_str.length() - delim.length())) return;
token_str.erase(token_str.length() - delim.length(),delim.length());
  }
}


int StringTokenizer::countTokens() {

unsigned int prev_pos = 0;
int num_tokens = 0;

if (token_str.length() > 0) {
num_tokens = 0;

unsigned int curr_pos = 0;
while(true) {
if ((curr_pos = token_str.find(delim,curr_pos)) != string::npos) {
num_tokens++;
prev_pos = curr_pos;
curr_pos += delim.length();
}
else
break;
}
return ++num_tokens;
}
else {
return 0;
  }
}


bool StringTokenizer::hasMoreTokens() {
return (token_str.length() > 0);
}


string StringTokenizer::nextToken() {

if (token_str.length() == 0)
return "";

string tmp_str = "";
unsigned int pos = token_str.find(delim,0);

if (pos != string::npos) {
tmp_str = token_str.substr(0,pos);
token_str = token_str.substr(pos+delim.length(),token_str.length()-pos);
}
else {
tmp_str = token_str.substr(0,token_str.length());
token_str = "";
}

return tmp_str;
}


int StringTokenizer::nextIntToken() {
return atoi(nextToken().c_str());
}

double StringTokenizer::nextFloatToken() {
return atof(nextToken().c_str());
}


string StringTokenizer::nextToken(const string& delimiter) {
if (token_str.length() == 0)
return "";

string tmp_str = "";
unsigned int pos = token_str.find(delimiter,0);

if (pos != string::npos) {
tmp_str = token_str.substr(0,pos);
token_str = token_str.substr(pos + delimiter.length(),token_str.length() - pos);
}
else {
tmp_str = token_str.substr(0,token_str.length());
token_str = "";
}

return tmp_str;
}


string StringTokenizer::remainingString() {
return token_str;
}


string StringTokenizer::filterNextToken(const string& filterStr) {
string tmp_str = nextToken();
unsigned int currentPos = 0;

while((currentPos = tmp_str.find(filterStr,currentPos)) != string::npos) {
tmp_str.erase(currentPos,filterStr.length());
}

return tmp_str;
}

#endif