String.cpp

Go to the documentation of this file.

/*
 * This file is a part of the Biology project by eons LLC.
 * Biology (aka Develop Biology) is a framework for approaching software
 * development from a natural sciences perspective.
 *
 * Copyright (C) 2021 Séon O'Shannon & eons LLC
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#include "bio/common/String.h"
 
#include <cstring>
 
using namespace bio;
 
bool string::ToBool(
    const char* s,
    bool* returned
)
{
    *returned = s == "true";
    if (!returned && s != "false")
    {
        return false;
    }
    return true;
}
 
bool string::ToInt(
    const char* s,
    int32_t* value
)
{
    if (strlen(s) == 0)
    {
        return false; //FAIL: empty string
    }
 
    char* endptr = NULL;
    *value = strtol(
        s,
        &endptr,
        10
    );
    return ((*endptr) == '\0');
}
 
bool string::ToUInt(
    const char* s,
    uint32_t* value
)
{
    if (strlen(s) == 0)
    {
        return false; //FAIL: empty string
    }
 
    char* endptr = NULL;
    *value = strtoul(
        s,
        &endptr,
        10
    );
    return ((*endptr) == '\0');
}
 
bool string::ToFloat(
    const char* s,
    float* value
)
{
    if (strlen(s) == 0)
    {
        return false; //FAIL: empty string
    }
 
    char* endptr = NULL;
    *value = strtof(
        s,
        &endptr
    );
    return ((*endptr) == '\0');
}
 
StdStrings string::Parse(
    const std::string& s,
    char delimiter,
    bool trimLeadingSpaces
)
{
    std::stringstream ss(s);
    StdStrings result;
    while (ss.good())
    {
 
        std::string substring;
        std::getline(
            ss,
            substring,
            delimiter
        );
 
        if (trimLeadingSpaces)
        {
            //trim leading spaces from substring
            size_t firstcharpos = substring.find_first_not_of(' ');
            if (firstcharpos != std::string::npos)
            {
                substring = substring.substr(firstcharpos);
            }
        } //else: don't alter substring
 
        result.push_back(substring);
    }
 
    return result;
}
 
std::string string::FromVectorOfStrings(
    const StdStrings& v,
    char delimiter,
    bool trimLeadingSpaces
)
{
    std::string result;
    for (
        StdStrings::const_iterator iter = v.begin();
        iter != v.end();
        ++iter
        )
    {
        std::string substring = *iter;
 
        if (trimLeadingSpaces)
        {
            //trim leading spaces from substring
            size_t firstcharpos = substring.find_first_not_of(' ');
            if (firstcharpos != std::string::npos)
            {
                substring = substring.substr(firstcharpos);
            }
        } //else: don't alter substring
 
        if (result.length() == 0)
        {
            result = substring;
        }
        else
        {
            result += (delimiter + substring);
        }
    }
 
    return result;
}
 
std::string string::FromVectorOfStrings(
    const CharStrings& v,
    char delimiter,
    bool trimLeadingSpaces
)
{
    std::string result;
    for (
        CharStrings::const_iterator iter = v.begin();
        iter != v.end();
        ++iter
        )
    {
        std::string substring(*iter);
 
        if (trimLeadingSpaces)
        {
            //trim leading spaces from substring
            size_t firstcharpos = substring.find_first_not_of(' ');
            if (firstcharpos != std::string::npos)
            {
                substring = substring.substr(firstcharpos);
            }
        } //else: don't alter substring
 
        if (result.length() == 0)
        {
            result = substring;
        }
        else
        {
            result += (delimiter + substring);
        }
    }
 
    return result;
}
 
CharStrings string::ToCharStrings(const StdStrings& strings)
{
    CharStrings ret;
    for (
        StdStrings::const_iterator str = strings.begin();
        str != strings.end();
        ++str
        )
    {
        ret.push_back(str->c_str());
    }
    return ret;
}
 
StdStrings string::ToStdStrings(const CharStrings& strings)
{
    StdStrings ret;
    for (
        CharStrings::const_iterator chr = strings.begin();
        chr != strings.end();
        ++chr
        )
    {
        std::string str(*chr);
        ret.push_back(str);
    }
    return ret;
}
 
void string::CloneInto(
    const char* source,
    const char*& target
)
{
    //NOTE: because "new" is used here, a delete needs to be called either here or in the caller.
    const size_t len = strlen(source);
    char* tmpName = new char[len + 1];
    strncpy(
        tmpName,
        source,
        len
    );
    tmpName[len] = '\0';
    target = tmpName;
}