encoding.h

Go to the documentation of this file.

#pragma once
#include <map>
#include <set>
#include <string>
#include <string_view>
#include <memory>
#ifdef WEBCFACE_MESON
#include "webcface-config.h"
#else
#include "webcface/common/webcface-config.h"
#endif
 
WEBCFACE_NS_BEGIN
namespace internal {
struct SharedStringData;
} // namespace internal
 
WEBCFACE_DLL void WEBCFACE_CALL usingUTF8(bool flag);
WEBCFACE_DLL bool WEBCFACE_CALL usingUTF8();
 
WEBCFACE_DLL std::wstring WEBCFACE_CALL toWide(std::string_view name_ref);
WEBCFACE_DLL std::string WEBCFACE_CALL toNarrow(std::wstring_view name_ref);
 
class WEBCFACE_DLL SharedString {
    std::shared_ptr<internal::SharedStringData> data;
 
  public:
    SharedString() : data() {}
    SharedString(std::nullptr_t) : data() {}
    explicit SharedString(std::shared_ptr<internal::SharedStringData> &&data);
 
    static SharedString WEBCFACE_CALL fromU8String(std::string_view u8s);
    static SharedString WEBCFACE_CALL encode(std::string_view s);
    static SharedString WEBCFACE_CALL
    encode(std::wstring_view ws, std::string_view s = std::string_view());
 
    const std::string &u8String() const;
    std::string_view u8StringView() const;
    const std::string &decode() const;
    const std::wstring &decodeW() const;
 
    static const std::string &emptyStr();
    static const std::wstring &emptyStrW();
 
    bool empty() const;
    bool startsWith(std::string_view str) const;
    bool startsWith(char str) const;
 
    bool operator==(const SharedString &other) const;
    bool operator<=(const SharedString &other) const;
    bool operator>=(const SharedString &other) const;
    bool operator!=(const SharedString &other) const;
    bool operator<(const SharedString &other) const;
    bool operator>(const SharedString &other) const;
 
    struct Hash : std::hash<std::string> {
        Hash() = default;
        auto operator()(const SharedString &ss) const {
            return this->std::hash<std::string>::operator()(ss.u8String());
        }
    };
};
 
template <typename T>
using StrMap1 = std::map<SharedString, T>;
template <typename T>
using StrMap2 = StrMap1<StrMap1<T>>;
using StrSet1 = std::set<SharedString>;
using StrSet2 = StrMap1<StrSet1>;
 
namespace [[deprecated("symbols in webcface::encoding namespace are "
                       "now directly in webcface namespace")]] encoding {
inline bool usingUTF8() { return webcface::usingUTF8(); }
inline void usingUTF8(bool flag) { webcface::usingUTF8(flag); }
inline std::wstring toWide(std::string_view name_ref) {
    return webcface::toWide(name_ref);
}
inline std::string toNarrow(std::wstring_view name) {
    return webcface::toNarrow(name);
}
 
using SharedString = webcface::SharedString;
 
template <typename T>
using StrMap1 = webcface::StrMap1<T>;
template <typename T>
using StrMap2 = webcface::StrMap2<T>;
using StrSet1 = webcface::StrSet1;
using StrSet2 = webcface::StrSet2;
 
} // namespace encoding
 
WEBCFACE_NS_END