stringutils.h

Go to the documentation of this file.

/*
* Copyright 2016 Autodesk, Inc. All rights reserved.
* Use of this software is subject to the terms of the Autodesk license agreement and any attachments or Appendices thereto provided at the time of installation or download,
* or which otherwise accompanies this software in either electronic or hard copy form, or which is signed by you and accepted by Autodesk.
*/

#pragma once

#include "gwnavruntime/base/types.h"
#include <stdarg.h>
#include <stdio.h>

namespace Kaim
{

struct StringSpan
{
    StringSpan() : ptr(nullptr), size(0) {}
    StringSpan(const char* ptr_, size_t size_) : ptr(ptr_), size(size_) {}

    const char* begin() const { return ptr; }
    const char* end() const { return ptr + size; }
    const char* pastend() const { return  ptr + size + 1; }

    const char* ptr;
    size_t size; // "abc" length is 3
};

struct StringSplitSpan
{
    StringSplitSpan(const char* ptr_, size_t size_, bool found_) : span(ptr_, size_), found(found_) {}

    const char* ptr() const     { return span.ptr; }
    size_t size() const         { return span.size; }
    const char* begin() const   { return span.begin(); }
    const char* end() const     { return span.end(); }
    const char* pastend() const { return span.pastend(); }

    StringSpan span;
    bool found;
};

inline StringSplitSpan StringSplitFirst(const char* ptr, const char* delimiters)
{
    for (size_t idx = 0; ; ++idx)
    {
        char c = ptr[idx];
        if (c == '\0')
            return StringSplitSpan(ptr, idx, false);

        for (size_t d = 0; ; ++d)
        {
            char s = delimiters[d];
            if (s == '\0')
                break;

            if (c == s)
                return StringSplitSpan(ptr, idx, true);
        }
    }
}



enum class StringSplitIgnoreEmpty { No, Yes };

template <typename F>
inline size_t StringSplit(const char* ptr, const char* delimiters, const F& callable, StringSplitIgnoreEmpty ignoreEmpty = StringSplitIgnoreEmpty::Yes)
{
    size_t count = 0;
    for (;;)
    {
        auto split = StringSplitFirst(ptr, delimiters);

        if (ignoreEmpty == StringSplitIgnoreEmpty::No || split.size() != 0)
        {
            callable(split.span);
            ++count;
        }

        if (split.found == false)
            break;

        ptr = split.pastend();
    }

    return count;
}

inline size_t StringPrintV(char* buffer, size_t buffer_size, const char* format, va_list vlist)
{
    // because vsnprintf is not supported by msvc prior to vc14 aka vs2015
#if defined(KY_CC_MSVC) && KY_CC_MSVC < 1900 // < vc14 aka vs2015
    int length = -1;
    if (buffer_size != 0)
        length = _vsnprintf_s(buffer, buffer_size, _TRUNCATE, format, vlist);
    if (length == -1)
        length = _vscprintf(format, vlist);
#else
    // http://en.cppreference.com/w/cpp/io/c/vfprintf
    // returns the number of chars that would have been written if buffer_size was large enough (not including the terminating null character) or a negative value if an error occurred.
    int length = vsnprintf(buffer, buffer_size, format, vlist);
#endif

    if (length < 0)
        return 0;

    if (((size_t)length) >= buffer_size)
        return buffer_size - 1;

    return (size_t)length;
}

inline size_t StringPrint(char* buffer, size_t buffer_size, const char* format, ...)
{
    va_list vlist;
    va_start(vlist, format);
    size_t length = StringPrintV(buffer, buffer_size, format, vlist);
    va_end(vlist);
    return length;
}

template<size_t N>
inline size_t StringPrint(char (&buffer)[N], const char* format, ...)
{
    va_list vlist;
    va_start(vlist, format);
    size_t length = StringPrintV(buffer, N, format, vlist);
    va_end(vlist);
    return length;
}

template<int ByteSize>
struct StringFmt
{
    StringFmt(const char* format, ...)
    {
        va_list args_list;
        va_start(args_list, format);
        length = StringPrintV(str, ByteSize, format, args_list);
        va_end(args_list);
    }

    StringSpan Span() const { return StringSpan(str, length); }

    char str[ByteSize];
    size_t length; // "abc" length is 3
};


} // namespace Kaim