BinarySink.hpp

/*
 * Copyright (C) 2020 Alexander Kornilov (akornilov.82@gmail.com)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef CPP_MATE_BINARY_SINK_HPP
#define CPP_MATE_BINARY_SINK_HPP
 
#include <CppMate/BinaryData.hpp>
#include <CppMate/Checkers.hpp>
 
#include <vector>
#include <limits>
 
#include <cstdint>
 
#include <memory.h>
 
namespace CppMate {
 
class BinarySink
{
public:
    class Closeable;
    class Null;
    class Chunk;
    class Memory;
    class Counter;
 
    virtual ~BinarySink() = default;
 
    virtual void write(const void* data, uint64_t size) = 0;
};
 
class BinarySink::Closeable: public virtual BinarySink
{
public:
 
    virtual bool isClosed() const = 0;
 
    virtual void close() = 0;
};
 
class BinarySink::Null: public BinarySink
{
public:
    void write(const void* data, uint64_t) override {
        checkArg(data);
    }
};
 
class BinarySink::Chunk: public virtual BinarySink
{
public:
 
    Chunk(size_t chunkSize = std::numeric_limits<size_t>::max()):
        _chunkSize(chunkSize)
    {
        checkArg(chunkSize > 0);
    }
 
    void write(const void* data, uint64_t size) override {
        checkArg(data);
        const auto* source = static_cast<const uint8_t*>(data);
        for (uint64_t i = 0; i < size / static_cast<uint64_t>(_chunkSize); i++) {
            writeChunk(source, _chunkSize);
            source += _chunkSize;
        }
        const auto lastChunkSize = size % _chunkSize;
        if (lastChunkSize) {
            writeChunk(source, lastChunkSize);
        }
    }
 
protected:
 
    virtual void writeChunk(const void* data, size_t size) = 0;
 
private:
    size_t _chunkSize;
};
 
class BinarySink::Memory: public BinarySink::Chunk, public BinaryData
{
public:
    const uint8_t* getData() const override { return &_buffer[0]; }
    uint64_t getSize() const override { return _buffer.size(); }
 
    void clear() { _buffer.clear(); }
 
protected:
    void writeChunk(const void* data, size_t size) override {
        const auto offset = _buffer.size();
        _buffer.resize(offset + size);
        memcpy(&_buffer[offset], data ,size);
    }
 
private:
    std::vector<uint8_t> _buffer;
};
 
class BinarySink::Counter: public virtual BinarySink
{
public:
 
    Counter(BinarySink& sink):
        _sink(sink),
        _bytesWritten(0) {}
 
    Counter(std::shared_ptr<BinarySink> sink):
        _sink(*sink),
        _sinkPtr(std::move(sink)),
        _bytesWritten(0)
    {
        checkArg(_sinkPtr.get());
    }
 
    uint64_t getBytesWritten() const { return _bytesWritten; }
 
    void resetCounter() { _bytesWritten = 0; }
 
    void write(const void* data, uint64_t size) override {
        checkArg(data);
        _sink.write(data, size);
        _bytesWritten += size;
    }
 
private:
    BinarySink& _sink;
    std::shared_ptr<BinarySink> _sinkPtr;
    uint64_t _bytesWritten;
};
 
} // namespace CppMate
 
#endif // CPP_MATE_BINARY_SINK_HPP