stringutils.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// std includes
#include <list>
#include <sstream>
#include <string>
#include <vector>
#include <algorithm>
#include <locale>
#include <memory>
#include <unordered_map>
 
namespace nap
{
    namespace utility
    {
        /*
         * Splits a string based on the given delimiter. Results are stored in ioParts.
         * @param string the sequence to split
         * @param delim the character used to split the string
         * @param ioParts list of individual split parts
         */
        void splitString(const std::string& string, const char delim, std::vector<std::string>& ioParts);
 
        /*
         * Splits a string based on the given delimiter.
         * @param string the sequence to split.
         * @param delim the delimiter used to split the string.
         * @return vector of split parts.
         */
        std::vector<std::string> splitString(const std::string& string, const char delim);
 
        template<typename T>
        std::string joinString(const T& list, const char* delim);
 
        void writeString(std::ostream& stream, const std::string& text);
 
        std::string readString(std::istream& stream);
 
        void toLower(std::string& ioString);
 
        std::string toLower(const std::string& string);
 
        void toUpper(std::string& ioString);
 
        std::string toUpper(const std::string& string);
 
        std::string stripNamespace(const std::string& str);
 
        void removeChars(const char* chars, std::string& ioString);
 
        void tokenize(const std::string& str, std::list<std::string>& tokens, const std::string& delims, bool omitTokens = false);
 
        bool startsWith(const std::string& string, const std::string& subString, bool caseSensitive = true);
 
        bool endsWith(const std::string& string, const std::string& subString, bool caseSensitive = true);
 
        bool contains(const std::string& string, const std::string& subString, bool caseSensitive = true);
 
        std::string trim(const std::string& string);
 
        std::string lTrim(const std::string& string);
 
        std::string rTrim(const std::string& string);
 
        template <typename T>
        std::string addresStr(T thing);
 
        template <typename... Args>
        static std::string stringFormat(const char* msg, Args&&... args);
 
        void namedFormat(std::string& subject, const std::unordered_map<std::string, std::string>& rep);
 
        void namedFormat(std::vector<std::string>& subjects, const std::unordered_map<std::string, std::string>& rep);
 
        std::string replaceTemplateType(const std::string& typeName, const std::string& templateTypeName);
 
        void replaceAllInstances(std::string& inString, const std::string& find, const std::string& replace);
 
        std::string replaceAllInstances(const std::string& inString, const std::string& find, const std::string& replace);
 
        int getLine(const std::string& buffer, size_t offset);
 
 
        // Template Definitions
 
        template<typename T>
        std::string joinString(const T& list, const char* delim)
        {
            std::stringstream ss;
            for (size_t i = 0, len = list.size(); i < len; i++)
            {
                if (i > 0)
                    ss << delim;
                ss << list.at(i);
            }
            return ss.str();
        }
 
 
        template <typename... Args>
        std::string stringFormat(const char* format, Args&&... args)
        {
            size_t size = (size_t)(snprintf(nullptr, 0, format, args...) + 1); // Extra space for '\0'
            std::unique_ptr<char[]> buf(new char[size]);
            snprintf(buf.get(), size, format, args...);
            return std::string(buf.get(), buf.get() + size - 1); // We don't want the '\0' inside
        }
 
        template <typename T>
        std::string addresStr(T thing)
        {
            const void* addr = static_cast<const void*>(thing);
            std::stringstream ss;
            ss << addr;
            return ss.str();
        }
    }
}