base64ostream.cpp

Go to the documentation of this file.

/*
 * Copyright (C) 2020 Ondrej Starek
 *
 * This file is part of OTest2.
 *
 * OTest2 is free software: you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License,
 * or (at your option) any later version.
 *
 * OTest2 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 Lesser General Public
 * License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with OTest2.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#include <base64ostream.h>
 
#include <assert.h>
#include <cstdint>
#include <streambuf>
 
#include <utils.h>
 
namespace OTest2 {
 
class Base64OStream::Buffer : public std::streambuf {
  private:
    std::ostream* decorated;
 
    int output_raw_width;
    int output_base64_width;
    bool output_newline;
    char* output_buffer;
 
  public:
    explicit Buffer(
        std::ostream* decorated_,
        int width_);
 
    virtual ~Buffer();
 
    /* -- avoid copying */
    Buffer(
        const Buffer&) = delete;
    Buffer& operator = (
        const Buffer&) = delete;
 
    bool finish() noexcept;
 
  private:
    /* -- streambuf interface */
    virtual int overflow(
        int c) override;
 
    void finishData();
};
 
 
Base64OStream::Buffer::Buffer(
    std::ostream* decorated_,
    int width_) :
  decorated(decorated_) {
  assert(decorated != nullptr);
 
  /* -- Create output buffer with size according to requested line width. */
  if(width_ > 0) {
    assert(width_ % 4 == 0);
    output_base64_width = width_;
    output_newline = true;
  }
  else {
    output_base64_width = 80;
    output_newline = false;
  }
  output_raw_width = output_base64_width / 4 * 3;
  output_buffer = new char[output_raw_width];
 
  /* -- set the streambuf pointers */
  setp(output_buffer, output_buffer + output_raw_width);
}
 
Base64OStream::Buffer::~Buffer() {
  finishData();
  delete[] output_buffer;
}
 
void Base64OStream::Buffer::finishData() {
  /* -- compute length of data */
  auto length_(pptr() - output_buffer);
  assert(length_ >= 0 && length_ <= output_raw_width);
 
  /* -- encode the output buffer */
  static const unsigned char base64_table[] =
      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  char buffer_[output_base64_width];
  const std::uint8_t* in_(reinterpret_cast<std::uint8_t*>(output_buffer));
  char* out_(buffer_);
  while(length_ >= 3) {
    *out_++ = base64_table[in_[0] >> 2];
    *out_++ = base64_table[((in_[0] & 0x03) << 4) | (in_[1] >> 4)];
    *out_++ = base64_table[((in_[1] & 0x0f) << 2) | (in_[2] >> 6)];
    *out_++ = base64_table[in_[2] & 0x3f];
    length_ -= 3;
    in_ += 3;
  }
  if(length_ > 0) {
    /* -- Padding should happen only if the sequence is closed. Otherwise,
     *    the data length is divisible by 3. */
    *out_++ = base64_table[in_[0] >> 2];
    if(length_ == 1) {
        *out_++ = base64_table[(in_[0] & 0x03) << 4];
        *out_++ = '=';
    }
    else {
        *out_++ = base64_table[((in_[0] & 0x03) << 4) | (in_[1] >> 4)];
        *out_++ = base64_table[(in_[1] & 0x0f) << 2];
    }
    *out_++ = '=';
  }
 
  /* -- reset the buffer pointers */
  setp(output_buffer, output_buffer + output_raw_width);
 
  /* -- push the encoded data into the decorated stream buffer */
  auto coded_length_(out_ - buffer_);
  decorated->write(buffer_, static_cast<std::streamsize>(coded_length_));
}
 
int Base64OStream::Buffer::overflow(
    int c) {
  /* -- flush current data */
  finishData();
 
  /* -- start new line if it's requested */
  if(output_newline)
    decorated->put('\n');
 
  /* -- write the character */
  if(c != traits_type::eof()) {
    *output_buffer = traits_type::to_char_type(c);
    pbump(1);
  }
 
  return traits_type::not_eof(c);
}
 
bool Base64OStream::Buffer::finish() noexcept {
  finishData();
  return true;
}
 
Base64OStream::Base64OStream(
    std::ostream* decorated_,
    int line_length_) :
  buffer(new Buffer(decorated_, line_length_)) {
  rdbuf(buffer);
}
 
Base64OStream::~Base64OStream() {
  odelete(buffer);
}
 
bool Base64OStream::finish() noexcept {
  return buffer->finish();
}
 
} /* -- namespace OTest2 */