Base64encoder.h

#pragma once


#include <libutl/Encoder.h>


UTL_NS_BEGIN;

// Base64encode ////////////////////////////////////////////////////////////////////////////////////


class Base64encode : public Object
{
    UTL_CLASS_DECL(Base64encode, Object);
    UTL_CLASS_NO_COMPARE;
    UTL_CLASS_NO_COPY;

public:
    Base64encode(utl::Stream* os, bool owner = false)
    {
        init();
        setOutputStream(os, owner);
    }

    Stream*
    stream() const
    {
        return _os;
    }

    bool
    streamOwner() const
    {
        return _owner;
    }

    void
    setOutputStream(Stream* os, bool owner = false)
    {
        if (_owner) delete _os;
        _os = os;
        _owner = owner;
    }

    void process(const byte_t* data, size_t dataLen);

    void finalize();

private:
    void
    init()
    {
        _dataLen = 0;
        _owner = false;
        _os = nullptr;
    }
    void
    deInit()
    {
        try
        {
            finalize();
        }
        catch (...)
        {
        }
        setOutputStream(nullptr);
    }

private:
    byte_t _data[3];
    byte_t _dataLen;
    byte_t _owner;
    utl::Stream* _os;
};

// Base64decode ////////////////////////////////////////////////////////////////////////////////////


class Base64decode : public Object
{
    UTL_CLASS_DECL(Base64decode, Object);
    UTL_CLASS_NO_COMPARE;
    UTL_CLASS_NO_COPY;

public:
    Base64decode(utl::Stream* os, bool owner = false)
    {
        init();
        setOutputStream(os, owner);
    }

    Stream*
    stream() const
    {
        return _os;
    }

    bool
    streamOwner() const
    {
        return _owner;
    }

    void
    setOutputStream(Stream* os, bool owner = false)
    {
        if (_owner) delete _os;
        _os = os;
        _owner = owner;
    }

    void process(const byte_t* data, size_t dataLen);

    void finalize();

private:
    void init();
    void
    deInit()
    {
        try
        {
            finalize();
        }
        catch (...)
        {
        }
        setOutputStream(nullptr);
    }

private:
    uint32_t _data;
    uint32_t _dataShift;
    byte_t _owner;
    utl::Stream* _os;
};

// Base64encoder ///////////////////////////////////////////////////////////////////////////////////


class Base64encoder : public Encoder
{
    UTL_CLASS_DECL(Base64encoder, Encoder);

public:
    Base64encoder(uint_t mode, Stream* stream, bool owner = true)
    {
        init();
        start(mode, stream, owner);
    }

    virtual size_t encode(const byte_t* block, size_t num);

    virtual size_t decode(byte_t* block, size_t num);

    void start(uint_t mode, Stream* stream, bool owner = true);

protected:
    virtual void clear();
    virtual void finishEncoding();
    virtual size_t finishDecoding();

private:
    void
    init()
    {
        _codec.object = nullptr;
    }
    void
    deInit()
    {
        close();
    }

private:
    union
    {
        Object* object;
        Base64encode* encode;
        Base64decode* decode;
    } _codec;
};


UTL_NS_END;