ZNCString.h

Go to the documentation of this file.

/*
 * Copyright (C) 2004-2013 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>

#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,
};

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

        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() {}
        
        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, bool bCaseSensitive = false, CString::size_type uLen = CString::npos) const;
        static bool WildCmp(const CString& sWild, const CString& sString);
        bool WildCmp(const CString& sWild) 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;

        bool StartsWith(const CString& sPrefix) const;
        bool EndsWith(const CString& sSuffix) 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 = NULL, unsigned int* piCount = NULL) const;
};

class MCString : public std::map<CString, CString> {
public:
        MCString() : std::map<CString, CString>() {}
        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;
};

#endif // !ZNCSTRING_H