BHdzITK/BH_itk/string_utils.cpp

/*==================================================================================================================
                    Copyright(c) 2012 ORIGIN.
                             Unpublished - All rights reserved
====================================================================================================================
File description:
    Filename: string_utils.c
    Module  : Common module.

        This file includes some operations of the string.

====================================================================================================================
Date                Name             Description of Change
3-Feb-2015		Ray li    Initialize creation
$HISTORY$
===================================================================================================================*/
#ifndef _cplusplus
#ifndef _CRT_SECURE_NO_DEPRECATE
#define _CRT_SECURE_NO_DEPRECATE
#endif
#endif

#include <fclasses/tc_string.h>
#include <tc/tc_util.h>
#include <base_utils/mem.h>
#include <tccore/workspaceobject.h>
#include <stdlib.h>
#include <ctype.h>

#include "string_utils.h"

void Split(string strArg, string spliter, vector<string>& ans)
{
    ans.clear();
    size_t index0;
    string one_arg;
    if (strArg.find_first_not_of(' ') == string::npos)
        strArg = "";
    while (strArg.size() > 0)
    {
        index0 = strArg.find(spliter);
        if (index0 != string::npos)
        {
            one_arg = strArg.substr(0, index0);
            strArg = strArg.substr(index0 + spliter.size());
            ans.push_back(one_arg);
        }
        else
        {
            ans.push_back(strArg);
            break;
        }
    }
}
char* GSTR_clone(char** dst, const char* src)
{
    char* retVal = NULL;
    int  srcLen = 0;

    *dst = NULL;
    if (src == NULL)
        return NULL;

    srcLen = (int)tc_strlen(src) + 1;
    *dst = (char*)MEM_alloc(srcLen * sizeof(char));
    retVal = tc_strncpy(*dst, src, srcLen);
    (*dst)[srcLen - 1] = '\0';

    return retVal;
}

char* GSTR_copy(char* dst, const char* src, int dstSize)
{
    char* retVal = tc_strncpy(dst, src, dstSize);
    dst[dstSize - 1] = '\0';
    return retVal;
}

char* GSTR_int_to_string(char** dst, int value)
{
    char strVal[128 + 1];

    *dst = NULL;
    memset(strVal, 0, sizeof(strVal) / sizeof(char));
    sprintf(strVal, "%d", value);

    return GSTR_clone(dst, strVal);
}

void GSTR_format_int_to_string(char* dst, int digitNum, int value)
{
    char sNum[WSO_desc_size_c + 1];
    sprintf(sNum, "%%0%dd", digitNum);
    sprintf(dst, sNum, value);
}

void GSTR_format_string(const char* dst, int m, const char* fill_char, char** out)
{
    char sNum[WSO_name_size_c + 1] = { 0 };
    char sNew[WSO_name_size_c + 1] = { 0 };
    sprintf(sNum, "%%%d.%ds", m, m);
    sprintf(sNew, sNum, dst);
    STRNG_replace_str(sNew, " ", fill_char, out);
}


char* GSTR_string_append(const char* s1, const char* s2)
{
    char* s = NULL;
    if (s1 == NULL || s2 == NULL)
    {
        GSTR_clone(&s, s1 == NULL ? (s2 == NULL ? "" : s2) : s1);
    }
    else
    {
        int size = (int)tc_strlen(s1) + (int)tc_strlen(s2) + 1;
        s = (char*)MEM_alloc(size);
        tc_strcpy(s, s1);
        tc_strcat(s, s2);
        s[size - 1] = '\0';
    }
    return s;
}

logical GSTR_is_float(const char* str)
{
    logical isfloat = true;
    char* pStr = (char*)str;
    logical hasPositive = false;
    logical hasMinus = false;
    logical hasDot = false;

    if (str == NULL)
        return false;

    while (*pStr != '\0' && isfloat == true)
    {
        if ((*pStr >= '0' && *pStr <= '9'))
        {
            //continue;
        }
        else if (*pStr == '+')
        {
            isfloat = (hasPositive ? false : (hasPositive = true));
        }
        else if (*pStr == '-')
        {
            isfloat = (hasMinus ? false : (hasMinus = true));
        }
        else if (*pStr == '.')
        {
            isfloat = (hasDot ? false : (hasDot = true));
        }
        else
            isfloat = false;

        pStr++;
    }
    return isfloat;
}

logical GSTR_is_number(const char* str)
{
    logical is_number = true;
    char* pStr = (char*)str;
    if (str == NULL)
        return false;

    while (*pStr != '\0')
    {
        if (!((*pStr >= '0' && *pStr <= '9') || *pStr == '-'))
        {
            is_number = false;
            break;
        }
        pStr++;
    }
    return is_number;
}

logical GSTR_is_ascii(char ch)
{
    return ((unsigned int)ch) < 128;
}

int GSTR_trim_l(char* str, char s)
{
    int count = 0;
    char* pointer = str, * poffset = NULL;
    if (str == NULL || str[0] == '\0')
        return 0;

    while (*pointer != '\0')
    {
        if (*pointer != s)
        {
            break;
        }
        count++;
        pointer++;
    }
    if (count == 0)
        return 0;

    poffset = str + count;
    pointer = str;
    while (*poffset != '\0')
    {
        *pointer = *poffset;
        pointer++;
        poffset++;
    }
    *pointer = '\0';

    return count;
}

int GSTR_trim_r(char* str, char s)
{
    int count = 0;
    char* pointer = NULL;
    if (str == NULL || str[0] == '\0')
        return 0;

    pointer = str + ((int)strlen(str) - 1);

    while (pointer != str)
    {
        if (*pointer != s)
        {
            break;
        }

        *pointer = '\0';

        count++;
        pointer--;
    }

    return count;
}

void GSTR_trim_float(char* floatValue)
{
    if (!IS_EMPTY(floatValue) && tc_strstr(floatValue, ".") != NULL)
    {
        int len = 0;
        GSTR_trim_r(floatValue, '0');
        len = (int)tc_strlen(floatValue);
        if (floatValue[len - 1] == '.')
            floatValue[len - 1] = '\0';
    }
}