Line data    Source code

       1             : /* File: utf8string.inl; Copyright and License: see below */
       2             : 
       3             : #include "utf8stringbuf/utf8codepoint.h"
       4             : #include <string.h>
       5             : #include <stdio.h>
       6             : #include <stdint.h>
       7             : #include <stdlib.h>
       8             : #include <errno.h>
       9             : 
      10             : #ifdef __cplusplus
      11             : extern "C" {
      12             : #endif
      13             : 
      14             : /*!
      15             :  *  \enum utf8string_bool_enum
      16             :  *  \private
      17             :  */
      18             : /*  enumeration for true and false or success and failure */
      19             : enum utf8string_bool_enum {UTF8STRING_FALSE=0, UTF8STRING_TRUE=1,};
      20             : 
      21          28 : static inline size_t utf8string_get_size( utf8string_t *this_ ) {
      22          28 :     size_t sizeResult = 0;
      23          28 :     if ( this_ != NULL ) {
      24          26 :         sizeResult = strlen( this_ ) + 1; /* 1 for size of terminating 0 character */
      25             :     }
      26          28 :     return sizeResult;
      27             : }
      28             : 
      29         263 : static inline unsigned int utf8string_get_length( utf8string_t *this_ ) {
      30         263 :     unsigned int lenResult = 0;
      31         263 :     if ( this_ != NULL ) {
      32         262 :         lenResult = strlen( this_ );
      33             :     }
      34         263 :     return lenResult;
      35             : }
      36             : 
      37          96 : static inline int utf8string_equals_str( utf8string_t *this_, utf8string_t *that ) {
      38          96 :     int cmpResult = -1;
      39          96 :     if (( this_ != NULL ) && ( that != NULL )) {
      40          93 :         cmpResult = strcmp( this_, that );
      41             :     }
      42          96 :     return ( cmpResult == 0 ) ? UTF8STRING_TRUE : UTF8STRING_FALSE;
      43             : }
      44             : 
      45          54 : static inline int utf8string_starts_with_str( utf8string_t *this_, utf8string_t *that ) {
      46          54 :     int cmpResult = -1;
      47          54 :     if (( this_ != NULL )&&( that != NULL )) {
      48          51 :         unsigned int thatLen = strlen( that );
      49          51 :         cmpResult = strncmp( this_, that, thatLen );
      50             :     }
      51          54 :     return ( cmpResult == 0 ) ? UTF8STRING_TRUE : UTF8STRING_FALSE;
      52             : }
      53             : 
      54          12 : static inline int utf8string_ends_with_str( utf8string_t *this_, utf8string_t *that ) {
      55          12 :     int cmpResult = -1;
      56          12 :     if (( this_ != NULL )&&( that != NULL )) {
      57           9 :         unsigned int thatLen = strlen( that );
      58           9 :         unsigned int thisLen = strlen( this_ );
      59           9 :         if ( thatLen <= thisLen ) {
      60           8 :             cmpResult = memcmp( &(this_[thisLen-thatLen]), that, thatLen );
      61             :         }
      62             :     }
      63          12 :     return ( cmpResult == 0 ) ? UTF8STRING_TRUE : UTF8STRING_FALSE;
      64             : }
      65             : 
      66           7 : static inline bool utf8string_contains_str( utf8string_t *this_, utf8string_t *pattern ) {
      67           7 :     bool result = false;
      68           7 :     if (( pattern != NULL )&&( this_ != NULL )) {
      69           4 :         const char *ptrResult = strstr( this_, pattern );
      70           4 :         if ( ptrResult != NULL ) {
      71           2 :             result = true;
      72             :         }
      73             :     }
      74           7 :     return result;
      75             : }
      76             : 
      77          22 : static inline utf8codepoint_t utf8string_get_char_at( utf8string_t *this_, unsigned int byte_index ) {
      78          22 :     utf8codepoint_t result = UTF8CODEPOINT_INVAL_CHAR;
      79          22 :     unsigned int thisSize = utf8string_get_size( this_ );
      80          22 :     if ( byte_index < thisSize ) {
      81          20 :         result = utf8codepoint_new( &(this_[byte_index]), thisSize-byte_index );
      82             :     }
      83          22 :     return result;
      84             : }
      85             : 
      86             : #ifdef __cplusplus
      87             : }
      88             : #endif
      89             : 
      90             : 
      91             : /*
      92             :  * Copyright 2012-2025 Andreas Warnke
      93             :  *
      94             :  * Licensed under the Apache License, Version 2.0 (the "License");
      95             :  * you may not use this file except in compliance with the License.
      96             :  * You may obtain a copy of the License at
      97             :  *
      98             :  *    http://www.apache.org/licenses/LICENSE-2.0
      99             :  *
     100             :  * Unless required by applicable law or agreed to in writing, software
     101             :  * distributed under the License is distributed on an "AS IS" BASIS,
     102             :  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     103             :  * See the License for the specific language governing permissions and
     104             :  * limitations under the License.
     105             :  */