StringUtils.h

Go to the documentation of this file.

// This file is part of CoreLibrary containing useful reusable utility
// classes.
//
// Copyright (C) 2014 to present, Duncan Crutchley
// Contact <dac1976github@outlook.com>
//
// This program 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 3 of the License, or
// (at your option) any later version.
//
// This program 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 General Public License and GNU Lesser General Public License
// for more details.
//
// You should have received a copy of the GNU General Public License
// and GNU Lesser General Public License along with this program. If
// not, see <http://www.gnu.org/licenses/>.

#ifndef STRINGUTILS
#define STRINGUTILS

#include <string>
#include <sstream>
#include <iomanip>
#include <map>
#include <vector>
#include <limits>
#include <cmath>
#include "CoreLibraryDllGlobal.h"
#include "Platform/PlatformDefines.h"

namespace core_lib
{
namespace string_utils
{

void CORE_LIBRARY_DLL_SHARED_API PackStdString(std::string& line);

enum class eSplitStringResult
{
    trimmed,
    notTrimmed
};

void CORE_LIBRARY_DLL_SHARED_API SplitString(std::string& subStr1, std::string& subStr2,
                                             const std::string& toSplit, const std::string& delim,
                                             eSplitStringResult option);

enum class eFloatStringFormat
{
    normal,
    fixed,
    scientific
};

template <typename T>
std::string FormatFloatString(const T value, const int precision = 15,
                              eFloatStringFormat formatting = eFloatStringFormat::normal)
{
    std::ostringstream ss;

    switch (formatting)
    {
    case eFloatStringFormat::fixed:
        ss << std::fixed;
        break;
    case eFloatStringFormat::scientific:
        ss << std::scientific;
        break;
    case eFloatStringFormat::normal:
        // do nothing
        break;
    }

    if (precision >= 0)
    {
        ss << std::setprecision(precision);
    }

    ss << value;
    return ss.str();
}

template <typename T> std::string AutoFormatFloatString(const T value, int decimalPlaces = 1)
{
    std::string formattedValue;

    if (decimalPlaces < 0)
    {
        decimalPlaces = 0;
    }

    const T min    = std::pow(T(10), T(-1) * decimalPlaces);
    const T absVal = std::fabs(value);

    if (absVal < std::numeric_limits<T>::epsilon()) // 0.0 case
    {
        formattedValue = FormatFloatString(value, 1 + decimalPlaces);
    }
    else if ((absVal < min) || (absVal >= T(100000))) // very small and very big values
    {
        formattedValue = FormatFloatString(value, decimalPlaces, eFloatStringFormat::scientific);
    }
    else // everything in between
    {
        if (absVal < T(1))
        {
            formattedValue = FormatFloatString(value, decimalPlaces);
        }
        else if (absVal < T(10))
        {
            formattedValue = FormatFloatString(value, 1 + decimalPlaces);
        }
        else if (absVal < T(100))
        {
            formattedValue = FormatFloatString(value, 2 + decimalPlaces);
        }
        else if (absVal < T(1000))
        {
            formattedValue = FormatFloatString(value, 3 + decimalPlaces);
        }
        else if (absVal < T(10000))
        {
            formattedValue = FormatFloatString(value, 4 + decimalPlaces);
        }
        else
        {
            formattedValue = FormatFloatString(value, 5 + decimalPlaces);
        }
    }

    return formattedValue;
}

std::wstring CORE_LIBRARY_DLL_SHARED_API RemoveIllegalChars(
    const std::wstring& text, const std::wstring& illegalChars = L"~#%&*{}\\:<>?/+|\"",
    wchar_t replacementChar = L'_');

std::string CORE_LIBRARY_DLL_SHARED_API
            RemoveIllegalChars(const std::string& text, const std::string& illegalChars = "~#%&*{}\\:<>?/+|\"",
                               char replacementChar = '_');

std::wstring CORE_LIBRARY_DLL_SHARED_API StringToWString(const std::string& text);

std::string CORE_LIBRARY_DLL_SHARED_API WStringToString(const std::wstring& text);

bool CORE_LIBRARY_DLL_SHARED_API IsAlphaNumeric(const std::wstring& text);

bool CORE_LIBRARY_DLL_SHARED_API IsAlphaNumeric(const std::string& text);

template <typename Iter>
std::string MakeHexString(Iter first, Iter last, bool useUppercase, bool insertSpaces)
{
    std::ostringstream ss;
    ss << std::hex << std::setfill('0');

    if (useUppercase)
    {
        ss << std::uppercase;
    }

    while (first != last)
    {
        ss << std::setw(2) << static_cast<int>(*first++);

        if (insertSpaces && first != last)
        {
            ss << " ";
        }
    }

    return ss.str();
}

std::vector<std::string> CORE_LIBRARY_DLL_SHARED_API TokeniseString(std::string const& text,
                                                                    std::string const& separator,
                                                                    bool keepEmptyTokens = false);

std::string CORE_LIBRARY_DLL_SHARED_API
            ReplaceTokens(std::string const& text, std::map<std::string, std::string> const& tokenMap);

} // namespace string_utils
} // namespace core_lib

#endif // STRINGUTILS