stringutils.hpp

Go to the documentation of this file.

/******************************************************************************
* Copyright (c) ATTX INC 2025. All Rights Reserved.
*
* This software and associated documentation (the "Software") are the 
* proprietary and confidential information of ATTX, INC. The Software is 
* furnished under a license agreement between ATTX and the user organization 
* and may be used or copied only in accordance with the terms of the agreement.
* Refer to 'license/attx_license.adoc' for standard license terms.
*
* EXPORT CONTROL NOTICE: THIS SOFTWARE MAY INCLUDE CONTENT CONTROLLED UNDER THE
* INTERNATIONAL TRAFFIC IN ARMS REGULATIONS (ITAR) OR THE EXPORT ADMINISTRATION 
* REGULATIONS (EAR99). No part of the Software may be used, reproduced, or 
* transmitted in any form or by any means, for any purpose, without the express 
* written permission of ATTX, INC.
******************************************************************************/
#ifndef UTILS_STRINGUTILS_H
#define UTILS_STRINGUTILS_H 
 
#include <stddef.h>
#include <stdint.h>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <array>
 
#include "types.h"
#include "core/clockwerkerrors.h"
 
namespace clockwerk {
    // Constant definition for single value conversion to string
    const uint8 MAX_CHARS_PER_STRING_VALUE = 32;
 
    // Constant definition for array/vector conversion to string
    const uint16 MAX_CHARS_PER_ARRAY_STRING = 200;

    void toUpper(char* input);

    void toLower(char* input);

    bool caseInsensitiveEqual(const char* a, const char* b);

    int16 strip(const char* input, char* output, size_t output_size);

    int16 stringReplace(const char* source, const char* orig, const char* repl,
                      char* output, size_t output_size);

    int16 splitString(const char* text, const char* delimiter,
                    char** tokens, size_t max_tokens,
                    char* token_buf, size_t token_buf_size);

    bool isValidNumber(const char* s);

    template <typename T>
    int16 setArrayFromString(const char* s, T* array, size_t array_size);

    template<size_t N>
    int16 numberToString(const std::array<char, N>& val, char* retval, size_t size);

    template<typename Tn, size_t N>
    int16 numberToString(const std::array<Tn, N>& val, char* retval, size_t size);

    int16 numberToString(bool num, char* out, size_t out_size);
    int16 numberToString(int8 num, char* out, size_t out_size);
    int16 numberToString(int16 num, char* out, size_t out_size);
    int16 numberToString(int32 num, char* out, size_t out_size);
    int16 numberToString(int64 num, char* out, size_t out_size);
    int16 numberToString(uint8 num, char* out, size_t out_size);
    int16 numberToString(uint16 num, char* out, size_t out_size);
    int16 numberToString(uint32 num, char* out, size_t out_size);
    int16 numberToString(uint64 num, char* out, size_t out_size);

    int16 numberToString(char num, char* out, size_t out_size);

    int16 numberToString(float num, char* out, size_t out_size, uint8 precision = 6);

    int16 numberToString(float16 num, char* out, size_t out_size, uint8 precision = 3);

    int16 numberToString(double num, char* out, size_t out_size, uint8 precision = 6);

    int16 numberFromString(const char* s, uint8& num);
    int16 numberFromString(const char* s, uint16& num);
    int16 numberFromString(const char* s, uint32& num);
    int16 numberFromString(const char* s, uint64& num);
    int16 numberFromString(const char* s, int8& num);
    int16 numberFromString(const char* s, int16& num);
    int16 numberFromString(const char* s, int32& num);
    int16 numberFromString(const char* s, int64& num);
    int16 numberFromString(const char* s, float& num);
    int16 numberFromString(const char* s, double& num);

    size_t strnlen(const char *s, size_t maxlen);
 
    template <typename T>
    int16 setArrayFromString(const char* s, T* array, size_t array_size) {
        if (!s || !array) {
            return ERROR_NULLPTR;
        }
 
        // Note implicit assumption that we have a valid string
        size_t len = strlen(s);
        if(len < 1) {
            return ERROR_DIMENSIONS;
        }
 
        // Loop through our string, looking for the commas that separate
        // our char elements and parsing accordingly
        uint32 filled_num = 0;
        uint32 start_idx = 0;
        uint32 end_idx = 0;
        int16 err = NO_ERROR;
        while(filled_num < array_size && end_idx < len) {
            // Find the next end index of our string
            while(s[end_idx] != ',' && s[end_idx] != '\0') {
                end_idx++;
            }
 
            // Try to pull out of our string and into our number. 
            char num_arr[end_idx - start_idx + 1];
            memcpy(num_arr, s + start_idx, end_idx - start_idx);
            num_arr[end_idx - start_idx] = '\0';
            err = numberFromString(num_arr, array[filled_num]);
            if(err) {return err;}
 
            // And increment
            if(end_idx < len - 1) {
                start_idx = ++end_idx;
            }
            filled_num++;
        }
 
        // Check that we actually filled the thing correctly
        if(filled_num != array_size) {
            return ERROR_DIMENSIONS;
        }
 
        return NO_ERROR;
    }
 
    template<typename Tn, size_t N>
    int16 numberToString(const std::array<Tn, N>& val, char* retval, size_t size) {
        if(retval == nullptr) {return ERROR_NULLPTR;}
 
        bool dimensions_error = false;
        uint32 val_idx = 0;
        int num_chars_filled = 0;
        while (val_idx < N && !dimensions_error) {
            // Call number to string conversion, starting at open space in our buffer
            int16 err = numberToString(val[val_idx], retval + num_chars_filled, size - num_chars_filled);
            if(err) {dimensions_error = true;}
 
            if(!dimensions_error) {
                // Calculate updated parameters
                num_chars_filled = strnlen(retval, size);
 
                // Add in comma to separate values
                if(size - num_chars_filled > 1) {
                    if(val_idx < N - 1) {
                        strcpy(retval + num_chars_filled, ",");
                        num_chars_filled += 1;
                    }
                } else {
                    dimensions_error = true;
                }
            }
 
            val_idx++;
        }
 
        if(dimensions_error) {return ERROR_DIMENSIONS;}
        return NO_ERROR;
    }
 
    template<size_t N>
    int16 numberToString(const std::array<char, N>& val, char* retval, size_t size) {
        if(retval == nullptr) {return ERROR_NULLPTR;}
 
        // Determine length
        uint32 length = strnlen(val.data(), N);
        if(length >= size) {return ERROR_DIMENSIONS;}
 
        // And copy over
        memcpy(retval, val.data(), length);
        retval[length] = '\0';
 
        return NO_ERROR;
    }
 
}
 
#endif