UT_StringUtils.h

Go to the documentation of this file.

/*
 * POPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        UT_StringUtils.h
 *
 * COMMENTS:
 *
 */

#ifndef __UT_STRINGUTILS_H__
#define __UT_STRINGUTILS_H__

#include "UT_API.h"

#include "UT_Array.h"
#include "UT_StringView.h"

#include <SYS/SYS_Compiler.h>
#include <SYS/SYS_String.h>
#include <SYS/SYS_Inline.h>

#include <tuple>
#include <type_traits>

SYS_FORCE_INLINE bool UTisstring(const char *s) { return s && *s; }

template <typename T>
SYS_NO_DISCARD_RESULT bool
UTstringStartsWith(
        const T& str,
        const char* prefix,
        bool case_sensitive = true,
        exint len = -1)
{
    if (!UTisstring(str.data()) || !(prefix && *prefix))
        return false;

    if (len < 0)
        len = strlen(prefix);

    if (len > str.length())
        return false;

    const char* start = str.data();
    if (case_sensitive)
        return strncmp(start, prefix, len) == 0;
    return SYSstrncasecmp(start, prefix, len) == 0;
}

template <typename T>
SYS_NO_DISCARD_RESULT bool
UTstringEndsWith(
        const T& str,
        const char* suffix,
        bool case_sensitive = true,
        exint len = -1)
{
    if (!UTisstring(str.data()) || !(suffix && *suffix))
        return false;

    if (len < 0)
        len = strlen(suffix);

    if (len > str.length())
        return false;

    const char* start = (str.data() + str.length()) - len;
    if (case_sensitive)
        return strncmp(start, suffix, len) == 0;
    return SYSstrncasecmp(start, suffix, len) == 0;
}

template <typename T>
SYS_NO_DISCARD_RESULT const char *
UTstringNumericSuffix(
        const T& str)
{
    int i = str.length();
    if (i <= 0)
        return nullptr;

    const char* data = str.data();
    while (i--)
    {
        if (!SYSisdigit(data[i]))
            break;
    }
    return &data[i + 1];
}

template <typename StringT>
SYS_NO_DISCARD_RESULT UT_StringView
UTstringFileName(const StringT& str)
{
    // Convert the unknown string type to a string view.
    UT_StringView view(str.data(), str.length());
    return UTstringFileName(view);
}

template <>
SYS_NO_DISCARD_RESULT inline UT_StringView
UTstringFileName(const UT_StringView& str)
{
    if (str.isEmpty())
        return str;

    exint pos = str.findLastOf('/');
    if (pos == UT_StringView::npos)
    {
        return str;
    }

    // Make sure to move the pos past the '/'
    return UT_StringView(str.begin() + pos + 1, str.end());
}

/// Split the given path into the directory, filename, and file extension.
template <typename StringT>
SYS_NO_DISCARD_RESULT std::tuple<UT_StringView, UT_StringView, UT_StringView>
UTstringSplitPath(const StringT& str)
{
    // Convert the unknown string type to a string view.
    UT_StringView view(str.data(), str.length());
    return UTstringSplitPath(view);
}

/// Split the given path into the directory, filename, and file extension.
template <>
SYS_NO_DISCARD_RESULT inline std::tuple<UT_StringView, UT_StringView, UT_StringView>
UTstringSplitPath(const UT_StringView& str)
{
    if (str.isEmpty())
        return std::make_tuple(str, str, str);

    // Parse for the dir
    UT_StringView dir;
    exint pos = str.findLastOf('/');
    if (pos != UT_StringView::npos)
        dir = UT_StringView(str.begin(), pos + 1);

    // Parse for the filename and file extension
    UT_StringView file = UT_StringView(str.begin() + dir.length(), str.end());
    exint dot = file.findLastOf('.');

    UT_StringView fname = file;
    UT_StringView fext;
    if (dot != UT_StringView::npos)
    {
        fname = UT_StringView(file.begin(), dot);
        fext = UT_StringView(file.begin() + dot, file.end());
    }

    return std::make_tuple(dir, fname, fext);
}

template <typename StringT>
SYS_NO_DISCARD_RESULT UT_StringView
UTstringFileExtension(const StringT& str)
{
    // Convert the unknown string type to a string view.
    UT_StringView view(str.data(), str.length());
    return UTstringFileExtension(view);
}

template <>
SYS_NO_DISCARD_RESULT inline UT_StringView
UTstringFileExtension<UT_StringView>(const UT_StringView& str)
{
    if (str.isEmpty())
        return str;

    exint dot = str.findLastOf('.');
    if (dot == UT_StringView::npos)
    {
        return UT_StringView{};
    }

    // Make sure the last dot that is found is after the last '/'.
    exint slash = str.findLastOf('/');
    if (slash != UT_StringView::npos && slash > dot)
        return UT_StringView{};

    return UT_StringView(str.begin() + dot, str.end());
}

template <typename StringT>
SYS_NO_DISCARD_RESULT bool
UTstringMatchFileExtension(const StringT& str, const char* extension)
{
    UT_StringView str_extension = UTstringFileExtension(str);
    return str_extension.equal(extension, false);
}

template <typename StringT>
SYS_NO_DISCARD_RESULT int
UTstringCountChar(const StringT& str, int c)
{
    UT_StringView view(str.data(), str.length());
    return UTstringCountChar(view, c);
}

template <>
SYS_NO_DISCARD_RESULT inline int
UTstringCountChar<UT_StringView>(const UT_StringView& str, int c)
{
    if (str.isEmpty())
        return 0;

    int count = 0;
    exint pos = 0;
    while (pos < str.length())
    {
        pos = str.findFirstOf(static_cast<char>(c), pos);
        if (pos == UT_StringView::npos)
            break;

        count++;
        // Skip past the item that was just found.
        pos++;
    }

    return count;
}

template <typename StringT>
SYS_NO_DISCARD_RESULT bool
UTstringIsFloat(
        const StringT& str,
        bool skip_spaces = false,
        bool loose = false,
        bool allow_underscore = false)
{
    const char* data = str.data();
    if (!UTisstring(data))
        return false;

    int i = 0;
    // Skip leading spaces
    if (skip_spaces)
        for (; SYSisspace(data[i]); i++)
            continue;

    for (; data[i] == '-' || data[i] == '+'; i++)
        continue;

    int digit = 0;
    int ecount = 0;
    int dotcount = 0;
    int epos = -10;

    for (; data[i]; i++)
    {
        if (SYSisdigit(data[i]))
        {
            digit = 1;
            continue;
        }
        switch (data[i])
        {
        case 'e':
        case 'E':
            if (ecount)
                return false;
            epos = i + 1;
            ecount = 1;
            break;
        case '-':
        case '+':
            if (epos != i)
                return false;
            epos++;
            break;
        case '.':
            if (ecount || dotcount)
                return false;
            dotcount = 1;
            break;
        case '_':
            if (allow_underscore)
            {
                // If we have not seen a digit, it is an error.
                if (!digit)
                    return false;
                // The actual requirements are tighter than this as
                // I believe trailing underscores are prohibited.
            }
            else
            {
                return false;
            }
            break;
        case ' ':
        case '\t':
        case '\n':
        case '\r':
        case '\f':
        case '\v':
            if (!skip_spaces)
            {
                return false;
            }
            else
            {
                // ignore trailing spaces
                for (; data[i]; i++)
                    if (!SYSisspace(data[i]))
                        return false;

                if (digit || loose)
                    return true;
                else
                    return false;
            }

        default:
            return false;
        }
    }

    return (digit || loose);
}

template <>
SYS_NO_DISCARD_RESULT inline bool
UTstringIsFloat<UT_StringView>(
        const UT_StringView& str,
        bool skip_spaces,
        bool loose,
        bool allow_underscore)
{
    // Since UT_StringView may not be null terminated we need to use a
    // specialized method.
    return str.isFloat(skip_spaces, loose, allow_underscore);
}

template <typename StringT>
SYS_NO_DISCARD_RESULT bool
UTstringIsInteger(const StringT& str, bool skip_spaces = false)
{
    const char* cur = str.data();

    if (!UTisstring(cur))
        return false;

    // Skip leading spaces
    if (skip_spaces)
    {
        for (; SYSisspace(*cur); ++cur)
            ;
    }

    // Skip all +'s and -'s
    for (; *cur == '-' || *cur == '+'; ++cur)
        ;

    // Skip all digits
    for (; SYSisdigit(*cur); ++cur)
        ;

    // Skip trailing spaces
    if (skip_spaces)
    {
        for (; SYSisspace(*cur); ++cur)
            ;
    }

    // if we have anything left, this is not an integer
    if (*cur)
        return false;
    return true;
}

template <>
SYS_NO_DISCARD_RESULT inline bool
UTstringIsInteger<UT_StringView>(const UT_StringView& str, bool skip_spaces)
{
    // Since UT_StringView may not be null terminated we need to use a
    // specialized method.
    return str.isInteger(skip_spaces);
}

#endif // __UT_STRINGUTILS_H__