helpers.cpp

Go to the documentation of this file.

namespace krotos
{
    namespace utils
    {
        std::string HttpDateToISO8601(const std::string& httpDate)
        {
            // HTTP date format:
            // Weekday, DD Mon YYYY HH:MM:SS GMT
 
            if (httpDate.empty())
            {
                return std::string("");
            }
 
            const std::string months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
                                          "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
 
            std::tm t = {};
 
            // Parse DD
            std::string day = httpDate.substr(5, 2);
            t.tm_mday = std::stoi(day);
 
            // Parse Mon
            std::string monthStr = httpDate.substr(8, 3);
            int monthIndex = -1;
            for (int i = 0; i < 12; i++)
            {
                if (months[i] == monthStr)
                {
                    monthIndex = i;
                    break;
                }
            }
 
            if (monthIndex >= 0 && monthIndex <= 11)
            {
                t.tm_mon = monthIndex;
            }
 
            // Parse YYYY
            std::string year = httpDate.substr(12, 4);
            t.tm_year = std::stoi(year) - 1900;
 
            // Parse HH:MM:SS
            std::string time = httpDate.substr(17, 8);
            std::string hour = time.substr(0, 2);
            std::string min = time.substr(3, 2);
            std::string sec = time.substr(6, 2);
 
            t.tm_hour = std::stoi(hour);
            t.tm_min = std::stoi(min);
            t.tm_sec = std::stoi(sec);
 
            // Convert to ISO 8601 format
            std::stringstream ss;
            ss << std::put_time(&t, "%FT%TZ");
 
            return ss.str();
        }
 
        StringArray getVersionSegments(StringRef p)
        {
            auto segments = StringArray::fromTokens(p, ",.", "");
            segments.trim();
            segments.removeEmptyStrings();
            return segments;
        }
 
        int getVersionAsHexIntegerFromParts(const StringArray& segments)
        {
            int value;
            if (segments.size() == 2)
            {
                value = (segments[0].getIntValue() << 8) + segments[1].getIntValue();
            }
            else
            {
                value = (segments[0].getIntValue() << 16) + (segments[1].getIntValue() << 8) +
                        segments[2].getIntValue();
            }
 
            return value;
        }
 
        int getVersionAsHexInteger(StringRef versionString)
        {
            return getVersionAsHexIntegerFromParts(getVersionSegments(versionString));
        }
 
        static bool compareFloats(const float& a, const float& b) { return a < b; }
 
        String ellipsizeStringToWidth(const Font& font, const String& input, const int maxWidth)
        {
            // If the input width is zero or less, we return an empty string
            if (maxWidth <= 0)
            {
                return String();
            }
            float widthMax = static_cast<float>(maxWidth);
            Array<int> glyphs;
            Array<float> xOffsets;
            font.getGlyphPositions(input, glyphs, xOffsets);
            float inputStringWidth = xOffsets.getLast();
            // If the input string fits within the supplied max width, we can return it unchanged
            if (inputStringWidth <= widthMax)
            {
                return input;
            }
            const String ellipsis = "..."; // Define the ellipsis which we will use to join the halves
            const float ellipsisWidth = font.getStringWidthFloat(ellipsis);
            const float halfStringWidth = (widthMax - ellipsisWidth) * 0.5f;
            const float startOfSecondHalf = inputStringWidth - halfStringWidth;
            // Find the index of the first array member to exceed halfStringWidth
            // Couldn't use Array::indexOfSorted because it requires an exact match
            // std::lower_bound uses a binary chop, so should be efficient
            const int indexEndOfFirstHalf = static_cast<int>(
                    std::lower_bound(xOffsets.begin(), xOffsets.end(), halfStringWidth, &compareFloats) -
                    xOffsets.begin());
            // Find the index of the first array member to exceed startOfSecondHalf
            const int indexStartOfSecondHalf = static_cast<int>(
                    std::lower_bound(xOffsets.begin(), xOffsets.end(), startOfSecondHalf, &compareFloats) -
                    xOffsets.begin());
            // Join the fist and second halves together with the ellipsis in the middle
            return input.substring(0, indexEndOfFirstHalf - 1) + ellipsis +
                   input.substring(indexStartOfSecondHalf, input.length());
        }
 
        String convertFilePathString(const String& inputPath)
        {
            String result = inputPath;
#if JUCE_WINDOWS
            if (inputPath.containsChar('/'))
            {
                // replace / with \\ for windows
                result = inputPath.replaceCharacter('/', '\\');
            }
#elif JUCE_MAC
            if (inputPath.containsChar('\\'))
            {
                // replace \\ with / for mac
                result = inputPath.replaceCharacter('\\', '/');
            }
#endif
            return result;
        }
 
        void hexStringToByteArray(const std::string& input, std::vector<unsigned char>& byteArray)
        {
            // validate input string contains hex characters only
            if (!std::all_of(input.begin(), input.end(), [](unsigned char c){ return std::isxdigit(c); }))
            {
                throw std::invalid_argument("Input string contains invalid hexadecimal characters.");
            }
 
            // Resize the byte array to half the size of the input string, adding an extra byte for odd-length input
            // strings
            byteArray.resize((input.length() % 2 != 0 ? input.length() + 1 : input.length()) / 2);
 
            for (size_t i = 0, j = 0; i < input.length(); i += 2, j++)
            {
                // Add padding for odd-length input strings
                std::string byteStr = i + 1 < input.length() ? input.substr(i, 2) : input.substr(i, 1) + "0";
                unsigned int byteValue;
                std::istringstream(byteStr) >> std::hex >> byteValue;
                byteArray[j] = static_cast<unsigned char>(byteValue);
            }
        }
 
    } // namespace utils
} // namespace krotos