tb_fixed_string.hpp

 
#ifndef TurtleBrains_FixedString_hpp
#define TurtleBrains_FixedString_hpp
 
#include <turtle_brains/core/tb_configuration.hpp>
#include <turtle_brains/core/tb_string.hpp>
#include <turtle_brains/core/tb_error.hpp>
 
#include <cstring>
 
// 2024-07-30: I believe I'm getting this warning as a compiler bug, and yet Ubuntu 22.04 isn't letting me update GCC.
//   Bug Reported here: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=88780 and you can see it was closed for GCC 11 on
//   2024-07-19, which is definitely after I got rhino started; as of today no GCC update avaiable.
//
//   This was caused in TrackBuilder where NodeName is FixedString<24> and the error is complaining about:
//   "output may be truncated copying 23 bytes from a string of length 23" where size = 24, and I expected error is
//   24-1 for the null-terminator. Previously used strncpy(mData, value, Size - 1); and now strncpy with full size and
//   manually setting the last char to null-terminator.
//
// 2024-11-02: Today the null-terminator was removed from the FixedString and .c_str() was removed as well since it
//   required that null-terminator. Using data() returns the raw (possibly no null-terminator) character array; also
//   could use String() to return a copy where .c_str() can work.
#if (defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER))
  #pragma GCC diagnostic ignored "-Wstringop-truncation"
#endif
 
namespace TurtleBrains
{
    namespace Core
    {
 
        template <size_t Size> class FixedString
        {
            tb_static_error_if(Size < 1, "Expected FixedString size to contain at least 1 character.");
 
        public:
            FixedString(void) :
                mData{ '\0', }
            {
            }
 
            FixedString(const char* value) :
                mData{ '\0', }
            {
                strncpy(mData, value, Size);
            }
 
            FixedString(const String& value) :
                mData{ '\0', }
            {
                strncpy(mData, value.c_str(), Size);
            }
 
            FixedString(const FixedString& value) :
                mData{ '\0', }
            {
                strncpy(mData, value.mData, Size);
            }
 
            FixedString& operator=(const FixedString& other)
            {
                strncpy(mData, other.mData, Size);
                return *this;
            }
 
            FixedString& operator=(const String& other)
            {
                strncpy(mData, other.c_str(), Size);
                return *this;
            }
 
            FixedString& operator=(const char* other)
            {
                strncpy(mData, other, Size);
                return *this;
            }
 
            bool operator==(const FixedString& other) const { return 0 == std::strncmp(mData, other.String().c_str(), Size); }
            bool operator==(const char* other) const { return 0 == std::strncmp(mData, other, Size); }
            bool operator==(const String& other) const { return 0 == std::strncmp(mData, other.c_str(), Size); }
            bool operator!=(const FixedString& other) const { return 0 != std::strncmp(mData, other.mData, Size); }
            bool operator!=(const char* other) const { return 0 != std::strncmp(mData, other, Size); }
            bool operator!=(const String& other) const { return 0 != std::strncmp(mData, other.c_str(), Size); }
 
            inline operator tbCore::String(void) const
            {
                return String();
            }
 
            bool empty(void) const { return mData[0] == '\0'; }
            size_t size(void) const
            {
                // memchr is somewhat like strlen with max count, strlen_s (and any _s) are seemingly bad standards because
                //   MSVC had some of them defined that don't act like the standard states; so many compilers didn't
                //   support the _s functions. https://stackoverflow.com/questions/66346502/which-is-most-standard-strnlen-or-strnlen-s
                const char* nullTerm = static_cast<const char*>(memchr(mData, '\0', Size));
                const char* start = &mData[0];
                return (nullptr == nullTerm) ? Size : (nullTerm - start);
            }
 
            size_t FixedSize(void) const { return Size; }
 
            const char* data(void) const { return mData; }
            char* data(void) { return mData; }
 
            tbCore::String String(void) const
            {
                return tbCore::String(mData, size());
            }
 
        private:
            char mData[Size];
        };
 
        template <size_t Size> std::ostream& operator<<(std::ostream& outputStream, const FixedString<Size>& fixed)
        {
            outputStream << fixed.data();
            return outputStream;
        }
 
        template <size_t Size> std::istream& operator<<(std::istream& inputStream, FixedString<Size>& fixed)
        {
            String buffer;
            inputStream >> buffer;
            fixed = buffer;
            return inputStream;
        }
 
        template <size_t Size> bool operator==(const char* left, const FixedString<Size>& right) { return 0 == std::strncmp(right.data(), left, Size); }
        template <size_t Size> bool operator==(const String& left, const FixedString<Size>& right) { return 0 == std::strncmp(right.data(), left.c_str(), Size); }
        template <size_t Size> bool operator!=(const char* left, const FixedString<Size>& right) { return 0 != std::strncmp(right.data(), left, Size); }
        template <size_t Size> bool operator!=(const String& left, const FixedString<Size>& right) { return 0 != std::strncmp(right.data(), left.c_str(), Size); }
 
    }; /* namespace Core */
}; /* namespace TurtleBrains */
 
namespace tbCore = TurtleBrains::Core;
 
#if (defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER))
  #pragma GCC diagnostic warning "-Wstringop-truncation"
#endif
 
#endif /* TurtleBrains_FixedString_hpp */