stafstring.h

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

/* Returns: kSTAFOk on success                                         */
/*          other on error                                             */
/***********************************************************************/

STAFRC_t STAFStringByteIndexOfChar(STAFStringConst_t aString,
                                   unsigned int index,
                                   unsigned int *pos,
                                   unsigned int *osRC);

/***********************************************************************/
/* STAFStringIsCharsOfType - Checks a STAFString to be of a specific   */
/*                           character type (white, digits, ascii)     */
/*                                                                     */
/* Accepts: (In)  A STAFString_t                                       */
/*          (In)  A STAFUTF8CharType_t                                 */
/*          (Out) A pointer set to 0 if false, >0 if true              */
/*          (Out) A pointer to an OS return code (may be NULL)         */
/*                                                                     */
/* Returns: kSTAFOk on success                                         */
/*          other on error                                             */
/*                                                                     */
/* Note   : If the empty string is passed in as the first argument,    */
/*          the result of this function will always return kSTAFOk     */
/*          as we are considering the empty string to be a character   */
/*          of every type.                                             */
/***********************************************************************/

STAFRC_t STAFStringIsCharsOfType(STAFStringConst_t aFirst,
                                 const STAFUTF8CharType_t aType,
                                 unsigned int *result,
                                 unsigned int *osRC);

/***********************************************************************/
/* STAFStringIsEqualTo - Compares a STAFString to another STAFString   */
/*                                                                     */
/* Accepts: (In)  A STAFString_t                                       */
/*          (In)  A STAFString_t                                       */
/*          (In)  Case sensitivity indicator                           */
/*          (Out) A pointer set to 0 if different or >0 if equal       */
/*          (Out) A pointer to an OS return code (may be NULL)         */
/*                                                                     */
/* Returns: kSTAFOk on success                                         */
/*          other on error                                             */
/***********************************************************************/

STAFRC_t STAFStringIsEqualTo(STAFStringConst_t aFirst,
                             STAFStringConst_t aSecond,
                             STAFStringCaseSensitive_t sensitive,
                             unsigned int *comparison,
                             unsigned int *osRC);

/***********************************************************************/
/* STAFStringCompareTo - Determines whether a STAFString is greater    */
/*                       than another STAFString by byte comparison    */
/*                                                                     */
/* Accepts: (In)  A STAFString_t                                       */
/*          (In)  A STAFString_t                                       */
/*          (Out) A pointer to a int set to 1 if the first string is   */
/*                less than the second string, 0 if they are equal,    */
/*                or 2 if the second string is less than the first     */
/*          (Out) A pointer to an OS return code (may be NULL)         */
/*                                                                     */
/* Returns: kSTAFOk on success                                         */
/*          other on error                                             */
/***********************************************************************/

STAFRC_t STAFStringCompareTo(STAFStringConst_t aFirst,
                             STAFStringConst_t aSecond,
                             unsigned int *less,
                             unsigned int *osRC);

/***********************************************************************/
/* STAFStringCompareTo - Determines whether a STAFString is greater    */
/*                       than another STAFString by byte comparison    */
/*                                                                     */
/* Accepts: (In)  String to check                                      */
/*          (In)  Starts with string                                   */
/*          (Out) A pointer to a int set to 1 if the first string      */
/*                starts with the second string, and 0 if the first    */
/*                does not start with the second string                */
/*          (Out) A pointer to an OS return code (may be NULL)         */
/*                                                                     */
/* Returns: kSTAFOk on success                                         */
/*          other on error                                             */
/***********************************************************************/

STAFRC_t STAFStringStartsWith(STAFStringConst_t aString,
                              STAFStringConst_t startsWithString,
                              unsigned int *startsWith,
                              unsigned int *osRC);

/***********************************************************************/
/* STAFStringContainsWildcard - Determines whether a STAFString is     */
/*                              contains at least one wildcard         */
/*                              character                              */
/*                                                                     */
/* Accepts: (In)  A STAFString_t                                       */
/*          (Out) A pointer to a int set to 1 if the string contains   */
/*                at least one wildcard character, 0 if the string     */
/*                does not contain any wildcard characters             */
/*          (Out) A pointer to an OS return code (may be NULL)         */
/*                                                                     */
/* Returns: kSTAFOk on success                                         */
/*          other on error                                             */
/*                                                                     */
/* Note   : Two wildcard characters are understood: '*' and '?'        */
/***********************************************************************/

STAFRC_t STAFStringContainsWildcard(STAFStringConst_t aString,
                                    unsigned int *hasWildcard,
                                    unsigned int *osRC);

/***********************************************************************/
/* STAFStringMatchesWildcards - Determines whether a given STAFString  */
/*                              matches a given wildcard STAFString    */
/*                                                                     */
/* Accepts: (In)  String to check                                      */
/*          (In)  String containg wildcards                            */
/*          (In)  Case sensitivity indicator                           */
/*          (Out) Result of comparison (0 = no match, 1 = matches)     */
/*          (Out) A pointer to an OS return code (may be NULL)         */
/*                                                                     */
/* Returns: kSTAFOk on success                                         */
/*          other on error                                             */
/*                                                                     */
/* Note   : Two wildcard characters are understood.  '*' matches zero  */
/*          or more characters.  '?' matches one single character.     */
/***********************************************************************/

STAFRC_t STAFStringMatchesWildcards(STAFStringConst_t stringToCheck,
                                    STAFStringConst_t wildcardString,
                                    STAFStringCaseSensitive_t caseSensitive,
                                    unsigned int *matches,
                                    unsigned int *osRC);

/***********************************************************************/
/* STAFStringFind - Finds the first instance of a substring in a STAF- */
/*                  String                                             */
/*                                                                     */
/* Accepts: (In)  A STAFString_t                                       */
/*          (In)  A STAFString_t to look for                           */
/*          (In)  The char or byte index from where to start looking   */
/*          (In)  0->char index, 1->byte index                         */
/*          (Out) A pointer to a int set to the char or byte index of  */
/*                the entry found or 0xffffffff if not found           */
/*          (Out) A pointer to an OS return code (may be NULL)         */
/*                                                                     */
/* Returns: kSTAFOk on success                                         */
/*          other on error                                             */
/***********************************************************************/

STAFRC_t STAFStringFind(STAFStringConst_t aString,
                        STAFStringConst_t aSubStr,
                        unsigned int index, unsigned int corb,
                        unsigned int *pos,
                        unsigned int *osRC);

/***********************************************************************/
/* STAFStringFindFirstOf - Finds the first instance of a UTF-8 char in */
/*                         a set starting from a given char or byte    */
/*                         index                                       */
/*                                                                     */
/* Accepts: (In)  A STAFString_t                                       */
/*          (In)  A STAFString_t which is a set of chars to look for   */
/*          (In)  The char or byte index from where to start looking   */
/*          (In)  0->char index, 1->byte index                         */
/*          (Out) A pointer to a int set to the char or byte index of  */
/*                the entry found or 0xffffffff if not found           */
/*          (Out) A pointer to an OS return code (may be NULL)         */
/*                                                                     */
/* Returns: kSTAFOk on success                                         */
/*          other on error                                             */
/***********************************************************************/

STAFRC_t STAFStringFindFirstOf(STAFStringConst_t aString,
                               STAFStringConst_t aSet,
                               unsigned int index, unsigned int corb,
                               unsigned int *pos,
                               unsigned int *osRC);

/***********************************************************************/
/* STAFStringFindLastOf - Finds the last instance of a UTF-8 char in a */
/*                        set starting from a given char or byte index */
/*                                                                     */
/* Accepts: (In)  A STAFString_t                                       */
/*          (In)  A STAFString_t which is a set of chars to look for   */
/*          (In)  The char or byte index from where to start looking   */
/*          (In)  0->char index, 1->byte index                         */
/*          (Out) A pointer to a int set to the char or byte index of  */
/*                the entry found or 0xffffffff if not found           */
/*          (Out) A pointer to an OS return code (may be NULL)         */
/*                                                                     */
/* Returns: kSTAFOk on success                                         */
/*          other on error                                             */
/***********************************************************************/

STAFRC_t STAFStringFindLastOf(STAFStringConst_t aString,
                              STAFStringConst_t aSet,
                              unsigned int index, unsigned int corb,
                              unsigned int *pos,
                              unsigned int *osRC);

/***********************************************************************/
/* STAFStringFindFirstNotOf - Finds the first instance of a UTF-8 char */
/*                            not in set starting from a given char or */
/*                            byte index                               */
/*                                                                     */
/* Accepts: (In)  A STAFString_t                                       */
/*          (In)  A STAFString_t which is a set of chars to look for   */
/*          (In)  The char or byte index from where to start looking   */
/*          (In)  0->char index, 1->byte index                         */
/*          (Out) A pointer to a int set to the char or byte index of  */
/*                the entry found or 0xffffffff if not found           */
/*          (Out) A pointer to an OS return code (may be NULL)         */
/*                                                                     */
/* Returns: kSTAFOk on success                                         */
/*          other on error                                             */
/***********************************************************************/

STAFRC_t STAFStringFindFirstNotOf(STAFStringConst_t aString,
                                  STAFStringConst_t aSet,
                                  unsigned int index,
                                  unsigned int corb,
                                  unsigned int *pos,
                                  unsigned int *osRC);

/***********************************************************************/
/* STAFStringFindLastNotOf - Finds the last instance of a UTF-8 char   */
/*                           not in a set starting from a given char   */