strings.h

Go to the documentation of this file.

 
#include "elementa/license.inc"
#include "elementa/checks.inc"
 
#ifndef ELEMENTA_BASE_STRINGS_H
#define ELEMENTA_BASE_STRINGS_H
 
#include <string>
#include <vector>
#include <utility>
#include <algorithm> 
#include <type_traits>
#include <sstream>
#include <bitset>
#include <iomanip>
#include <functional>
#include <cctype>
#include <limits>
#include "elementa/base/fundamentaltypes.h"
 
namespace elementa
{
 
namespace base
{
 
/* ==========================================================================
 
            TESTING STRINGS
 
============================================================================*/
 
 
/* *************************************************************************
 
    Template class: is_charlike
 
**************************************************************************/
 
 
template <typename T>
struct is_charlike { static constexpr bool value = false; };
 
template <>
struct is_charlike<char> { static constexpr bool value = true; };
 
template <>
struct is_charlike<wchar_t> { static constexpr bool value = true; };
 
template <>
struct is_charlike<char16_t> { static constexpr bool value = true; };
 
template <>
struct is_charlike<char32_t> { static constexpr bool value = true; };
 
 
/* *************************************************************************
 
    Template class: is_string
 
******************************************************************************/
 
 
template <typename... T>
struct IsStringHelperPriv { typedef void type; }; 
 
 
template <typename T, class Enable = void>
struct is_string: std::false_type {}; // the resulting struct has a ::value
                                      // member that is FALSE
 
template <typename T>
struct is_string<T,
                 typename IsStringHelperPriv<  
                                       // this parameter yield error if the
                                       // compiler finds in T a type that
                                       // has no value_type, traits_type or
                                       // allocator_type, but in that case,
                                       // due to the SFINAE rule, it will
                                       // look for another specialization of
                                       // IsStringHelperPriv instead of giving 
                                       // the error, and that will be the false
                                       // one. Otherwise, ::type is void
                                       // and this specialization goes on.
                                typename T::value_type,
                                typename T::traits_type,
                                typename T::allocator_type
                                >::type
                >
    : std::is_base_of<
                        std::basic_string<
                            typename T::value_type,
                            typename T::traits_type,
                            typename T::allocator_type
                        >,
                        T
                     > {}; // the resulting struct will contain a ::value 
                           // member that is TRUE
 
 
/* *************************************************************************
 
    Functions: is_all_upper, is_all_lower, 
               is_hex_digit, is_identifier, is_number,
               is_linechanger, is_blank, is_separator, bytes_for_eol
 
******************************************************************************/
 
 
bool is_all_upper(const std::string & s) noexcept;
 
 
bool is_all_lower(const std::string & s) noexcept;
 
constexpr bool is_hex_digit(char c) noexcept
    { return(((c >= 'a') && (c <= 'f')) ||
             ((c >= 'A') && (c <= 'F')) ||
             std::isdigit(c)); }
             
 
bool is_identifier(const std::string & s);
 
 
bool is_number(const std::string & s, uint8_t base = 10, 
               bool onlyint = false);
 
constexpr bool is_linechanger(char c)
    { return((c == '\r') || (c == '\n')); }
 
constexpr bool is_blank(char c)
    { return((c == '\t') || (c == ' ')); }
 
constexpr bool is_separator(char c)
    { return(is_linechanger(c) || is_blank(c)); }
 
const std::vector<uint8_t> & bytes_for_eol(void);
 
 
 
/* ==========================================================================
 
            CONVERTIG TO/FROM STRING
 
============================================================================*/
 
 
/* *************************************************************************
 
    Template functions: to_string_dec, to_string_hex, to_string_bin, 
                        to_string_oct, from_string_hex, from_string_bin
    Functions: real_to_string, char_to_string, hexdump
 
******************************************************************************/
 
 
template <typename NumType>
std::string to_string_dec(NumType n, bool padding = true)
{
    static_assert(std::is_integral<NumType>::value,
                  "to_string_dec only works with integral types");
 
    std::stringstream stream;
    if (padding) 
    {
        stream << std::setw(std::numeric_limits<NumType>::digits10 + 1);
        stream << std::setfill('0');
    }
    stream << n;
    return(stream.str());
}
 
 
template <>
std::string to_string_dec<>(uint8_t n, bool padding);
 
 
template <typename NumType>
std::string to_string_hex(NumType n, bool padding = true)
{
    static_assert(std::is_integral<NumType>::value,
                  "to_string_hex only works with integral types");
 
    std::stringstream stream;
    if (padding)
        stream << std::hex << 
                  std::setw(sizeof(NumType)*2) << std::setfill('0') <<
                  std::uppercase <<
                  static_cast<LongestUnsigned>(n); // cast needed for uint8_t...
    else stream << std::hex << static_cast<LongestUnsigned>(n);// not being char
    return(stream.str());
}
 
 
template <typename NumType>
std::string to_string_bin(NumType n, bool padding = true)
{
    static_assert(std::is_integral<NumType>::value,
                  "to_string_bin only works with integral types");
 
    const std::string result = std::bitset<sizeof(NumType)*8>(n).to_string();
    if (padding) return(result);
    return(result.substr(result.find("1", 0)));
}
 
 
template <typename NumType>
std::string to_string_oct(NumType n, bool padding = true)
{
    static_assert(std::is_integral<NumType>::value,
                  "to_string_oct only works with integral types");
 
    std::stringstream stream;
    if (padding)
        stream << std::oct << 
                  std::setw(sizeof(NumType)*2) << std::setfill('0') <<
                  static_cast<LongestUnsigned>(n);
    else stream << std::oct << static_cast<LongestUnsigned>(n);
    return(stream.str());
}
 
 
template <typename NumType>
NumType from_string_hex(const std::string & txt)
{
    static_assert(std::is_unsigned<NumType>::value,
                  "from_string_hex only works with integral unsigned types");
 
    NumType v{0};
    NumType mult{0};
    NumType c;
    for (int f = static_cast<int>(txt.size() - 1); f >= 0; --f)
    {
        if (std::isdigit(txt[f])) c = txt[f] - '0';
        else if (std::isalpha(txt[f]))
        {
            if (std::isupper(txt[f])) c = txt[f] - 'A' + 10;
            else c = txt[f] - 'a' + 10;
            if (c > 15) break;
        }
        else break;
        v += c << mult;
        mult += 4;
    }
    return(v);
}
 
 
template <typename NumType>
NumType from_string_bin(const std::string & txt)
{
    static_assert(std::is_unsigned<NumType>::value,
                  "from_string_bin only works with integral unsigned types");
 
    NumType v{0};
    NumType mult{0};
    NumType c;
    for (int f = static_cast<int>(txt.size() - 1); f >= 0; --f)
    {
        if ((txt[f] == '0') || (txt[f] == '1')) c = txt[f] - '0';
        else break;
        v += c << mult;
        ++mult;
    }
    return(v);
}
 
 
std::string real_to_string(LongestReal n);
 
std::string real_to_string_fixdec(LongestReal n, unsigned ds);
 
 
std::string char_to_string(char c);
 
 
template <typename PointedType>
std::string hexdump(const PointedType * data, size_t howmany, bool toupp = true,
                    bool sepelems = true)
{
    std::string res;
    if ((data != nullptr) && (howmany > 0))
    {
        const auto * bytes = reinterpret_cast<const uint8_t *>(data);
        for (size_t f = 0; f < howmany; ++f)
        {
            res += to_string_hex(*bytes);
            if (sepelems && (f < howmany - 1)) res.push_back(' ');
            ++bytes;
        }
        if (toupp)
            std::transform(res.begin(),res.end(),res.begin(),
                           [](char c)->char 
                           { return(std::toupper(c)); });
    }
    return(res);
}
 
 
/* ==========================================================================
 
            PROCESSING / MODIFYING STRINGS
 
============================================================================*/
 
 
/* *************************************************************************
 
        Function: toCase
 
*****************************************************************************/
 
std::string toCase(const std::string & s, char to);
 
 
/* *************************************************************************
 
    Functions: ltrim, rtrim, trim / ltrim_mut, rtrim_mut, trim_mut,
               pad
 
******************************************************************************/
 
 
inline std::string & ltrim_mut(std::string & s) 
{
    auto f = [](int c) { return(!std::isspace(c)); };
    s.erase(s.begin(), std::find_if(s.begin(),s.end(),f) );
    // erase() removes characters from the iterator of its first argument to the
    // iterator of the second one minus 1. find_if() returns iter. to the first 
    // element that satisfies its predicate within two iterators. not1() returns
    // the complement of its predicate (std::isspace in this case). ptr_fun()
    // creates a function wrapper for its argument.
    return(s);
}
 
inline std::string ltrim(const std::string & s)
{
    std::string res{s};
    ltrim_mut(res);
    return(res);    
}
 
 
inline std::string & rtrim_mut(std::string & s) 
{
    auto f = [](int c) { return(!std::isspace(c)); };
    s.erase(std::find_if(s.rbegin(),s.rend(),f).base() , s.end() );
    return(s);
}
 
inline std::string rtrim(const std::string & s)
{
    std::string res{s};
    rtrim_mut(res);
    return(res);    
}
 
inline std::string & trim_mut(std::string & s) 
{
    return(ltrim_mut(rtrim_mut(s)));
}
 
inline std::string trim(const std::string & s) 
{
    std::string res{s};
    return(trim_mut(res));
}
 
 
void pad(std::string & s, size_t len, 
         bool leftorright = false, char padding = ' ');
         
 
void chop(std::string & s, size_t len, char excess = 0x00,
          bool leftorright = false, char padding = ' ');
 
 
 
/* *************************************************************************
 
        Function: split
 
*****************************************************************************/
 
 
std::vector<std::string> split(const std::string & s, char delim);
 
 
/* *************************************************************************
 
        Function: concatWithMiddle
 
*****************************************************************************/
 
std::string concatWithMiddle(const std::string & s1,
                             const std::string & s2,
                             const std::string & m = ". ");
 
 
/* ***************************************************************************
 
        Function: indentlinedtext
 
*****************************************************************************/
 
 
std::string indentlinedtext(const std::string & txt,
                            bool atstarttoo = false,
                            std::string::size_type maxlinelength = 80, 
                            const std::string & newlinepreffix ="    ",
                            const std::string & newlinetext = "\n");
 
 
 
/* ==========================================================================
 
            TYPES BASED ON STRINGS
 
============================================================================*/
 
 
/* **********************************************************************
 
    Class: Strings
 
*************************************************************************/
 
class Strings: public std::vector<std::string>
{
 public:
 
    using Base = std::vector<std::string>;
 
    using Base::Base;
 
 
    std::string to_string(const std::string & preffix = "",
                          const std::string & beg = "{",
                          const std::string & end = "}") const;
};
 
 
 
 // Strings
 
 
} // end namespace base
 
} // end namespace elementa
 
#endif