drwnStrUtils.h

Go to the documentation of this file.

/*****************************************************************************
** DARWIN: A FRAMEWORK FOR MACHINE LEARNING RESEARCH AND DEVELOPMENT
** Distributed under the terms of the BSD license (see the LICENSE file)
** Copyright (c) 2007-2017, Stephen Gould
** All rights reserved.
**
******************************************************************************
** FILENAME:    drwnStrUtils.h
** AUTHOR(S):   Stephen Gould <stephen.gould@anu.edu.au>
**
*****************************************************************************/

#pragma once

#include <string>
#include <vector>
#include <list>
#include <set>
#include <iostream>
#include <sstream>
#include <map>
#include <deque>
#include <stdlib.h>
#include <limits>

using namespace std;

// constants and globals ----------------------------------------------------

extern std::string DRWN_COL_SEP;  
extern std::string DRWN_ROW_BEG;  
extern std::string DRWN_ROW_END;  

// functions ----------------------------------------------------------------

template<typename T>
std::string toString(const T& v);

template<typename T>
std::string toString(const std::vector<T>& v);

template<typename T>
std::string toString(const std::list<T>& v);

template<typename T>
std::string toString(const std::set<T>& v);

template<typename T>
std::string toString(const std::deque<T>& q);

template<typename T, typename U>
std::string toString(const std::pair<T, U>& p);

std::string toString(const map<std::string, std::string>& m);

namespace drwn {

    int strNoCaseCompare(const std::string& A, const std::string& B);

    template<typename T>
    int parseString(const std::string& str, std::vector<T>& v);
};

    //@cond
    template<typename T, bool B>
    struct parseInfToken {
        static bool apply(const std::string& token, T& value);
    };
    //@endcond

namespace drwn {

    map<string, string> parseNameValueString(std::string str);

    bool trueString(const std::string& str);

    std::string padString(const std::string& str, int padLength,
        unsigned char padChar = '0');

    std::list<string> breakString(const std::string& str, unsigned lineLength);

    std::string& trim(std::string& str);

    string strReplaceSubstr(const string& str, const string& substr, const string& rep);

    string strSpacifyCamelCase(const string& str);

    string bytesToString(unsigned b);
    string millisecondsToString(unsigned ms);

    string strBaseName(const string &fullPath);
    string strFilename(const string &fullPath);
    string strDirectory(const string &fullPath);
    string strExtension(const string &fullPath);
    string strReplaceExt(const string &fullPath, const string &ext);
    string strWithoutExt(const string &fullPath);
    string strWithoutEndSlashes(const string &fullPath);
    int strFileIndex(const string &fullPath);
};

// Implementation -----------------------------------------------------------

template<typename T>
std::string toString(const T& v)
{
    std::stringstream s;
    s << v;
    return s.str();
}

template<typename T>
std::string toString(const std::vector<T>& v)
{
    std::stringstream s;
    for (unsigned i = 0; i < v.size(); i++) {
        s << " " << v[i];
    }
    return s.str();
}

template<typename T>
std::string toString(const std::list<T>& v)
{
    std::stringstream s;
    for (typename std::list<T>::const_iterator it = v.begin(); it != v.end(); ++it) {
        if (it != v.begin()) s << " ";
        s << *it;
    }
    return s.str();
}

template<typename T>
std::string toString(const std::set<T>& v)
{
    std::stringstream s;
    s << "{";
    for (typename std::set<T>::const_iterator it = v.begin(); it != v.end(); ++it) {
        s << " " << *it;
    }
    s << " }";
    return s.str();
}

template<typename T>
std::string toString(const std::deque<T>& q)
{
    std::stringstream s;
    for (typename std::deque<T>::const_iterator it = q.begin(); it != q.end(); ++it) {
        s << " " << *it;
    }
    return s.str();
}

template<typename T, typename U>
std::string toString(const std::pair<T, U>& p)
{
    std::stringstream s;
    s << "(" << p.first << ", " << p.second << ")";
    return s.str();
}

// Conversion from a string
template<typename T>
int drwn::parseString(const std::string& str, std::vector<T>& v)
{
    std::stringstream buffer;
    T data;
    int count;

    buffer << str;

    count = 0;
    while (1) {
        int lastPosition = buffer.tellg();
        buffer >> data;
        if (buffer.fail()) {
            // try to parse special token
            buffer.clear();
            buffer.seekg(lastPosition, ios::beg);
            string token;
            buffer >> token;
            if (!parseInfToken<T, numeric_limits<T>::has_infinity>::apply(token, data)) {
                break;
            }
        }
        v.push_back(data);
        count++;

        if (buffer.eof()) break;
    }

    return count;
}

//@cond
template<typename T>
struct parseInfToken<T, true>  {
    static bool apply(const std::string& token, T& value) {
        if (token.compare("-inf") == 0) {
            value = -numeric_limits<T>::infinity();
        } else if (token.compare("inf") == 0) {
            value = numeric_limits<T>::infinity();
        } else {
            return false;
        }

        return true;
    }
};

template<typename T>
struct parseInfToken<T, false>  {
    static bool apply(const std::string& token, T& value) {
        return false;
    }
};
//@condend