fixed_size_string.hpp

// Copyright 2023 Proyectos y Sistemas de Mantenimiento SL (eProsima).
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

 
#ifndef FASTCDR_UTILS_FIXED_SIZE_STRING_HPP_
#define FASTCDR_UTILS_FIXED_SIZE_STRING_HPP_
 
#include <string>
#include <cstring>
 
#ifdef _WIN32
#define MEMCCPY _memccpy
#else
#define MEMCCPY memccpy
#endif // ifdef _WIN32
 
namespace eprosima {
namespace fastcdr {

template <size_t MAX_CHARS>
struct fixed_string
{
public:

    static constexpr size_t max_size = MAX_CHARS;

    fixed_string() noexcept
    {
        memset(string_data, 0, sizeof(string_data));
        string_len = 0;
    }
 
    // We don't need to define copy/move constructors/assignment operators as the default ones would be enough

    fixed_string(
            const char* c_array,
            size_t n_chars) noexcept
    {
        assign(c_array, n_chars);
    }

    fixed_string& assign(
            const char* c_array,
            size_t n_chars) noexcept
    {
        string_len = (nullptr == c_array) ? 0 :
                (MAX_CHARS < n_chars) ? MAX_CHARS : n_chars;
        if (0 < string_len)
        {
            memcpy(string_data, c_array, string_len);
        }
        string_data[string_len] = '\0';
        return *this;
    }

    fixed_string (
            const char* c_string) noexcept
        : fixed_string()
    {
        set(c_string != nullptr ? c_string : "");
    }

    fixed_string& operator = (
            const char* c_string) noexcept
    {
        set(c_string != nullptr ? c_string : "");
        return *this;
    }

    fixed_string (
            const std::string& str) noexcept
        : fixed_string()
    {
        set(str.c_str());
    }

    fixed_string& operator = (
            const std::string& str) noexcept
    {
        set(str.c_str());
        return *this;
    }

    template<size_t N> fixed_string& operator = (
            const fixed_string<N>& rhs) noexcept
    {
        set(rhs.c_str());
        return *this;
    }

    const char* c_str() const noexcept
    {
        return string_data;
    }

    std::string to_string() const
    {
        return std::string(string_data);
    }

    bool operator == (
            const char* rhs) const noexcept
    {
        return strncmp(string_data, rhs, MAX_CHARS) == 0;
    }

    bool operator == (
            const std::string& rhs) const noexcept
    {
        return strncmp(string_data, rhs.c_str(), MAX_CHARS) == 0;
    }

    template<size_t N>  bool operator == (
            const fixed_string<N>& rhs) const noexcept
    {
        return strncmp(string_data, rhs.c_str(), MAX_CHARS) == 0;
    }

    bool operator != (
            const char* rhs) const noexcept
    {
        return !(*this == rhs);
    }

    bool operator != (
            const std::string& rhs) const noexcept
    {
        return !(*this == rhs);
    }

    template<size_t N>  bool operator != (
            const fixed_string<N>& rhs) const noexcept
    {
        return !(*this == rhs);
    }

    template<size_t N>  bool operator < (
            const fixed_string<N>& rhs) const noexcept
    {
        return 0 > compare(rhs);
    }

    template<size_t N>  bool operator > (
            const fixed_string<N>& rhs) const noexcept
    {
        return 0 < compare(rhs);
    }

    bool operator < (
            const std::string& rhs) const noexcept
    {
        return 0 > compare(rhs);
    }

    bool operator > (
            const std::string& rhs) const noexcept
    {
        return 0 < compare(rhs);
    }

    operator const char* () const noexcept {
        return c_str();
    }

    size_t size() const noexcept
    {
        return string_len;
    }

    int compare(
            const char* str) const noexcept
    {
        return strncmp(string_data, str, MAX_CHARS);
    }

    int compare(
            const std::string& str) const noexcept
    {
        return strncmp(string_data, str.c_str(), MAX_CHARS);
    }

    template<size_t N>  int compare(
            const fixed_string<N>& str) const noexcept
    {
        return strncmp(string_data, str.c_str(), MAX_CHARS);
    }
 
private:
 
    void set(
            const char* c_string) noexcept
    {
        char* result = static_cast<char*>(MEMCCPY(string_data, c_string, '\0', MAX_CHARS));
        string_len = (result == nullptr) ? MAX_CHARS : static_cast<size_t>(result - string_data) - 1u;
    }
 
    char string_data[MAX_CHARS + 1];      
    size_t string_len;                    
};
 
using string_255 = fixed_string<255>;
 
} /* namespace fastcdr */
} /* namespace eprosima */
 
#endif /* FASTCDR_UTILS_FIXED_SIZE_STRING_HPP_ */