StringUtils.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2024 German Aerospace Center (DLR) and others.
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0/
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License 2.0 are satisfied: GNU General Public License, version 2
// or later which is available at
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
/****************************************************************************/
// Some static methods for string processing
/****************************************************************************/
#pragma once
#include <config.h>
#include <string>
#include <chrono>
#include <sstream>
#include <iomanip>
#include <xercesc/util/XMLString.hpp>
#include <utils/common/StdDefs.h>
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class StringUtils {
 
public:
 
    static std::string prune(const std::string& str);
 
    static std::string pruneZeros(const std::string& str, int max);
 
    static std::string to_lower_case(const std::string& str);
 
    static std::string latin1_to_utf8(std::string str);
 
    static std::string convertUmlaute(std::string str);
 
    static std::string replace(std::string str, const std::string& what, const std::string& by);
 
    static std::string substituteEnvironment(const std::string& str, const std::chrono::time_point<std::chrono::system_clock>* const timeRef = nullptr);
 
    static bool startsWith(const std::string& str, const std::string prefix);
 
    static bool endsWith(const std::string& str, const std::string suffix);
 
    static std::string padFront(const std::string& str, int length, char padding);
 
    static std::string escapeXML(const std::string& orig, const bool maskDoubleHyphen = false);
 
    static std::string escapeShell(const std::string& orig);
 
    static std::string emptyString;
 
    static std::string urlEncode(const std::string& url, const std::string encodeWhich = "");
 
    static std::string urlDecode(const std::string& encoded);
 
    static std::string charToHex(unsigned char c);
 
    static unsigned char hexToChar(const std::string& str);
 
    static int toInt(const std::string& sData);
 
    static int toIntSecure(const std::string& sData, int def);
 
    static long long int toLong(const std::string& sData);
 
    static int hexToInt(const std::string& sData);
 
    static double toDouble(const std::string& sData);
 
    static double toDoubleSecure(const std::string& sData, const double def);
 
    static bool toBool(const std::string& sData);
 
    static MMVersion toVersion(const std::string& sData);
 
    static double parseDist(const std::string& sData);
 
    static double parseSpeed(const std::string& sData, const bool defaultKmph = true);
 
    static inline std::string transcode(const XMLCh* const data) {
        return transcode(data, (int)XERCES_CPP_NAMESPACE::XMLString::stringLen(data));
    }
 
    static std::string transcode(const XMLCh* const data, int length);
 
    static std::string transcodeFromLocal(const std::string& localString);
 
    static std::string transcodeToLocal(const std::string& utf8String);
 
    static std::string trim_left(const std::string s, const std::string& t = " \t\n");
 
    static std::string trim_right(const std::string s, const std::string& t = " \t\n");
 
    static std::string trim(const std::string s, const std::string& t = " \t\n");
 
    static std::string wrapText(const std::string s, int width);
 
    static void resetTranscoder();
 
    // variadic function
    template<typename T, typename... Targs>
    static const std::string format(const std::string& format, T value, Targs... Fargs) {
        std::ostringstream os;
        os << std::fixed << std::setprecision(gPrecision);
        _format(format.c_str(), os, value, Fargs...);
        return os.str();
    }
 
private:
    static void _format(const char* format, std::ostringstream& os) {
        os << format;
    }
 
    // variadic function
    template<typename T, typename... Targs>
    static void _format(const char* format, std::ostringstream& os, T value, Targs... Fargs) {
        for (; *format != '\0'; format++) {
            if (*format == '%') {
                os << value;
                _format(format + 1, os, Fargs...); // recursive call
                return;
            }
            os << *format;
        }
    }
 
    static XERCES_CPP_NAMESPACE::XMLLCPTranscoder* myLCPTranscoder;
};