StringHelpers.h

Go to the documentation of this file.

#ifndef STRINGHELPERSH_H
#define STRINGHELPERSH_H

#ifndef HELPERS_IMP_EXP
    #ifdef VRECKO_LIBRARY
        #define HELPERS_IMP_EXP __declspec(dllexport)
    #else
        #define HELPERS_IMP_EXP __declspec(dllimport)
    #endif
#endif


#if defined(__linux__)
    #ifndef _itoa
        #define _itoa   itoa
        HELPERS_IMP_EXP char *strrev(char *str);
        HELPERS_IMP_EXP char* itoa(int value, char*  str, int radix);
    #endif
#endif

/* Is a string beginning with another specified string? */
HELPERS_IMP_EXP bool isBeginningWith(const char *fullString, const char *beginString);



inline char*  uniCpy(char* str1, const char* str2) { return strcpy(str1, str2); }
inline WCHAR* uniCpy(WCHAR* str1, const WCHAR* str2) { return wcscpy(str1, str2); }
inline char*  uniNCpy(char* str1, const char* str2, size_t count) { return strncpy(str1, str2, count); }
inline WCHAR* uniNCpy(WCHAR* str1, const WCHAR* str2, size_t count) { return wcsncpy(str1, str2, count); }
inline char*  uniCat(char* str1, const char* str2) { return strcat(str1, str2); }
inline WCHAR* uniCat(WCHAR* str1, const WCHAR* str2) { return wcscat(str1, str2); }
inline const char*  uniStr(const char* str1, const char* str2) { return strstr(str1, str2); }
inline const WCHAR* uniStr(const WCHAR* str1, const WCHAR* str2) { return wcsstr(str1, str2); }
inline char*  uniStr(char* str1, const char* str2) { return strstr(str1, str2); }
inline WCHAR* uniStr(WCHAR* str1, const WCHAR* str2) { return wcsstr(str1, str2); }
inline size_t uniLen(const char* str1) { return strlen(str1); }
inline size_t uniLen(const WCHAR* str1) { return wcslen(str1); }



template <class _Type>
void getFileNameFromPathFile(_Type* outFile, const _Type* inPath, const _Type* inFile)
    // Adds together the path and the file name (containing absolute, relative or no path) using common rules.
 {
    int i;
    _Type backslashStr[2] = {'\\', 0x00};
    _Type colonStr[2] = {':', 0x00};

    if ((inFile[0] == '\\') || (inFile[0] == '/')) {
        // root directory (but might be on non-current disk)
        uniCpy(outFile, inPath);
        i = (int)uniLen(outFile) - 1;
        while (i >= 0) {
            if (outFile[i] == ':')
                break;
            --i;
        }
        outFile[i + 1] = 0;

        uniCat(outFile, inFile);
    } else if (uniStr(inFile, colonStr)) {
        // full path including the disk
        uniCpy(outFile, inFile);
    } else {
        uniCpy(outFile, inPath);
        i = (int)uniLen(outFile);
        if ((i > 0) && (outFile[i - 1] != '\\') && (outFile[i - 1] != '/'))
            uniCat(outFile, backslashStr);
        uniCat(outFile, inFile);
    }
}


template <class _Type>
void getRelativePath(_Type *outPathFile, const _Type *inPath, const _Type *inPathFile)
    // Adjusts the [inPathFile] to be a path relative to [inPath]
{
    int i;

    _Type tmpInPath[1000];
    strcpy (tmpInPath, inPath);
    i  = uniLen(tmpInPath);
    if ((i <= 0) || ((tmpInPath[i - 1] != '\\') && (tmpInPath[i - 1] != '/'))) {
        // we require terminating backslash at the end of the input path
        tmpInPath[i] = '\\';
        tmpInPath[i + 1] = 0x00;
    }

    _Type tmpPath[1000];
    getFileNameFromPathFile(tmpPath, inPath, inPathFile);

    int inPos = 0;
    while ((tmpInPath[inPos] != 0x00) && (tolower(tmpInPath[inPos]) == tolower(tmpPath[inPos]))) {
        // find the first difference or the end of either string
        ++inPos;
    }

    if (tmpInPath[inPos] == 0x00) {
        // in-path ended first (or both paths ended). The specified directory/file is in the (sub)directory of the in-path.
        if (tmpPath[inPos] == 0x00) {
            // Path with the specified directory/file ended too.
            // This means the user gave us exactly the main directory (with backslash at the end).
            outPathFile[0] = '.';
            outPathFile[1] = 0x00;
            return;
        }

        uniCpy(outPathFile, tmpPath + inPos);
        return;
    }

    
    // => The specified path lies outside the [inPath] directory.
    int outPos = 0;
    i = inPos;
    while (tmpInPath[i] != 0x00) {
        if ((tmpInPath[i] == '\\') || (tmpInPath[i] == '/')) {
            outPathFile[outPos] = '.';
            outPathFile[outPos + 1] = '.';
            outPathFile[outPos + 2] = '\\';
            outPos += 3;
        }
        ++i;
    }

    while ((inPos >= 0) && (tmpPath[inPos - 1] != '\\') && (tmpPath[inPos - 1] != '/')) {
        // find the beginning of the current directory
        --inPos;
    }

    uniCpy(outPathFile + outPos, tmpPath + inPos);
}


/*template <class _Type>
void getRelativePath(_Type* outPath, _Type* inPath, const _Type* basePath) {
    if (inPath != uniStr(inPath, basePath)) {
        uniCpy(outPath, inPath);
    } else {
        outPath[0] = 0;

        int i = (int)uniLen(basePath);
        int i2 = (int)uniLen(inPath);
        if ((i2 > i) && (basePath[i] == '\\')) {
            uniNCpy(outPath, inPath + i + 1, i2 - i - 1);
            outPath[i2 - i - 1] = 0;
        } else {
            uniNCpy(outPath, inPath + i, i2 - i);
            outPath[i2 - i] = 0;
        }
    }
}*/



template <class _Type>
void getFilePath(_Type* outPath, const _Type* inFile)
    // Will include the terminating '\\' (or will be completely empty)
{
    int i = (int)uniLen(inFile) - 1;
    while (i >= 0) {
        if ((inFile[i] == '\\') || (inFile[i] == '/')) {
            uniNCpy(outPath, inFile, i + 1);
            outPath[i + 1] = 0;
            return;
        }
        --i;
    }

    outPath[0] = 0;
}

template <class _Type>
void getFileNameWithoutPath(_Type* outFile, const _Type* inFile) {
    int i = (int)uniLen(inFile) - 1;
    while (i >= 0) {
        if ((inFile[i] == '\\') || (inFile[i] == '/')) {
            uniNCpy(outFile, inFile + i + 1, uniLen(inFile) - i - 1);
            outFile[uniLen(inFile) - i - 1] = 0;
            return;
        }
        --i;
    }
    uniCpy(outFile, inFile);
}


template <class _Type>
void getFileNameWithoutExt(_Type* outFile, const _Type* inFile)
    // Will NOT include the "."
{
    int i = (int)uniLen(inFile) - 1;
    while (i >= 0) {
        if ((inFile[i] == '\\') || (inFile[i] == '/'))
            // expecting '.', but found '\\' -> there was no extension
            break;

        if (inFile[i] == '.') {
            uniNCpy(outFile, inFile, i);
            outFile[i] = 0;
            return;
        }
        --i;
    }

    // no extension
    uniCpy(outFile, inFile);
}


template <class _Type>
void getFileExtension(_Type* outExt, const _Type* inFile)
    // Will NOT include the "."
{
    int i = (int)uniLen(inFile) - 1;
    while (i >= 0) {
        if ((inFile[i] == '\\') || (inFile[i] == '/'))
            // expected '.', but found '\\' -> there was no extension
            break;

        if (inFile[i] == '.') {
            uniNCpy(outExt, inFile + i + 1, uniLen(inFile) - i - 1);
            outExt[uniLen(inFile) - i - 1] = 0;
            return;
        }
        --i;
    }

    // no extension
    outExt[0] = 0;
}


#endif