/**
 *  This is free and unencumbered software released into the public domain.
 *  Anyone is free to copy, modify, publish, use, compile, sell, or
 *  distribute this software, either in source code form or as a compiled
 *  binary, for any purpose, commercial or non-commercial, and by any
 *  means.
 *
 *  In jurisdictions that recognize copyright laws, the author or authors
 *  of this software dedicate any and all copyright interest in the
 *  software to the public domain. We make this dedication for the benefit
 *  of the public at large and to the detriment of our heirs and
 *  successors. We intend this dedication to be an overt act of
 *  relinquishment in perpetuity of all present and future rights to this
 *  software under copyright law.
 *
 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 *  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 *  OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 *  ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 *  OTHER DEALINGS IN THE SOFTWARE.
 *
 *  For more information, please refer to <http://unlicense.org/>
 */

#include <cppcodec/base64_rfc4648.hpp>
#include <iostream>


// This example shows how to wrap a type (here: std::string) in another
// result type in order to modify the standard behavior for that type.
// Use this when you're in a position to wrap the result variable.
//
// This is the more straightforward of two ways for modifying cppcodec's
// behavior for a given type, the other one being able to modify the
// default behavior but also being more complex/intricate.
//
// The overall approach is straightforward: Define a result type with
// push_back(char) and size() methods, implement template specializations
// for init() and finish() for the result type, and call encode()/decode()
// with an object of this type as result parameter.

class string_append_wrapper
{
public:
    string_append_wrapper(std::string& backing)
        : m_backing(backing)
        , m_offset(0)
        , m_orig_size(0)
    {
    }

    void init(size_t capacity)
    {
        m_orig_size = m_backing.size();
        m_offset = m_orig_size;
        m_backing.resize(m_orig_size + capacity);
    }
    void finish()
    {
        m_backing.resize(m_offset);
    }

    // Methods required for satisfying default result type requirements:
    CPPCODEC_ALWAYS_INLINE void push_back(char c) { m_backing[m_offset++] = c; }
    CPPCODEC_ALWAYS_INLINE size_t size() const { return m_offset - m_orig_size; }

    // Note that the above implementation of push_back() is not the fastest,
    // because operator[] for std::string (for C++11 and above) still includes
    // a check for whether the size of the string fits into its allocation-less
    // character array union.
    //
    // With C++17 and above, it's legitimate to get the character array as a
    // mutable (non-const) char pointer, so this check can be skipped.
    // This is implemented via template specialization in cppcodec's
    // default behavior for std::string, but omitted here for simplicity.
    // If you need that last bit of extra performance, see
    // direct_data_access_result_state in cppcodec/data/access.hpp
    // for an example of optimal C++17 string access.

private:
    std::string& m_backing;
    size_t m_offset;
    size_t m_orig_size;
};


// init() and finish() must be declared in the cppcodec::data namespace.
namespace cppcodec {
namespace data {

template <> inline void init<string_append_wrapper>(
        string_append_wrapper& result, empty_result_state&, size_t capacity)
{
    // init() is called to prepare the output buffer. cppcodec will call it
    // with the maximum output size, null termination not included.
    //
    // Any thrown exception will not be caught by cppcodec itself,
    // the caller of the encode/decode function is responsible for handling it.
    //
    // empty_result_state can be ignored in this case because the wrapper type
    // can carry all required state internally.
    //
    // In order to maximize performance, init() should generally try to
    // allocate or guarantee the entire output buffer at once, so that
    // subsequent calls to push_back() don't result in extra checks (slower)
    // or even re-allocations.

    result.init(capacity);
}

// Between init() and finish(), cppcodec will call result.push_back(char)
// repeatedly, once for each output character with no rewinding.
// While init() can ask for greater capacity than the final output length,
// cppcodec guarantees that push_back() will never be called too often.
//
// (If you know exactly how long your output is, you could theoretically
// overcommit on capacity while allocating only the exact expected length
// of the output buffer. This is of course dangerous, because you can
// hardly ever know for sure and everyone's often wrong, so don't try it
// unless you have a business-critical reason to reduce/avoid the allocation.)

template <> inline void finish<string_append_wrapper>(
        string_append_wrapper& result, empty_result_state&)
{
    // finish() is called after encoding/decoding is done.
    // Its main purpose is to reduce the size of the result type
    // from capacity to the actual (often slightly smaller) output length.
    //
    // After finish(), cppcodec will assert that result.size() does indeed
    // equal the number of times that push_back() has been called.

    result.finish();
}

} // namespace data
} // namespace cppcodec


int main() {
    using base64 = cppcodec::base64_rfc4648;

    std::string result = "Result: ";
    string_append_wrapper appender(result);
    base64::encode(appender, std::string("any carnal pleasure"));
    std::cout << result << std::endl; // "Result: YW55IGNhcm5hbCBwbGVhc3VyZQ=="
    return 0;
}