stafstring.cpp

Software Testing Automation Framework (STAF)的开发代码

    if (aInOutStr == 0 || side > 2) return kSTAFInvalidObject;

    // if 0 then left, if 1 then right, if 2 then both

    char *ptr = 0;
    char *lim = 0;

    if (aInOutStr->pBuffer == 0) return kSTAFOk;

    if (side == 1 || side == 2)
    {
        ptr = aInOutStr->pBuffer + aInOutStr->fByteLen;
        ptr = PREV(ptr);
        lim = aInOutStr->pBuffer;

        switch (aType)
        {
            case kUTF8_TYPE_WHITESPACE:
        
            while (ptr >= lim && WHITESPACE(ptr))
            {
                aInOutStr->fByteLen -= BYTES(ptr);
                aInOutStr->fCharLen--;
                ptr = PREV(ptr);
            }
            break;

            case kUTF8_TYPE_SPACE:
        
            while (ptr >= lim && SPACE(ptr))
            {
                aInOutStr->fByteLen -= BYTES(ptr);
                aInOutStr->fCharLen--;
                ptr = PREV(ptr);
            }
            break;
            
            case kUTF8_TYPE_ASCII:
        
            while (ptr >= lim && ASCII(ptr))
            {
                aInOutStr->fByteLen -= BYTES(ptr);
                aInOutStr->fCharLen--;
                ptr = PREV(ptr);
            }
            break;

            case kUTF8_TYPE_DIGIT:
        
            while (ptr >= lim && DIGIT(ptr))
            {
                aInOutStr->fByteLen -= BYTES(ptr);
                aInOutStr->fCharLen--;
                ptr = PREV(ptr);
            }
            break;

            default:
            break;
        }
    }

    if (side == 0 || side == 2)
    {
        ptr = aInOutStr->pBuffer;
        lim = aInOutStr->pBuffer + aInOutStr->fByteLen;

        switch (aType)
        {
            case kUTF8_TYPE_WHITESPACE:

            while (ptr < lim && WHITESPACE(ptr)) 
            {
                aInOutStr->fByteLen -= BYTES(ptr);
                aInOutStr->fCharLen--;
                ptr = NEXT(ptr);
            }
            break;

            case kUTF8_TYPE_SPACE:

            while (ptr < lim && SPACE(ptr)) 
            {
                aInOutStr->fByteLen -= BYTES(ptr);
                aInOutStr->fCharLen--;
                ptr = NEXT(ptr);
            }
            break;

            case kUTF8_TYPE_ASCII:

            while (ptr < lim && ASCII(ptr)) 
            {
                aInOutStr->fByteLen -= BYTES(ptr);
                aInOutStr->fCharLen--;
                ptr = NEXT(ptr);
            }
            break;

            case kUTF8_TYPE_DIGIT:

            while (ptr < lim && DIGIT(ptr)) 
            {
                aInOutStr->fByteLen -= BYTES(ptr);
                aInOutStr->fCharLen--;
                ptr = NEXT(ptr);
            }
            break;
        
            default:
            break;
        }

        memmove(aInOutStr->pBuffer, ptr, aInOutStr->fByteLen);
    }

    return kSTAFOk;
}


STAFRC_t STAFStringToUInt(STAFStringConst_t aString, unsigned int *value,
                          unsigned int base, unsigned int *osRC)
{
    if (aString == 0) return kSTAFInvalidObject;

    if (value == 0 || base == 0 || base > 16) return kSTAFInvalidParm;

    char *ptr = aString->pBuffer + aString->fByteLen - 1;
    unsigned int dig, mult = 1;

    *value = 0;

    // go to the last digit and work backwards

    while (ptr >= aString->pBuffer)
    {
        // if it's an ASCII A..F (or a..f) convert to its numeric value

        if ( ((*ptr | 0x20) >= 0x61) && ((*ptr | 0x20) <= 0x66) )
            dig = (*ptr | 0x20) - 0x57;  // A = 10, B = 11, ... and so on
        else if ( (*ptr >= 0x30) && (*ptr <= 0x39) )
            dig = *ptr - 0x30;  // '0' = 0, '1' = 1, ... and so on
        else
            return kSTAFInvalidValue;

        // if it's an invalid digit for this base then error

        if (dig >= base) return kSTAFInvalidParm;  // invalid argument

        *value += (dig * mult);
        mult *= base;
        ptr--;
    }

    return kSTAFOk;
}


STAFRC_t STAFStringLength(STAFStringConst_t aString, unsigned int *len,
                          unsigned int corb, unsigned int *osRC)
{
    if (aString == 0) return kSTAFInvalidObject;

    if (len == 0) return kSTAFInvalidParm;

    *len = (corb ? aString->fByteLen : aString->fCharLen);

    return kSTAFOk;
}


STAFRC_t STAFStringSizeOfChar(STAFStringConst_t aString, 
                              unsigned int index,
                              unsigned int corb, 
                              unsigned int *len, unsigned int *osRC)
{ 
    if (aString == 0) return kSTAFInvalidObject;

    if (len == 0) return kSTAFInvalidParm;

    char *ptr = aString->pBuffer;
    char *lim = aString->pBuffer + aString->fByteLen;

    *len = 0;  // default to 0 (helps on error)

    // if index is beyond string's length, return error
 
    if (index >= (corb ? aString->fByteLen : aString->fCharLen))
        return kSTAFInvalidObject;  // invalid argument

    ptr = FWDN(ptr, index, corb);

    *len = BYTES(ptr);
    
    return kSTAFOk;
}


STAFRC_t STAFStringByteIndexOfChar(STAFStringConst_t aString, 
                                   unsigned int index, unsigned int *pos, 
                                   unsigned int *osRC)
{
    if (aString == 0) return kSTAFInvalidObject;

    if (pos == 0) return kSTAFInvalidParm;

    char *ptr = aString->pBuffer;
    char *lim = aString->pBuffer + aString->fByteLen;

    *pos = 0xffffffff;  // default to not found
 
    // if index is beyond string's length, return error
 
    if (index >= aString->fCharLen)
        return kSTAFInvalidObject;  // invalid argument

    ptr = FWDC(ptr, index);

    *pos = ptr - aString->pBuffer;

    return kSTAFOk;
}


STAFRC_t STAFStringIsCharsOfType(STAFStringConst_t aString,
                                 const STAFUTF8CharType_t aType,
                                 unsigned int *result,
                                 unsigned int *osRC)
{
    if (aString == 0) return kSTAFInvalidObject;

    if (result == 0) return kSTAFInvalidParm;

    char *ptr = aString->pBuffer;
    char *lim = aString->pBuffer + aString->fByteLen;

    *result = 0;  // default to false

    switch (aType)
    {
        case kUTF8_TYPE_WHITESPACE:

            while (ptr < lim && WHITESPACE(ptr))
                ptr = NEXT(ptr);

            if (ptr >= lim)
                *result = 1;
                    
            break;

        case kUTF8_TYPE_SPACE:

            while (ptr < lim && SPACE(ptr))
                ptr = NEXT(ptr);

            if (ptr >= lim)
                *result = 1;
                    
            break;

        case kUTF8_TYPE_ASCII:

            while (ptr < lim && ASCII(ptr))
                ptr = NEXT(ptr);
            
            if (ptr >= lim)
                *result = 1;

            break;

        case kUTF8_TYPE_DIGIT:

            while (ptr < lim && DIGIT(ptr))
                ptr = NEXT(ptr);
            
            if (ptr >= lim)
                *result = 1;

            break;
 
        default:
            break;
    }

    return kSTAFOk;
}

STAFRC_t STAFStringIsEqualTo(STAFStringConst_t aFirst,
                             STAFStringConst_t aSecond,
                             STAFStringCaseSensitive_t sensitive,
                             unsigned int *comparison,
                             unsigned int *osRC)
{
    if ((aFirst == 0) || (aSecond == 0)) return kSTAFInvalidObject;

    if (comparison == 0) return kSTAFInvalidParm;

    *comparison = 1;  // default to true

    if ( (aFirst->fByteLen != aSecond->fByteLen) ||
         (aFirst->fCharLen != aSecond->fCharLen) )
    {
        // different
        *comparison = 0;
    }
    else if (sensitive == kSTAFStringCaseInsensitive)  // case insensitive
    {
        char *ptr1, *ptr2, *lim1;

        ptr1 = aFirst->pBuffer;
        ptr2 = aSecond->pBuffer;
        lim1 = aFirst->pBuffer + aFirst->fByteLen;

        while (ptr1 < lim1 && *comparison)
        {
            if ( (*ptr1 >= 0x41 && *ptr1 <= 0x5a) ||
                 (*ptr1 >= 0x61 && *ptr1 <= 0x7a) )
            {
                if ((*ptr1 | 0x20) != (*ptr2 | 0x20))
                    *comparison = 0;
            }
            else if (*ptr1 != *ptr2) *comparison = 0;

            ptr1 = NEXT(ptr1);
            ptr2 = NEXT(ptr2);
        }
    }
    else  // case sensitive, just do a memory comparison
    {
        if (memcmp(aFirst->pBuffer, aSecond->pBuffer, aFirst->fByteLen))
            *comparison = 0;
    }

    return kSTAFOk;
}


STAFRC_t STAFStringCompareTo(STAFStringConst_t aFirst,
                             STAFStringConst_t aSecond,
                             unsigned int *whichLess,
                             unsigned int *osRC)
{
    if ((aFirst == 0) || (aSecond == 0)) return kSTAFInvalidObject;

    if (whichLess == 0) return kSTAFInvalidParm;

    unsigned int min = (aFirst->fByteLen <= aSecond->fByteLen ? 
                        aFirst->fByteLen : aSecond->fByteLen);

    int cmp = memcmp(aFirst->pBuffer, aSecond->pBuffer, min);

    if (cmp <  0) 
        *whichLess = 1;  // first one is less 
    else if (cmp == 0) 
    {
        // must actually ensure that sizes were equal, otherwise
        // mark the shorter one as being the "less" one

        if (aFirst->fByteLen == aSecond->fByteLen)
            *whichLess = 0;  // both are equal
        else if (aFirst->fByteLen < aSecond->fByteLen)
            *whichLess = 1;  // first one is less
        else 
            *whichLess = 2;  // second one is less
    }
    else if (cmp >  0) 
        *whichLess = 2;  // second one is less

    return kSTAFOk;
}


STAFRC_t STAFStringStartsWith(STAFStringConst_t aString,
                              STAFStringConst_t startsWithString,
                              unsigned int *startsWith,
                              unsigned int *osRC)
{
    if ((aString == 0) || (startsWithString == 0)) return kSTAFInvalidObject;

    if (startsWith == 0) return kSTAFInvalidParm;

    *startsWith = 0;

    if (aString->fByteLen >= startsWithString->fByteLen)
    {
        int cmp = memcmp(aString->pBuffer, startsWithString->pBuffer,
                         startsWithString->fByteLen);

        if (cmp == 0) *startsWith = 1;
    }

    return kSTAFOk;
}


STAFRC_t STAFStringContainsWildcard(STAFStringConst_t aString,
                                    unsigned int *hasWildcard,
                                    unsigned int *osRC)
{
    if (aString == 0) return kSTAFInvalidObject;

    if (hasWildcard == 0) return kSTAFInvalidParm;

    *hasWildcard = 0;  // Default to does not contain a wildcard

    unsigned int theIndex = 0;

    STAFRC_t rc = STAFStringFindFirstOf(aString, sWildCards.getImpl(),
                                        0, 0, &theIndex, osRC);

    if ((rc == 0) && (theIndex != 0xffffffff))
        *hasWildcard = 1;   // Contains a wildcard

    return rc;
}


STAFRC_t STAFStringMatchesWildcards(STAFStringConst_t stringToCheck,
                                    STAFStringConst_t wildcardString,
                                    STAFStringCaseSensitive_t caseSensitive,
                                    unsigned int *matches,
                                    unsigned int *osRC)
{
    if (stringToCheck == 0) return kSTAFInvalidObject;

    if (matches == 0) return kSTAFInvalidParm;

    STAFRC_t retCode = kSTAFOk;

    try
    {