void GSimpStringCopy(GSimpStringPtr ssp, GSimpStringPtr source)
{
Assert( ssp != NULL );
Assert( source != NULL );
setGSimpStringWithContent(ssp, source->Str, source->Len);
}
static GSimpStringPtr stringToGSimpString(const char *str)
{
char *tempStr = (char *)malloc(strlen(str) + 1);
if ( tempStr == NULL )
{
write_log("%s Function malloc in stringToGSimpleString out of memory",
ENFORCER_MESSAGE_HEAD);
return NULL;
}
strncpy(tempStr, str, strlen(str)+1);
GSimpStringPtr simpStr = createGSimpString();
if ( simpStr == NULL )
{
free(tempStr);
write_log("%s Function createGSimpString in stringToGSimpleStringi out of memory",
ENFORCER_MESSAGE_HEAD);
return NULL;
}
if ( setGSimpStringWithContent(simpStr, tempStr, strlen(str)) != FUNC_RETURN_OK )
{
free(tempStr);
free(simpStr);
write_log("%s Function setGSimpStringWithContent in stringToGSimpleStringi out of memory",
ENFORCER_MESSAGE_HEAD);
return NULL;
}
free(tempStr);
return simpStr;
}
int GSimpStringReplaceFirst(GSimpStringPtr ssp, char *oldstr, char *newstr)
{
Assert( ssp );
Assert( oldstr );
Assert( newstr );
char *pos = strstr(ssp->Str, oldstr);
/* If the old string does not exist, no need to do any update. */
if ( pos == NULL )
{
return FUNC_RETURN_OK;
}
int nlen = ssp->Len + strlen(newstr) - strlen(oldstr);
char *buf = (char *)malloc(nlen+1);
if ( buf == NULL )
{
write_log("Function GSimpStringReplaceFirst out of memory");
return UTIL_SIMPSTRING_OUT_OF_MEMORY;
}
memset(buf, 0, sizeof(char)*(nlen+1));
int tlen1 = pos - ssp->Str;
if ( tlen1 > 0 )
{
strncpy(buf, ssp->Str, tlen1);
buf[tlen1] = '\0';
}
strncpy(buf + tlen1, newstr, strlen(newstr));
int tlen2 = tlen1 + strlen(oldstr);
int tlen3 = tlen1 + strlen(newstr);
if ( tlen2 < ssp->Len )
{
strncpy(buf + tlen3,
ssp->Str + tlen2,
ssp->Len - tlen2);
}
buf[nlen] = '\0';
setGSimpStringWithContent(ssp, buf, nlen);
free(buf);
return FUNC_RETURN_OK;
}
int GSimpStringTokens(GSimpStringPtr ssp,
char split,
GSimpStringPtr *tokens,
int *tokensize)
{
Assert( ssp );
Assert( tokens );
Assert( tokensize );
if ( ssp->Str == NULL || ssp->Len == 0 )
{
*tokens = NULL;
*tokensize = 0;
return FUNC_RETURN_OK;
}
*tokensize = 1;
for( int i = 0 ; i < ssp->Len ; ++i )
{
if ( ssp->Str[i] == split )
{
(*tokensize)++;
}
}
*tokens = malloc(sizeof(GSimpString) * (*tokensize));
if ( *tokens == NULL )
{
write_log("Function GSimpStringTokens out of memory");
return UTIL_SIMPSTRING_OUT_OF_MEMORY;
}
char *prevp = ssp->Str;
char *p = ssp->Str;
for ( int i = 0 ; i < *tokensize ; ++i )
{
while( *p != split && *p != '\0' )
{
p++;
}
initGSimpString(&((*tokens)[i]));
setGSimpStringWithContent(&((*tokens)[i]), prevp, p-prevp);
p++;
prevp = p;
}
return FUNC_RETURN_OK;
}
int GSimpStringSubstring(GSimpStringPtr ssp,
int start,
int end,
GSimpStringPtr target)
{
Assert( ssp != NULL );
Assert( target != NULL );
/* If end == -1, the substring ends till the end of source string. */
Assert( start >= 0 && ((end > 0 && end > start) || (end == -1)));
int newlen = end == -1 ? (ssp->Len)-start : end-start;
/* Check and alloc target string space. */
setGSimpStringWithContent( target,
(ssp->Str)+start,
newlen);
return newlen;
}
void initGSimpStringWithContent(GSimpStringPtr ssp, char *content, int length)
{
Assert( ssp != NULL );
setGSimpStringWithContent( ssp, content, length);
}
