base64.hpp

Go to the documentation of this file.

 
#ifndef __JOIN_BASE64_HPP__
#define __JOIN_BASE64_HPP__
 
// libjoin.
#include <join/openssl.hpp>
 
// C++.
#include <iostream>
#include <iomanip>
#include <string>
 
namespace join
{
    using BytesArray = std::vector <uint8_t>;
 
    __inline__ std::string bin2hex (const BytesArray& bin)
    {
        std::stringstream oss;
        for (size_t i = 0; i < bin.size (); ++i)
        {
            oss << std::hex << std::setw (2) << std::setfill ('0') << static_cast <uint32_t> (bin[i]);
        }
        return oss.str ();
    }
 
    class Encoderbuf : public std::streambuf
    {
    public:
        Encoderbuf ();
 
        Encoderbuf (const Encoderbuf& other) = delete;
 
        Encoderbuf& operator= (const Encoderbuf& other) = delete;
 
        Encoderbuf (Encoderbuf&& other);
 
        Encoderbuf& operator= (Encoderbuf&& other);
 
        virtual ~Encoderbuf () = default;
 
        std::string get ();
 
    protected:
        virtual int_type overflow (int_type c = traits_type::eof ()) override;
 
        static const std::streamsize _bufsize = 256;
 
        std::unique_ptr <char []> _buf;
 
        EvpEncodeCtxPtr _encodectx;
 
        std::string _out;
    };
 
    class Encoder : public std::ostream
    {
    public:
        Encoder ();
 
        Encoder (const Encoder& other) = delete;
 
        Encoder& operator=(const Encoder& other) = delete;
 
        Encoder (Encoder&& other);
 
        Encoder& operator=(Encoder&& other);
 
        virtual ~Encoder () = default;
 
        std::string get ();
 
    protected:
        Encoderbuf _encoderbuf;
    };
 
    class Decoderbuf : public std::streambuf
    {
    public:
        Decoderbuf ();
 
        Decoderbuf (const Decoderbuf& other) = delete;
 
        Decoderbuf& operator= (const Decoderbuf& other) = delete;
 
        Decoderbuf (Decoderbuf&& other);
 
        Decoderbuf& operator= (Decoderbuf&& other);
 
        virtual ~Decoderbuf () = default;
 
        BytesArray get ();
 
    protected:
        virtual int_type overflow (int_type c = traits_type::eof ()) override;
 
        static const std::streamsize _bufsize = 256;
 
        std::unique_ptr <char []> _buf;
 
        EvpEncodeCtxPtr _decodectx;
 
        BytesArray _out;
    };
 
    class Decoder : public std::ostream
    {
    public:
        Decoder ();
 
        Decoder (const Decoder& other) = delete;
 
        Decoder& operator=(const Decoder& other) = delete;
 
        Decoder (Decoder&& other);
 
        Decoder& operator=(Decoder&& other);
 
        virtual ~Decoder () = default;
 
        BytesArray get ();
 
    protected:
        Decoderbuf _decoderbuf;
    };
 
    class Base64
    {
    public:
        Base64 () = delete;
 
        ~Base64 () = delete;
 
        static std::string encode (const char* data, size_t size);
 
        static std::string encode (const std::string& data);
 
        static std::string encode (const BytesArray& data);
 
        static BytesArray decode (const std::string& data);
    };
}
 
#endif