root/util.hh

/*  This file is part of Alue, the multiprotocol Internet discussion daemon

    Copyright © 2009, 2010 Antti-Juhani Kaijanaho

    Alue is free software: you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Alue is distributed in the hope that it will be useful, but
    WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Alue.  If not, see <http://www.gnu.org/licenses/>.

 */

#ifndef GUARD_UTIL_HH
#define GUARD_UTIL_HH

#include <boost/asio/streambuf.hpp>
#include <stdexcept>
#include <string>

namespace util
{
        inline std::string to_lower(const std::string s)
        {
                std::string rv = s;
                for (size_t i = 0; i < s.length(); i++)
                {
                        if ('A' <= rv[i] && rv[i] <= 'Z') rv[i] += 'a' - 'A';
                }
                return rv;
        }

        /** Strips off any trailing LF or CRLF. */
        inline void strip_crlf(std::string &s) 
        {
                if (*(s.rbegin()) != '\n') return;
                s.erase(s.length()-1);
                if (*(s.rbegin()) != '\r') return;
                s.erase(s.length()-1);
        }

        inline void strip(std::string &s)
        {
                while (!s.empty() &&
                       (s[0] == ' '  || s[0] == '\t' ||
                        s[0] == '\r' || s[0] == '\n'))
                        s.erase(0,1);
                while (!s.empty() &&
                       (s[s.length()-1] == ' '  || s[s.length()-1] == '\t' ||
                        s[s.length()-1] == '\r' || s[s.length()-1] == '\n'))
                        s.erase(s.length()-1);
        }

        class parse_exception : public std::exception {
        public:
                const char *what() const throw() { 
                        return "parse error";
                }
        };

        /* Converts the string s (which must be a sequence of digits)
         * into a numeric value.  */
        template <typename Int>
        Int parse_nonnegative_integer(std::string s)
                throw (parse_exception)
        {
                Int rv = 0;

                for (size_t i = 0; i < s.length();i++) {
                        if (!('0' <= s[i] && s[i] <= '9')) {
                                throw parse_exception();
                        }
                        rv = 10*rv + (s[i] - '0');
                }
                return rv;
        }

        /** Splits off the first token (which is the longest string
         * not containing any of the sep characters), and returns it.
         * Any leading sep characters are erased.  The rest of the
         * string is stored in s. */
        std::string split(std::string &s, const char *sep = " \t\r\n");

        /** Splits off the first field and its delimeter (one
         * character only!).  If there is no delim, the field
         * encompasses the whole string. */
        std::string split1R(std::string &s, const char *delim);

        /** Splits off the first field and its delimeter (one
         * character only!).  If there is no delim, the field is
         * empty. */
        std::string split1L(std::string &s, const char *delim);

        /** Returns true if s is a sequence of digits. */
        bool is_number(std::string s);

        /** Returns true if c is an ASCII digit (note: locale has no
         * effect).  */
        inline bool is_digit(char c) 
        {
                return '0' <= c && c <= '9';
        }

        // assuming that i is at the start of a character, change it
        // to be at the start of the next character
        inline void advance_utf8(std::string s, size_t &i)
        {
                unsigned char c = s[i];
                /**/ if (c < 0xc0) i += 1;
                else if (c < 0xd0) i += 2;
                else if (c < 0xe0) i += 3;
                else               i += 4;
        }

        /* Returns the current date-time in IMF (RFC 5322) format */
        std::string current_imf_date();

        // URI-safe base64 - this is _not_ MIME base64
        inline char b64_char(unsigned val)
        {
                if (val < 26) return val + 'A';
                if (val < 52) return val - 26 + 'a';
                if (val < 62) return val - 52 + '0';
                if (val == 62) return '-';
                if (val == 63) return '.';
                throw std::logic_error("b64_char");
        }

        /* WARNING: The resulting string may be longer than n.  If you
           need exactly n, truncate the string afterward by using the resize(n)
           method. */
        std::string streambuf_to_string(boost::asio::streambuf &sbuf, size_t n);
}

#endif /* GUARD_UTIL_HH */