SysString.hxx

#pragma once
 
// C++
#include <cstring>
#include <iosfwd>
#include <string>
#include <string_view>
 
// Cosmos
#include <cosmos/dso_export.h>
 
namespace cosmos {
 
 
struct SysString {
 
        SysString() = default;
 
        SysString(const std::string &str) :
                        m_ptr{str.c_str()} {}
 
        SysString(const char *str) :
                        m_ptr{str} {}
 
        const char* raw() const {
                return m_ptr ? m_ptr : "";
        }
 
        size_t length() const {
                return view().length();
        }
 
        bool empty() const {
                return !m_ptr || m_ptr[0] == '\0';
        }
 
        std::string str() const {
                return m_ptr ? std::string{m_ptr} : std::string{};
        }
 
        std::string_view view() const {
                return m_ptr ? std::string_view{m_ptr} : std::string_view{};
        }
 
        operator std::string() const {
                return str();
        }
 
        operator std::string_view() const {
                return view();
        }
 
        SysString& operator=(const char *str) {
                m_ptr = str;
                return *this;
        }
 
        SysString& operator=(const std::string &str) {
                m_ptr = str.c_str();
                return *this;
        }
 
        bool operator==(const SysString &other) const {
                if (m_ptr == other.m_ptr)
                        return true;
 
                if (!m_ptr || !other.m_ptr)
                        return false;
 
                return std::strcmp(m_ptr, other.m_ptr) == 0;
        }
 
        bool operator!=(const SysString &other) const {
                return !(*this == other);
        }
 
protected: // data
 
        const char *m_ptr = nullptr;
};
 
} // end ns
 
COSMOS_API std::ostream& operator<<(std::ostream &o, const cosmos::SysString str);
 
inline bool operator==(const std::string &s, const cosmos::SysString str) {
        return s == str.view();
}
 
inline bool operator!=(const std::string &s, const cosmos::SysString str) {
        return !(s == str);
}
 
inline bool operator==(const std::string_view &s, const cosmos::SysString str) {
        return s == str.view();
}
 
inline bool operator!=(const std::string_view &s, const cosmos::SysString str) {
        return !(s == str);
}