string.hpp

// SPDX-License-Identifier: Apache-2.0
// Copyright 2020 - 2023 Pionix GmbH and Contributors to EVerest
#ifndef OCPP_COMMON_STRING_HPP
#define OCPP_COMMON_STRING_HPP
 
#include <cstddef>
#include <iostream>
#include <sstream>
#include <stdexcept>
#include <string>
 
namespace ocpp {
 
class StringConversionException : public std::runtime_error {
    using std::runtime_error::runtime_error;
};
 
enum class StringTooLarge {
    Throw,
    Truncate
};
 
template <size_t L> class String {
private:
    std::string data;
    static constexpr size_t length = L;
 
public:
    explicit String(const std::string& data, StringTooLarge to_large = StringTooLarge::Throw) {
        this->set(data, to_large);
    }
 
    explicit String(const char* data, StringTooLarge to_large = StringTooLarge::Throw) {
        this->set(data, to_large);
    }
 
    String() = default;
 
    std::string get() const {
        return data;
    }
 
    void set(const std::string& data, StringTooLarge to_large = StringTooLarge::Throw) {
        std::string_view view = data;
        if (view.length() > this->length) {
            if (to_large == StringTooLarge::Throw) {
                throw StringConversionException("String length (" + std::to_string(view.length()) +
                                                ") exceeds permitted length (" + std::to_string(this->length) + ")");
            }
            // Truncate
            view = view.substr(0, length);
        }
 
        if (this->is_valid(view)) {
            this->data = view;
        } else {
            throw StringConversionException("String has invalid format");
        }
    }
 
    bool is_valid(std::string_view data) {
        (void)data; // not needed here
        return true;
    }
 
    operator std::string() {
        return this->get();
    }
};
 
template <size_t L> bool operator==(const String<L>& lhs, const char* rhs) {
    return lhs.get() == rhs;
}
 
template <size_t L> bool operator==(const String<L>& lhs, const String<L>& rhs) {
    return lhs.get() == rhs.get();
}
 
template <size_t L> bool operator!=(const String<L>& lhs, const char* rhs) {
    return !(lhs.get() == rhs);
}
 
template <size_t L> bool operator!=(const String<L>& lhs, const String<L>& rhs) {
    return !(lhs.get() == rhs.get());
}
 
template <size_t L> std::ostream& operator<<(std::ostream& os, const String<L>& str) {
    os << str.get();
    return os;
}
 
} // namespace ocpp
 
#endif