anope.h

Go to the documentation of this file.

/*
 *
 * (C) 2003-2013 Anope Team
 * Contact us at team@anope.org
 *
 * Please read COPYING and README for further details.
 *
 * Based on the original code of Epona by Lara.
 * Based on the original code of Services by Andy Church.
 *
 */

#ifndef ANOPE_H
#define ANOPE_H

#include <signal.h>

#include "hashcomp.h"

namespace Anope
{
        class CoreExport string
        {
         private:
                std::string _string;
         public:
                typedef std::string::iterator iterator;
                typedef std::string::const_iterator const_iterator;
                typedef std::string::reverse_iterator reverse_iterator;
                typedef std::string::const_reverse_iterator const_reverse_iterator;
                typedef std::string::size_type size_type;
                static const size_type npos = static_cast<size_type>(-1);

                string() : _string("") { }
                string(char chr) : _string() { _string = chr; }
                string(size_type n, char chr) : _string(n, chr) { }
                string(const char *_str) : _string(_str) { }
                string(const char *_str, size_type n) : _string(_str, n) { }
                string(const std::string &_str) : _string(_str) { }
                string(const ci::string &_str) : _string(_str.c_str()) { }
                string(const string &_str, size_type pos, size_type n = npos) : _string(_str._string, pos, n) { }
                template <class InputIterator> string(InputIterator first, InputIterator last) : _string(first, last) { }

                inline string &operator=(char chr) { this->_string = chr; return *this; }
                inline string &operator=(const char *_str) { this->_string = _str; return *this; }
                inline string &operator=(const std::string &_str) { this->_string = _str; return *this; }
                inline string &operator=(const string &_str) { if (this != &_str) this->_string = _str._string; return *this; }

                inline bool operator==(const char *_str) const { return this->_string == _str; }
                inline bool operator==(const std::string &_str) const { return this->_string == _str; }
                inline bool operator==(const string &_str) const { return this->_string == _str._string; }

                inline bool equals_cs(const char *_str) const { return this->_string == _str; }
                inline bool equals_cs(const std::string &_str) const { return this->_string == _str; }
                inline bool equals_cs(const string &_str) const { return this->_string == _str._string; }

                inline bool equals_ci(const char *_str) const { return ci::string(this->_string.c_str()) == _str; }
                inline bool equals_ci(const std::string &_str) const { return ci::string(this->_string.c_str()) == _str.c_str(); }
                inline bool equals_ci(const string &_str) const { return ci::string(this->_string.c_str()) == _str._string.c_str(); }

                inline bool operator!=(const char *_str) const { return !operator==(_str); }
                inline bool operator!=(const std::string &_str) const { return !operator==(_str); }
                inline bool operator!=(const string &_str) const { return !operator==(_str); }

                inline string &operator+=(char chr) { this->_string += chr; return *this; }
                inline string &operator+=(const char *_str) { this->_string += _str; return *this; }
                inline string &operator+=(const std::string &_str) { this->_string += _str; return *this; }
                inline string &operator+=(const string &_str) { if (this != &_str) this->_string += _str._string; return *this; }

                inline const string operator+(char chr) const { return string(*this) += chr; }
                inline const string operator+(const char *_str) const { return string(*this) += _str; }
                inline const string operator+(const std::string &_str) const { return string(*this) += _str; }
                inline const string operator+(const string &_str) const { return string(*this) += _str; }

                friend const string operator+(char chr, const string &str);
                friend const string operator+(const char *_str, const string &str);
                friend const string operator+(const std::string &_str, const string &str);

                inline bool operator<(const string &_str) const { return this->_string < _str._string; }

                inline const char *c_str() const { return this->_string.c_str(); }
                inline std::string &str() { return this->_string; }
                inline const std::string &str() const { return this->_string; }
                inline ci::string ci_str() const { return ci::string(this->_string.c_str()); }

                inline bool empty() const { return this->_string.empty(); }

                inline size_type length() const { return this->_string.length(); }

                inline size_type capacity() const { return this->_string.capacity(); }

                inline void push_back(char c) { return this->_string.push_back(c); }

                inline string& append(const string &s) { this->_string.append(s.str()); return *this; }
                inline string& append(const char *s, size_t n) { this->_string.append(s, n); return *this; }

                inline void resize(size_type n) { return this->_string.resize(n); }

                inline iterator erase(const iterator &i) { return this->_string.erase(i); }
                inline iterator erase(const iterator &first, const iterator &last) { return this->_string.erase(first, last); }
                inline void erase(size_type pos = 0, size_type n = std::string::npos) { this->_string.erase(pos, n); }

                inline string& ltrim()
                {
                        while (!this->_string.empty() && isspace(this->_string[0]))
                                this->_string.erase(this->_string.begin());
                        return *this;
                }

                inline string& rtrim()
                {
                        while (!this->_string.empty() && isspace(this->_string[this->_string.length() - 1]))
                                this->_string.erase(this->_string.length() - 1);
                        return *this;
                }

                inline string& trim()
                {
                        this->ltrim();
                        this->rtrim();
                        return *this;
                }

                inline void clear() { this->_string.clear(); }

                inline size_type find(const string &_str, size_type pos = 0) const { return this->_string.find(_str._string, pos); }
                inline size_type find(char chr, size_type pos = 0) const { return this->_string.find(chr, pos); }
                inline size_type find_ci(const string &_str, size_type pos = 0) const { return ci::string(this->_string.c_str()).find(ci::string(_str._string.c_str()), pos); }
                inline size_type find_ci(char chr, size_type pos = 0) const { return ci::string(this->_string.c_str()).find(chr, pos); }

                inline size_type rfind(const string &_str, size_type pos = npos) const { return this->_string.rfind(_str._string, pos); }
                inline size_type rfind(char chr, size_type pos = npos) const { return this->_string.rfind(chr, pos); }
                inline size_type rfind_ci(const string &_str, size_type pos = npos) const { return ci::string(this->_string.c_str()).rfind(ci::string(_str._string.c_str()), pos); }
                inline size_type rfind_ci(char chr, size_type pos = npos) const { return ci::string(this->_string.c_str()).rfind(chr, pos); }

                inline size_type find_first_of(const string &_str, size_type pos = 0) const { return this->_string.find_first_of(_str._string, pos); }
                inline size_type find_first_of_ci(const string &_str, size_type pos = 0) const { return ci::string(this->_string.c_str()).find_first_of(ci::string(_str._string.c_str()), pos); }

                inline size_type find_first_not_of(const string &_str, size_type pos = 0) const { return this->_string.find_first_not_of(_str._string, pos); }
                inline size_type find_first_not_of_ci(const string &_str, size_type pos = 0) const { return ci::string(this->_string.c_str()).find_first_not_of(ci::string(_str._string.c_str()), pos); }

                inline size_type find_last_of(const string &_str, size_type pos = npos) const { return this->_string.find_last_of(_str._string, pos); }
                inline size_type find_last_of_ci(const string &_str, size_type pos = npos) const { return ci::string(this->_string.c_str()).find_last_of(ci::string(_str._string.c_str()), pos); }

                inline size_type find_last_not_of(const string &_str, size_type pos = npos) const { return this->_string.find_last_not_of(_str._string, pos); }
                inline size_type find_last_not_of_ci(const string &_str, size_type pos = npos) const { return ci::string(this->_string.c_str()).find_last_not_of(ci::string(_str._string.c_str()), pos); }

                inline bool is_number_only() const { return this->find_first_not_of("0123456789.-") == npos; }
                inline bool is_pos_number_only() const { return this->find_first_not_of("0123456789.") == npos; }

                inline string replace(size_type pos, size_type n, const string &_str) { return string(this->_string.replace(pos, n, _str._string)); }
                inline string replace(size_type pos, size_type n, const string &_str, size_type pos1, size_type n1) { return string(this->_string.replace(pos, n, _str._string, pos1, n1)); }
                inline string replace(size_type pos, size_type n, size_type n1, char chr) { return string(this->_string.replace(pos, n, n1, chr)); }
                inline string replace(iterator first, iterator last, const string &_str) { return string(this->_string.replace(first, last, _str._string)); }
                inline string replace(iterator first, iterator last, size_type n, char chr) { return string(this->_string.replace(first, last, n, chr)); }
                template <class InputIterator> inline string replace(iterator first, iterator last, InputIterator f, InputIterator l) { return string(this->_string.replace(first, last, f, l)); }
                inline string replace_all_cs(const string &_orig, const string &_repl)
                {
                        Anope::string new_string = *this;
                        size_type pos = new_string.find(_orig), orig_length = _orig.length(), repl_length = _repl.length();
                        while (pos != npos)
                        {
                                new_string = new_string.substr(0, pos) + _repl + new_string.substr(pos + orig_length);
                                pos = new_string.find(_orig, pos + repl_length);
                        }
                        return new_string;
                }
                inline string replace_all_ci(const string &_orig, const string &_repl)
                {
                        Anope::string new_string = *this;
                        size_type pos = new_string.find_ci(_orig), orig_length = _orig.length(), repl_length = _repl.length();
                        while (pos != npos)
                        {
                                new_string = new_string.substr(0, pos) + _repl + new_string.substr(pos + orig_length);
                                pos = new_string.find_ci(_orig, pos + repl_length);
                        }
                        return new_string;
                }

                inline string lower() const
                {
                        Anope::string new_string = *this;
                        for (size_type i = 0; i < new_string.length(); ++i)
                                new_string[i] = std::tolower(new_string[i], Anope::casemap);
                        return new_string;
                }

                inline string upper() const
                {
                        Anope::string new_string = *this;
                        for (size_type i = 0; i < new_string.length(); ++i)
                                new_string[i] = std::toupper(new_string[i], Anope::casemap);
                        return new_string;
                }

                inline string substr(size_type pos = 0, size_type n = npos) const { return string(this->_string.substr(pos, n)); }

                inline iterator begin() { return this->_string.begin(); }
                inline const_iterator begin() const { return this->_string.begin(); }
                inline iterator end() { return this->_string.end(); }
                inline const_iterator end() const { return this->_string.end(); }
                inline reverse_iterator rbegin() { return this->_string.rbegin(); }
                inline const_reverse_iterator rbegin() const { return this->_string.rbegin(); }
                inline reverse_iterator rend() { return this->_string.rend(); }
                inline const_reverse_iterator rend() const { return this->_string.rend(); }

                inline char &operator[](size_type n) { return this->_string[n]; }
                inline const char &operator[](size_type n) const { return this->_string[n]; }

                friend std::ostream &operator<<(std::ostream &os, const string &_str);
                friend std::istream &operator>>(std::istream &is, string &_str);
        };

        inline std::ostream &operator<<(std::ostream &os, const string &_str) { return os << _str._string; }
        /* This is not standard to make operator>> behave like operator<< in that it will allow extracting a whole line, not just one word */
        inline std::istream &operator>>(std::istream &is, string &_str) { return std::getline(is,  _str._string); }

        inline const string operator+(char chr, const string &str) { string tmp(chr); tmp += str; return tmp; }
        inline const string operator+(const char *_str, const string &str) { string tmp(_str); tmp += str; return tmp; }
        inline const string operator+(const std::string &_str, const string &str) { string tmp(_str); tmp += str; return tmp; }

        struct hash_ci
        {
                inline size_t operator()(const string &s) const
                {
                        return std::tr1::hash<std::string>()(s.lower().str());
                }
        };

        struct hash_cs
        {
                inline size_t operator()(const string &s) const
                {
                        return std::tr1::hash<std::string>()(s.str());
                }
        };

        struct compare
        {
                inline bool operator()(const string &s1, const string &s2) const
                {
                        return s1.equals_ci(s2);
                }
        };

        template<typename T> class map : public std::map<string, T, ci::less> { };
        template<typename T> class hash_map : public std::tr1::unordered_map<string, T, hash_ci, compare> { };

        static const char *const compiled = __TIME__ " " __DATE__;

        extern CoreExport time_t StartTime;

        extern int ReturnValue;

        extern sig_atomic_t Signal;
        extern CoreExport bool Quitting;
        extern CoreExport bool Restarting;
        extern CoreExport Anope::string QuitReason;

        extern CoreExport time_t CurTime;

        extern CoreExport int Debug;

        extern CoreExport bool ReadOnly, NoFork, NoThird, NoExpire, ProtocolDebug;

        extern CoreExport Anope::string ServicesDir;

        extern CoreExport Anope::string ServicesBin;

        extern CoreExport Anope::string ConfigDir;
        extern CoreExport Anope::string DataDir;
        extern CoreExport Anope::string ModuleDir;
        extern CoreExport Anope::string LocaleDir;
        extern CoreExport Anope::string LogDir;

        extern CoreExport int CurrentUplink;

        extern CoreExport string Version();
        extern CoreExport string VersionShort();
        extern CoreExport string VersionBuildString();
        extern CoreExport int VersionMajor();
        extern CoreExport int VersionMinor();
        extern CoreExport int VersionPatch();

        extern bool AtTerm();

        extern void Fork();

        extern void HandleSignal();

        extern void Init(int ac, char **av);

        extern CoreExport void SaveDatabases();

        extern CoreExport bool Match(const string &str, const string &mask, bool case_sensitive = false, bool use_regex = false);

        extern CoreExport string Hex(const string &data);
        extern CoreExport string Hex(const char *data, unsigned len);

        extern CoreExport void Unhex(const string &src, string &dest);
        extern CoreExport void Unhex(const string &src, char *dest, size_t sz);
        
        extern CoreExport void B64Encode(const string &src, string &target);
        
        extern CoreExport void B64Decode(const string &src, string &target);

        extern CoreExport void Encrypt(const Anope::string &src, Anope::string &dest);

        extern CoreExport bool Decrypt(const Anope::string &src, Anope::string &dest);

        extern CoreExport string printf(const char *fmt, ...);

        extern CoreExport int LastErrorCode();

        extern CoreExport const string LastError();

        extern CoreExport bool IsFile(const Anope::string &file);

        extern CoreExport time_t DoTime(const Anope::string &s);

        extern CoreExport Anope::string Duration(time_t seconds, const NickCore *nc = NULL);

        extern CoreExport Anope::string Expires(time_t seconds, const NickCore *nc = NULL);

        extern CoreExport Anope::string strftime(time_t t, const NickCore *nc = NULL, bool short_output = false);

        extern CoreExport Anope::string NormalizeBuffer(const Anope::string &);

        extern void Process(const Anope::string &);

        extern Anope::string Resolve(const Anope::string &host, int type);
}

class CoreExport sepstream
{
 private:
        Anope::string tokens;
        Anope::string::iterator last_starting_position;
        Anope::string::iterator n;
        char sep;
 public:
        sepstream(const Anope::string &source, char seperator);

        bool GetToken(Anope::string &token);

        bool GetToken(Anope::string &token, int num);

        template<typename T> void GetTokens(T& token)
        {
                token.clear();
                Anope::string t;
                while (this->GetToken(t))
                        token.push_back(t);
        }

        bool GetTokenRemainder(Anope::string &token, int num);

        int NumTokens();

        const Anope::string GetRemaining();

        bool StreamEnd();
};

class commasepstream : public sepstream
{
 public:
        commasepstream(const Anope::string &source) : sepstream(source, ',') { }
};

class spacesepstream : public sepstream
{
 public:
        spacesepstream(const Anope::string &source) : sepstream(source, ' ') { }
};

class CoreException : public std::exception
{
 protected:
        Anope::string err;
        Anope::string source;
 public:
        CoreException() : err("Core threw an exception"), source("The core") { }
        CoreException(const Anope::string &message) : err(message), source("The core") { }
        CoreException(const Anope::string &message, const Anope::string &src) : err(message), source(src) { }
        virtual ~CoreException() throw() { }
        virtual const Anope::string &GetReason() const
        {
                return err;
        }

        virtual const Anope::string &GetSource() const
        {
                return source;
        }
};

class ModuleException : public CoreException
{
 public:
        ModuleException() : CoreException("Module threw an exception", "A Module") { }

        ModuleException(const Anope::string &message) : CoreException(message, "A Module") { }
        virtual ~ModuleException() throw() { }
};

class ConvertException : public CoreException
{
 public:
        ConvertException(const Anope::string &reason = "") : CoreException(reason) { }

        virtual ~ConvertException() throw() { }
};

template<typename T> inline Anope::string stringify(const T &x)
{
        std::ostringstream stream;

        if (!(stream << x))
                throw ConvertException("Stringify fail");

        return stream.str();
}

template<typename T> inline void convert(const Anope::string &s, T &x, Anope::string &leftover, bool failIfLeftoverChars = true)
{
        leftover.clear();
        std::istringstream i(s.str());
        char c;
        bool res = i >> x;
        if (!res)
                throw ConvertException("Convert fail");
        if (failIfLeftoverChars)
        {
                if (i.get(c))
                        throw ConvertException("Convert fail");
        }
        else
        {
                std::string left;
                getline(i, left);
                leftover = left;
        }
}

template<typename T> inline void convert(const Anope::string &s, T &x, bool failIfLeftoverChars = true)
{
        Anope::string Unused;
        convert(s, x, Unused, failIfLeftoverChars);
}

template<typename T> inline T convertTo(const Anope::string &s, Anope::string &leftover, bool failIfLeftoverChars = true)
{
        T x;
        convert(s, x, leftover, failIfLeftoverChars);
        return x;
}

template<typename T> inline T convertTo(const Anope::string &s, bool failIfLeftoverChars = true)
{
        T x;
        convert(s, x, failIfLeftoverChars);
        return x;
}

#ifdef DEBUG_BUILD
# include <typeinfo>
#endif
template<typename T, typename O> inline T anope_dynamic_static_cast(O ptr)
{
#ifdef DEBUG_BUILD
        T ret = dynamic_cast<T>(ptr);
        if (ptr != NULL && ret == NULL)
                throw CoreException(Anope::string("anope_dynamic_static_cast<") + typeid(T).name() + ">(" + typeid(O).name() + ") fail");
        return ret;
#else
        return static_cast<T>(ptr);
#endif
}

#endif // ANOPE_H