BinaryData.hpp

/*
 * Copyright (C) 2019-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_DATA_HPP
#define CPP_MATE_BINARY_DATA_HPP
 
#include <CppMate/Checkers.hpp>
 
#include <memory>
#include <vector>
#include <stdexcept>
 
#include <cstdint>
 
namespace CppMate {
 
class BinaryData
{
public:
    class Wrapper;
    class Empty;
    class Window;
 
    virtual ~BinaryData() = default;
 
    virtual const uint8_t* getData() const = 0;
 
    virtual uint64_t getSize() const = 0;
 
    bool hasData() const { return getData() && getSize(); }
 
    bool operator==(const BinaryData& other) const { return getData() == other.getData() && getSize() == other.getSize(); }
 
    bool operator!=(const BinaryData& other) const { return !(*this == other); }
};
 
class BinaryData::Wrapper: public BinaryData
{
public:
 
    Wrapper(const uint8_t* data, uint64_t size, bool validate = true):
        _data(data),
        _size(size)
    {
        checkArg(!validate || hasData());
    }
 
    Wrapper(const std::vector<uint8_t>& buffer):
        _data(&buffer[0]),
        _size(buffer.size())
    {
    }
 
    const uint8_t* getData() const override { return _data; }
    uint64_t getSize() const override { return _size; }
 
private:
    const uint8_t* _data;
    uint64_t _size;
};
 
class BinaryData::Empty: public BinaryData
{
public:
    const uint8_t* getData() const override { return nullptr; }
    uint64_t getSize() const override { return 0; }
 
    static const BinaryData& instance();
};
 
class BinaryData::Window: public BinaryData
{
public:
 
    Window(const BinaryData* data, uint64_t offset, uint64_t size = 0):
        _data(nullptr),
        _size(0)
    {
        using namespace CppMate;
        checkArg(data && data->hasData());
        checkArg(offset < data->getSize());
        _size = size > 0 ? size : data->getSize() - offset;
        checkArg(offset + _size <= data->getSize());
        _data = data->getData() + offset;
    }
 
    Window(std::unique_ptr<BinaryData> data, uint64_t offset, uint64_t size = 0):
        Window(data.get(), offset, size)
    {
        _sourceData = std::move(data);
    }
 
    Window(std::shared_ptr<BinaryData> data, uint64_t offset, uint64_t size = 0):
        Window(data.get(), offset, size)
    {
        _sourceData = std::move(data);
    }
 
    const uint8_t* getData() const override { return _data; }
    uint64_t getSize() const override { return _size; }
 
private:
    std::shared_ptr<BinaryData> _sourceData;
    const uint8_t* _data;
    uint64_t _size;
 
};
 
} // namespace CppMate
 
#endif // CPP_MATE_BINARY_DATA_HPP