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>

namespace TurtleBrains
{
    namespace Core
    {
        namespace Unstable
        {

            template <size_t Size> class FixedString
            {
            public:
                FixedString(void) :
                    mData{ '\0', }
                {
                }

                FixedString(const char* value) :
                    mData{ '\0', }
                {
                    strncpy(mData, value, Size - 1);
                }

                FixedString(const tbCore::tbString& value) :
                    mData{ '\0', }
                {
                    strncpy(mData, value.c_str(), Size - 1);
                }

                FixedString(const FixedString& value) :
                    mData{ '\0', }
                {
                    strncpy(mData, value.mData, Size - 1);
                }

                bool operator==(const FixedString& other) const { return 0 == strcmp(mData, other.mData); }
                bool operator==(const char* other) const { return 0 == strcmp(mData, other); }
                bool operator==(const tbCore::tbString& other) const { return 0 == strcmp(mData, other.c_str()); }
                bool operator!=(const FixedString& other) const { return 0 != strcmp(mData, other.mData); }
                bool operator!=(const char* other) const { return 0 != strcmp(mData, other); }
                bool operator!=(const tbCore::tbString& other) const { return 0 != strcmp(mData, other.c_str()); }

                inline operator tbCore::tbString(void) const
                {
                    return tbCore::tbString(mData);
                }

                bool empty(void) const { return strlen(mData) == 0; }
                size_t size(void) const { return strlen(mData); }
                size_t FixedSize(void) const { return Size; }

                const char* data(void) const { return mData; }
                char* data(void) { return mData; }

                const char* c_str(void) const { return mData; }

            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)
            {
                tbCore::tbString buffer;
                inputStream >> buffer;
                fixed = buffer;
                return inputStream;
            }

            template <size_t Size> bool operator==(const char* left, const FixedString<Size>& right) { return 0 == strcmp(right.c_str(), left); }
            template <size_t Size> bool operator==(const tbCore::tbString& left, const FixedString<Size>& right) { return 0 == strcmp(right.c_str(), left.c_str()); }
            template <size_t Size> bool operator!=(const char* left, const FixedString<Size>& right) { return 0 != strcmp(right.c_str(), left); }
            template <size_t Size> bool operator!=(const tbCore::tbString& left, const FixedString<Size>& right) { return 0 != strcmp(right.c_str(), left.c_str()); }

        }; /* namespace Unstable */
    }; /* namespace Core */
}; /* namespace TurtleBrains */

namespace tbCore = TurtleBrains::Core;

#endif /* TurtleBrains_FixedString_hpp */