/*
    str_replace:
        Case sensitive string replace

    Arguments:
        sSearch[]    String to search for
        sReplace[]   String to replace with
        sSubject[]   Original string
        (op) &iCount  How many times 'sSearch' has been replaced.

    Returns:
        Replaced string.
*/
native str_replace(sSearch[], sReplace[], const sSubject[], &iCount = 0)

/*
    str_ireplace:
        Case insensitive string replace

    Arguments:
        sSearch[]    String to search for
        sReplace[]   String to replace with
        sSubject[]   Original string
        (op) &iCount  How many times 'sSearch' has been replaced.

    Returns:
        Replaced string.
*/
native str_ireplace(sSearch[], sReplace[], const sSubject[], &iCount = 0)

/*
    str_pad:
        Pad a string with characters until the defined amount.

    Arguments:
        sSource[]     String input to pad.
        iPadLength    Pad to amount. If less than sSource, sSource is returned.
        (op) cPadChar  Character to use as padding.

    Returns:
        Padded string.
*/
native str_pad(const sSource[], iPadLength, cPadChar = ' ')

/*
    str_repeat:
        Repeats a string 'iMultiplier' times.

    Arguments:
        sSource[]   String to be repeated
        iMultiplier Amount of times to be repeated

    Returns:
        Repeated string.
*/
native str_repeat(const sSource[], iMultiplier)

/*
    str_rot13:
        Rotates alphabetical characters 13 characters along.

    Arguments:
        sSource[]   String to be rotated

    Returns:
        Rotated string.
*/
native str_rot13(const sSource[])

/*
    strtr:
        Removes 'sRemove' from the string and replaces
        that character from 'sReplace'.

    Arguments:
        sSource[]   String to be transformed
        sRemove[]  Characters to be removed (must be in same order as below!)
        sReplace[]  Characters to be replaced (must be in same order as above!)

    Returns:
        Trimmed string.
*/
native strtr(const sSource[], sRemove[], sReplace[])

/*
    substr:
        Gets a substring from a string.

    Arguments:
        sSource[]   String to be substring'd.
        iStart    Position for the start of substring.
        iLength    Position for the end of substring.
                (if negative, cells away from end)

    Returns:
        Substring.
*/
native substr(const sSource[], iStart, iLength = sizeof(sSource))

/*
    trim:
        Removes whitespace, tabs, and new lines
        from the beginning and end of 'sSource'.

    Arguments:
        sSource[]   String to be trimmed

    Returns:
        Trimmed string.
*/
native trim(const sSource[])

/*
    rtrim:
        Removes whitespace, tabs, and new lines
        from the end of 'sSource'.

    Arguments:
        sSource[]   String to be trimmed

    Returns:
        Trimmed string.
*/
native rtrim(const sSource[])

/*
    ltrim:
        Removes whitespace, tabs, and new lines
        from the beginning of 'sSource'.

    Arguments:
        sSource[]   String to be trimmed

    Returns:
        Trimmed string.
*/
native ltrim(const sSource[])

/*
    implode:
        Returns a string where the array has been stuck back together
        again.

    Arguments:
        aPieces[][]  The array to glue back together.
        sGlue     The string to use as the glue.

    Returns:
        The imploded string.
*/
native implode(const aPieces[][], const sGlue[] = " ")

/*
    explode:
        Creates an array of values from 'sSource', where only the exact amount of
        values matching sizeof(aExplode) are returned.

    Arguments:
        aExplode[][] The exploded array
        sSource[]   Source string.
        sDelimiter  The string to use as the delimiter.

    Returns:
        Returns -1 on failure, otherwise success.
*/
native explode(aExplode[][], sSource[], sDelimiter[] = " ")

/*
    explodea:
        Creates an array of values from 'sSource', where any overrun is stored in
        the final node.

    Arguments:
        aExplode[][] The exploded array
        sSource[]   Source string.
        sDelimiter  The string to use as the delimiter.

    Returns:
        Returns -1 on failure, otherwise success.
*/
native explodea(aExplode[][], sSource[], sDelimiter[] = " ")

/*
    str_in_array:
        Checks if a string matches any of the strings in the array.

    Arguments:
        sNeedle[]   String that is being matched.
        aHaystack[][] Array with strings to be searched,

    Returns:
        Returns true on a match.
*/
native str_in_array(sNeedle[], aHaystack[][])

explode(): 0860, explodea(): 0828, split(): 2187, ysi_explode(): 1922
explode(): 0766, explodea(): 0812, split(): 2156, ysi_explode(): 1875
explode(): 0735, explodea(): 0797, split(): 2187, ysi_explode(): 1875
explode(): 0719, explodea(): 0828, split(): 2172, ysi_explode(): 1859
explode(): 0735, explodea(): 0812, split(): 2891, ysi_explode(): 2531

str_replace(): 0266, dutils_strreplace(): 7125, dabombber_strreplace(): 0516
str_replace(): 0266, dutils_strreplace(): 6625, dabomber_strreplace(): 0484
str_replace(): 0266, dutils_strreplace(): 6328, dabomber_strreplace(): 0500
str_replace(): 0282, dutils_strreplace(): 6078, dabomber_strreplace(): 0515
str_replace(): 0266, dutils_strreplace(): 6703, dabomber_strreplace(): 0500

#define explode_(%1,%2, explode(%2,%1

#define explode_(%1,%2, chr_explode(%2,%1

/*
    explode:
        Creates an array of values from 'sSource', where only the exact amount of
        values matching sizeof(aExplode) are returned.

    Arguments:
        aExplode[][]  The exploded array
        sSource[]    Source string.
        sDelimiter   The string to use as the delimiter.
        iVertices    Vertices of aExplode, detected automatically.
        iLength     Length of a string in aExplode, detected automatically.

    Returns:
        Returns -1 on failure, otherwise success.
*/
stock explode(aExplode[][], sSource[], const sDelimiter[] = " ", iVertices = sizeof aExplode, iLength = sizeof aExplode[])
{
    strins(sSource, sDelimiter, strlen(sSource), 28);
    new
        iNode,
        iPointer,
        iPrevious = -1,
        iDelimiter = strlen(sDelimiter);
    
    while(iNode < iVertices)
    {
        iPointer = strfind(sSource, sDelimiter, false, iPointer);

        if(iPointer == -1)
        {
            strmid(aExplode[iNode], sSource, iPrevious, iLength, iLength);
            break;
        }
        else
        {
            strmid(aExplode[iNode], sSource, iPrevious, iPointer, iLength);
        }
        
        iPrevious = (iPointer += iDelimiter);
        ++iNode;
    }
    
    return iPrevious;
}

main()
{
    print(str_replace("dog", "cat", "dog dog dog dog"));
    // Returns: cat cat cat dog
}