WriteStream.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_WRITE_STREAM_HPP
#define CPP_MATE_WRITE_STREAM_HPP
 
#include <CppMate/BinarySink.hpp>
#include <CppMate/ByteOrder.hpp>
#include <CppMate/Checkers.hpp>
 
#include <cstring>
 
#include <memory>
#include <string>
 
namespace CppMate {
 
class WriteStream final
{
public:
 
    WriteStream(std::shared_ptr<BinarySink> sink, ByteOrder byteOrder = ByteOrder::Unknown):
        _sharedSink(std::move(sink)),
        _sink(_sharedSink.get()),
        _byteOrder(byteOrder != ByteOrder::Unknown ? byteOrder : getNativeByteOrder()),
        _isNativeByteOrder(_byteOrder == getNativeByteOrder())
    {
        checkArg(_sink);
    }
 
    WriteStream(BinarySink* sink, ByteOrder byteOrder = ByteOrder::Unknown):
        _sink(sink),
        _byteOrder(byteOrder != ByteOrder::Unknown ? byteOrder : getNativeByteOrder()),
        _isNativeByteOrder(_byteOrder == getNativeByteOrder())
    {
        checkArg(_sink);
    }
 
    ByteOrder getByteOrder() const { return _byteOrder; }
 
    template<typename T>
    inline void write(T value) {
        if (_isNativeByteOrder || sizeof(T) < 2) {
            _sink->write(&value, sizeof(value));
        } else {
            T reverse;
            auto const srcPtr = reinterpret_cast<uint8_t *>(&value);
            auto const dstPtr = reinterpret_cast<uint8_t *>(&reverse);
            switch (sizeof(T)) {
            case 2:
                dstPtr[0] = srcPtr[1];
                dstPtr[1] = srcPtr[0];
                break;
            case 4:
                dstPtr[0] = srcPtr[3];
                dstPtr[1] = srcPtr[2];
                dstPtr[2] = srcPtr[1];
                dstPtr[3] = srcPtr[0];
                break;
            case 8:
                dstPtr[0] = srcPtr[7];
                dstPtr[1] = srcPtr[6];
                dstPtr[2] = srcPtr[5];
                dstPtr[3] = srcPtr[4];
                dstPtr[4] = srcPtr[3];
                dstPtr[5] = srcPtr[2];
                dstPtr[6] = srcPtr[1];
                dstPtr[7] = srcPtr[0];
                break;
            default:
                for (auto i = 0u; i < sizeof(T); i++) {
                    dstPtr[i] = srcPtr[sizeof(T) - i - 1];
                }
                break;
            }
            _sink->write(&reverse, sizeof(reverse));
        }
    }
 
    template<typename T>
    inline WriteStream& operator<<(T value) {
        write(value);
        return *this;
    }
 
    void writeString(const char* str) {
        checkArg(str);
        _sink->write(str, strlen(str));
    }
 
    WriteStream& operator<<(const char* value) {
        writeString(value);
        return *this;
    }
 
    void writeString(const std::string& str) {
        _sink->write(str.c_str(), str.length());
    }
 
    WriteStream& operator<<(const std::string& value) {
        writeString(value);
        return *this;
    }
 
    void writeBytes(const void* data, uint64_t size) {
        _sink->write(data, size);
    }
 
private:
    std::shared_ptr<BinarySink> const _sharedSink;
    BinarySink* const _sink;
    const ByteOrder _byteOrder;
    const bool _isNativeByteOrder;
};
 
} // namespace CppMate
 
#endif // CPP_MATE_WRITE_STREAM_HPP