UT_StringUtils.h

Go to the documentation of this file.

/*
 * PROPRIETARY 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_StringView.h"

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

#include <tuple>
#include <string.h>

class UT_StringHolder;

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

template <typename T, bool HasFastLength = true>
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 constexpr (HasFastLength)
    {
        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());

    // If the file is `..` or `.`, or a dotfile, then there is no extension to parse
    if (file.length() > 0 && file[0] == '.')
        return std::make_tuple(dir, file, UT_StringView());

    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);
}

/// Decompose a filename into various parts
///
/// parseNumberedFileName will breakup a filename into its various
/// parts: file = prefix$Fsuffix (note: suffix is
/// not the same as file extension.) 0 is returned if there is
/// no frame number. 'negative' allows -[frame] to be interpreted as a
/// negative number. 'fractional' allows [frame].[number] to be interpreted
/// as a fractional frame.
///
/// WARNING:    Make sure to take care of lifetimes when the input string is
///             UT_StringView.
template <typename StringT>
bool
UTstringParseNumberedFilename(
        const StringT& str,
        UT_StringView& prefix,
        UT_StringView& frame,
        UT_StringView& suffix,
        bool negative, bool fractional)
{
    if (str.length() == 0) return false;

    const char *data = str.data();

    if (data == nullptr)
        return false;

    const char *itr;
    const char *digend;

    // make sure we don't find numbers in the path part
    const char* filename = strrchr(data, '/');
    if (filename == nullptr)
        filename = data;

    int len =strlen(filename);

    // make sure we don't find numbers in the file extension.
    const char* fileend = filename + len -1;
    while(*fileend != '.' && fileend > filename)
        fileend --;

    if(fileend == filename)
        fileend = filename + len -1;
    
    // search for the last digit.
    for(itr = fileend; itr >= filename; itr-- )
        if (SYSisdigit(*itr))
        {
            digend = itr;
            break;
        }

    if (itr < filename)
    {
        prefix = UT_StringView(data);
        frame = UT_StringView();
        suffix = UT_StringView();
        return false;
    }

    for (; itr >= filename; itr--)
        if (!(SYSisdigit(*itr) ||
              (negative && *itr == '-') ||
              (fractional && *itr == '.')))
            break;

    prefix = UT_StringView(data, (int)(itr-data+1));
    frame = UT_StringView(itr+1,  (int)(digend - itr));
    suffix = UT_StringView(digend+1);

    return true;
}

/// Decompose a filename into various parts
///
/// parseNumberedFileName will breakup a filename into its various
/// parts: file = prefix$Fsuffix (note: suffix is
/// not the same as file extension.) 0 is returned if there is
/// no frame number. 'negative' allows -[frame] to be interpreted as a
/// negative number. 'fractional' allows [frame].[number] to be interpreted
/// as a fractional frame.
template <typename StringT>
bool UTstringParseNumberedFilename(
        const StringT& str,
        UT_StringHolder& prefix,
        UT_StringHolder& frame,
        UT_StringHolder& suffix,
        bool negative,
        bool fractional);

template <typename StringT>
bool
UTstringIsQuoted(const StringT& str, char delimiter)
{
    int len = str.length();
    const char* data = str.data();

    return len >= 2 && data[0] == delimiter && data[len - 1] == delimiter
           && data[len - 2] != '\\';
}

template <typename StringT, typename IntT>
SYS_ParseStatus
UTstringToInt(
        const StringT& str,
        IntT& number,
        int base = 0,
        SYS_ParseFlags flags = SYS_ParseFlags::None)
{
    const char* b = str.data();
    const char* e = b+str.length();
    return SYSparseInteger(b, e, number, base, flags);
}

template <typename IntT, typename StringT>
SYS_NO_DISCARD_RESULT IntT
UTstringToInt(
        const StringT& str,
        int base=0,
        SYS_ParseFlags flags = SYS_ParseFlags::None)
{
    IntT number = IntT{};
    const char* b = str.data();
    const char* e = b+str.length();
    SYSparseInteger(b, e, number, base, flags);
    return number;
}

#endif // __UT_STRINGUTILS_H__