ZNCString.h

Go to the documentation of this file.

/*
 * Copyright (C) 2004-2024 ZNC, see the NOTICE file for details.
 *
 * 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 ZNCSTRING_H
#define ZNCSTRING_H

#include <znc/zncconfig.h>
#include <map>
#include <set>
#include <string>
#include <vector>
#include <sstream>
#include <sys/types.h>
#include <initializer_list>

#define _SQL(s) CString("'" + CString(s).Escape_n(CString::ESQL) + "'")
#define _URL(s) CString(s).Escape_n(CString::EURL)
#define _HTML(s) CString(s).Escape_n(CString::EHTML)
#define _NAMEDFMT(s) CString(s).Escape_n(CString::ENAMEDFMT)

class CString;
class MCString;

typedef std::set<CString> SCString;
typedef std::vector<CString> VCString;
typedef std::vector<std::pair<CString, CString>> VPair;

static const unsigned char XX = 0xff;
static const unsigned char base64_table[256] = {
    XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX,
    XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX,
    XX, XX, XX, XX, XX, 62, XX, XX, XX, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60,
    61, XX, XX, XX, XX, XX, XX, XX, 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10,
    11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, XX, XX, XX, XX,
    XX, XX, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
    43, 44, 45, 46, 47, 48, 49, 50, 51, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX,
    XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX,
    XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX,
    XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX,
    XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX,
    XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX,
    XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX,
    XX, XX, XX, XX, XX, XX, XX, XX, XX,
};

enum class CaseSensitivity { CaseInsensitive, CaseSensitive };

class CString : public std::string {
  public:
    typedef enum {
        EASCII,
        EURL,
        EHTML,
        ESQL,
        ENAMEDFMT,
        EDEBUG,
        EMSGTAG,
        EHEXCOLON,
    } EEscape;

    static const CaseSensitivity CaseSensitive = CaseSensitivity::CaseSensitive;
    static const CaseSensitivity CaseInsensitive =
        CaseSensitivity::CaseInsensitive;

    explicit CString(bool b) : std::string(b ? "true" : "false") {}
    explicit CString(char c);
    explicit CString(unsigned char c);
    explicit CString(short i);
    explicit CString(unsigned short i);
    explicit CString(int i);
    explicit CString(unsigned int i);
    explicit CString(long i);
    explicit CString(unsigned long i);
    explicit CString(long long i);
    explicit CString(unsigned long long i);
    explicit CString(double i, int precision = 2);
    explicit CString(float i, int precision = 2);

    CString() : std::string() {}
    CString(const char* c) : std::string(c) {}
    CString(const char* c, size_t l) : std::string(c, l) {}
    CString(const std::string& s) : std::string(s) {}
    CString(size_t n, char c) : std::string(n, c) {}
    CString(std::initializer_list<char> list) : std::string(list) {}
    ~CString() {}

    template <typename T>
    bool Convert(T* target) const {
        std::stringstream ss(*this);
        ss >> *target;
        return (bool)ss;  // we don't care why it failed, only whether it failed
    }

    template <typename Iterator>
    CString Join(Iterator i_start, const Iterator& i_end) const {
        if (i_start == i_end) return CString("");
        std::ostringstream output;
        output << *i_start;
        while (true) {
            ++i_start;
            if (i_start == i_end) return CString(output.str());
            output << *this;
            output << *i_start;
        }
    }

    int CaseCmp(const CString& s,
                CString::size_type uLen = CString::npos) const;
    int StrCmp(const CString& s, CString::size_type uLen = CString::npos) const;
    bool Equals(const CString& s, CaseSensitivity cs = CaseInsensitive) const;
    bool Equals(const CString& s, bool bCaseSensitive,
                CString::size_type uLen = CString::npos) const;
    static bool WildCmp(const CString& sWild, const CString& sString,
                        CaseSensitivity cs = CaseSensitive);
    bool WildCmp(const CString& sWild,
                 CaseSensitivity cs = CaseSensitive) const;

    CString& MakeUpper();
    CString& MakeLower();
    CString AsUpper() const;
    CString AsLower() const;

    static EEscape ToEscape(const CString& sEsc);
    CString Escape_n(EEscape eFrom, EEscape eTo) const;
    CString Escape_n(EEscape eTo) const;
    CString& Escape(EEscape eFrom, EEscape eTo);
    CString& Escape(EEscape eTo);

    static unsigned int Replace(CString& sStr, const CString& sReplace,
                                const CString& sWith, const CString& sLeft = "",
                                const CString& sRight = "",
                                bool bRemoveDelims = false);

    CString Replace_n(const CString& sReplace, const CString& sWith,
                      const CString& sLeft = "", const CString& sRight = "",
                      bool bRemoveDelims = false) const;
    unsigned int Replace(const CString& sReplace, const CString& sWith,
                         const CString& sLeft = "", const CString& sRight = "",
                         bool bRemoveDelims = false);
    CString Ellipsize(unsigned int uLen) const;
    CString Left(size_type uCount) const;
    CString Right(size_type uCount) const;

    CString FirstLine() const { return Token(0, false, "\n"); }

    CString Token(size_t uPos, bool bRest = false, const CString& sSep = " ",
                  bool bAllowEmpty = false) const;

    CString Token(size_t uPos, bool bRest, const CString& sSep,
                  bool bAllowEmpty, const CString& sLeft, const CString& sRight,
                  bool bTrimQuotes = true) const;

    size_type URLSplit(MCString& msRet) const;
    size_type OptionSplit(MCString& msRet, bool bUpperKeys = false) const;
    size_type QuoteSplit(VCString& vsRet) const;

    size_type Split(const CString& sDelim, VCString& vsRet,
                    bool bAllowEmpty = true, const CString& sLeft = "",
                    const CString& sRight = "", bool bTrimQuotes = true,
                    bool bTrimWhiteSpace = false) const;

    size_type Split(const CString& sDelim, SCString& ssRet,
                    bool bAllowEmpty = true, const CString& sLeft = "",
                    const CString& sRight = "", bool bTrimQuotes = true,
                    bool bTrimWhiteSpace = false) const;

    static CString NamedFormat(const CString& sFormat,
                               const MCString& msValues);

    static CString RandomString(unsigned int uLength);

    CString MD5() const;
    CString SHA256() const;

    unsigned long Base64Decode(CString& sRet) const;
    unsigned long Base64Decode();
    CString Base64Decode_n() const;
    bool Base64Encode(CString& sRet, unsigned int uWrap = 0) const;
    bool Base64Encode(unsigned int uWrap = 0);
    CString Base64Encode_n(unsigned int uWrap = 0) const;

#ifdef HAVE_LIBSSL
    CString Encrypt_n(const CString& sPass, const CString& sIvec = "") const;
    CString Decrypt_n(const CString& sPass, const CString& sIvec = "") const;
    void Encrypt(const CString& sPass, const CString& sIvec = "");
    void Decrypt(const CString& sPass, const CString& sIvec = "");
    void Crypt(const CString& sPass, bool bEncrypt, const CString& sIvec = "");
#endif

    static CString ToPercent(double d);
    static CString ToByteStr(unsigned long long d);
    static CString ToTimeStr(unsigned long s);

    bool ToBool() const;
    short ToShort() const;
    unsigned short ToUShort() const;
    int ToInt() const;
    long ToLong() const;
    unsigned int ToUInt() const;
    unsigned long ToULong() const;
    unsigned long long ToULongLong() const;
    long long ToLongLong() const;
    double ToDouble() const;

    bool Trim(const CString& s = " \t\r\n");
    bool TrimLeft(const CString& s = " \t\r\n");
    bool TrimRight(const CString& s = " \t\r\n");
    CString Trim_n(const CString& s = " \t\r\n") const;
    CString TrimLeft_n(const CString& s = " \t\r\n") const;
    CString TrimRight_n(const CString& s = " \t\r\n") const;

    bool TrimPrefix(const CString& sPrefix = ":");
    bool TrimSuffix(const CString& sSuffix);
    CString TrimPrefix_n(const CString& sPrefix = ":") const;
    CString TrimSuffix_n(const CString& sSuffix) const;

    size_t Find(const CString& s, CaseSensitivity cs = CaseInsensitive) const;
    bool StartsWith(const CString& sPrefix,
                    CaseSensitivity cs = CaseInsensitive) const;
    bool EndsWith(const CString& sSuffix,
                  CaseSensitivity cs = CaseInsensitive) const;
    bool Contains(const CString& s, CaseSensitivity cs = CaseInsensitive) const;

    bool LeftChomp(size_type uLen = 1);
    bool RightChomp(size_type uLen = 1);
    CString LeftChomp_n(size_type uLen = 1) const;
    CString RightChomp_n(size_type uLen = 1) const;
    CString& StripControls();
    CString StripControls_n() const;

  private:
  protected:
    unsigned char* strnchr(const unsigned char* src, unsigned char c,
                           unsigned int iMaxBytes,
                           unsigned char* pFill = nullptr,
                           unsigned int* piCount = nullptr) const;
};

class MCString : public std::map<CString, CString> {
  public:
    MCString() : std::map<CString, CString>() {}
    MCString(std::initializer_list<std::pair<const CString, CString>> list)
        : std::map<CString, CString>(list) {}
    virtual ~MCString() { clear(); }

    static const MCString EmptyMap;

    enum status_t {
        MCS_SUCCESS = 0,
        MCS_EOPEN = 1,
        MCS_EWRITE = 2,
        MCS_EWRITEFIL = 3,
        MCS_EREADFIL = 4
    };

    enum status_t WriteToDisk(const CString& sPath, mode_t iMode = 0644) const;
    enum status_t ReadFromDisk(const CString& sPath);

    virtual bool WriteFilter(CString& sKey, CString& sValue) const {
        return true;
    }
    virtual bool ReadFilter(CString& sKey, CString& sValue) const {
        return true;
    }

    virtual CString& Encode(CString& sValue) const;
    virtual CString& Decode(CString& sValue) const;
};

namespace std {
template <>
struct hash<CString> : hash<std::string> {};
}

// Make translateable messages easy to write:
// t_f("Foo is {1}")(foo)
class CInlineFormatMessage {
  public:
    explicit CInlineFormatMessage(const CString& sFormat)
        : m_sFormat(sFormat) {}
    explicit CInlineFormatMessage(CString&& sFormat)
        : m_sFormat(std::move(sFormat)) {}

    template <typename... Args>
    CString operator()(const Args&... args) const {
        MCString values;
        apply(values, 1, args...);
        return CString::NamedFormat(m_sFormat, values);
    }

  private:
    template <typename Arg, typename... Rest>
    void apply(MCString& values, int index, const Arg& arg,
               const Rest&... rest) const {
        values[CString(index)] = CString(arg);
        apply(values, index + 1, rest...);
    }

    void apply(MCString& values, int index) const {}

    CString m_sFormat;
};

// For gtest
#ifdef GTEST_FAIL
inline void PrintTo(const CString& s, std::ostream* os) {
    *os << '"' << s.Escape_n(CString::EDEBUG) << '"';
}
#endif

#endif  // !ZNCSTRING_H