StringUtils.cpp

#include <Core/Utils/StringUtils.hpp>
#include <cstddef>
#include <map>
#include <string>
#include <string_view>
 
/*
 * NOMINMAX is already defined in CoreMacros.hpp ...
 
#ifdef COMPILER_MSVC
#    define NOMINMAX // Avoid C2039 MSVC compiler error
//#undef vsnprintf
//#define vsnprintf(buffer, count, format, argptr) vsnprintf_s(buffer, count, count, format, argptr)
#endif
*/
 
namespace Ra {
namespace Core {
namespace Utils {
 
std::string getFileExt( const std::string& str ) {
    auto pos        = str.find_last_of( '.' );
    std::string res = pos < str.length() ? str.substr( pos + 1 ) : "";
    return res;
}
 
std::string getDirName( const std::string& path ) {
    // We remove any trailing slashes.
    auto pos = path.find_last_not_of( '/' );
 
    // Don't strip the last / from "/"
    if ( pos >= path.length() ) { pos = path.find_first_of( "/" ); }
    std::string res = path.substr( 0, pos + 1 );
 
    // Now find the previous slash and cut the string.
    pos = res.find_last_of( '/' );
 
    // The directory is actually "/" because the last slash is in first position.
    // In that case we should return "/"
    if ( pos == 0 ) { res = "/"; }
    else if ( pos < res.length() ) { res.resize( pos ); }
    else { res = "."; }
 
    return res;
}
 
std::string getBaseName( const std::string& path, bool keepExtension ) {
    // We remove any trailing slashes.
    auto pos = path.find_last_not_of( '/' );
    // Don't strip the last / from "/"
    if ( pos >= path.length() ) { pos = path.find_first_of( "/" ); }
    std::string res = path.substr( 0, pos + 1 );
 
    // Now find the previous slash and cut the string.
    pos = res.find_last_of( '/' );
    if ( pos < res.length() ) { res = res.substr( pos + 1 ); }
    if ( !keepExtension ) {
        pos = res.find_last_of( '.' );
        if ( pos < res.length() ) { res.resize( pos ); }
    }
 
    return res;
}
 
std::size_t replaceAllInString( std::string& inout, std::string_view what, std::string_view with ) {
    std::size_t count {};
    for ( std::string::size_type pos {};
          inout.npos != ( pos = inout.find( what.data(), pos, what.length() ) );
          pos += with.length(), ++count ) {
        inout.replace( pos, what.length(), with.data(), with.length() );
    }
    return count;
}
 
std::size_t removeAllInString( std::string& inout, std::string_view what ) {
    return replaceAllInString( inout, what, "" );
}
 
void remove_bracket_block( std::string& inout, const std::string& what, char open_sep ) {
    replace_bracket_block( inout, what, "", open_sep );
}
 
void replace_bracket_block( std::string& inout,
                            const std::string& what,
                            const std::string& with,
                            char open_sep ) {
    const std::map<char, char> open_to_close = {
        { '<', '>' },
        { '(', ')' },
        { '[', ']' },
        { '{', '}' },
    };
 
    const auto it = open_to_close.find( open_sep );
    if ( it == open_to_close.end() ) throw std::invalid_argument( "Unsupported open separator" );
 
    const char close_sep = it->second;
 
    std::string target = what + open_sep;
 
    size_t i = 0;
 
    for ( size_t pos = inout.find( target, i ); pos != std::string::npos;
          pos        = inout.find( target, i ) ) {
 
        size_t j  = pos + target.size();
        int depth = 1;
        while ( j < inout.size() && depth > 0 ) {
            if ( inout[j] == open_sep )
                ++depth;
            else if ( inout[j] == close_sep )
                --depth;
            ++j;
        }
        // If unmatched open_sep, abort safely
        if ( depth != 0 ) break;
 
        while ( j < inout.size() && std::isspace( static_cast<unsigned char>( inout[j] ) ) ) {
            ++j;
        }
        // Replace the full "what<...>" block with "with"
        inout.replace( pos, j - pos, with );
    }
}
 
} // namespace Utils
} // namespace Core
} // namespace Ra