BufferChunk.hpp

Go to the documentation of this file.

#pragma once
#include <Pothos/Config.hpp>
#include <Pothos/Framework/DType.hpp>
#include <Pothos/Framework/SharedBuffer.hpp>
#include <Pothos/Framework/ManagedBuffer.hpp>
#include <utility> //move

namespace Pothos {

class BufferAccumulator;

class POTHOS_API BufferChunk
{
public:

    static const BufferChunk &null(void);

    BufferChunk(void);

    BufferChunk(const size_t numBytes);

    BufferChunk(const DType &dtype, const size_t numElems);

    BufferChunk(const SharedBuffer &buffer);

    BufferChunk(const ManagedBuffer &buffer);

    BufferChunk(const BufferChunk &other);

    BufferChunk(BufferChunk &&other);

    ~BufferChunk(void);

    BufferChunk &operator=(const BufferChunk &other);

    BufferChunk &operator=(BufferChunk &&other);

    size_t address;

    size_t length;

    DType dtype;

    size_t elements(void) const;

    void setElements(const size_t numElements);

    const SharedBuffer &getBuffer(void) const;

    const ManagedBuffer &getManagedBuffer(void) const;

    size_t getAlias(void) const;

    size_t getEnd(void) const;

    template <typename ElementType>
    ElementType as(void) const;

    bool unique(void) const;

    size_t useCount(void) const;

    explicit operator bool(void) const;

    void clear(void);

    template<class Archive>
    void serialize(Archive & ar, const unsigned int version);

    void append(const BufferChunk &other);

    BufferChunk convert(const DType &dtype, const size_t numElems = 0) const;

    std::pair<BufferChunk, BufferChunk> convertComplex(const DType &dtype, const size_t numElems = 0) const;

    size_t convert(const BufferChunk &outBuff, const size_t numElems = 0) const;

    size_t convertComplex(const BufferChunk &outBuffRe, const BufferChunk &outBuffIm, const size_t numElems = 0) const;

private:
    friend BufferAccumulator;
    SharedBuffer _buffer;
    ManagedBuffer _managedBuffer;
    void _incrNextBuffers(void);
    void _decrNextBuffers(void);
    size_t _nextBuffers;
};

inline bool operator==(const BufferChunk &lhs, const BufferChunk &rhs);

} //namespace Pothos

#include <cassert>

inline bool Pothos::operator==(const Pothos::BufferChunk &lhs, const Pothos::BufferChunk &rhs)
{
    return lhs.address == rhs.address and lhs.length == rhs.length and lhs.getBuffer() == rhs.getBuffer();
}

inline Pothos::BufferChunk::BufferChunk(void):
    address(0),
    length(0),
    _nextBuffers(0)
{
    return;
}

inline Pothos::BufferChunk::BufferChunk(const size_t numBytes):
    address(0),
    length(numBytes),
    _buffer(Pothos::SharedBuffer::make(numBytes)),
    _nextBuffers(0)
{
    address = _buffer.getAddress();
}

inline Pothos::BufferChunk::BufferChunk(const DType &dtype, const size_t numElems):
    address(0),
    length(dtype.size()*numElems),
    dtype(dtype),
    _buffer(Pothos::SharedBuffer::make(length)),
    _nextBuffers(0)
{
    address = _buffer.getAddress();
}

inline Pothos::BufferChunk::BufferChunk(const SharedBuffer &buffer):
    address(buffer.getAddress()),
    length(buffer.getLength()),
    _buffer(buffer),
    _nextBuffers(0)
{
    return;
}

inline Pothos::BufferChunk::BufferChunk(const ManagedBuffer &buffer):
    address(buffer.getBuffer().getAddress()),
    length(buffer.getBuffer().getLength()),
    _buffer(buffer.getBuffer()),
    _managedBuffer(buffer),
    _nextBuffers(0)
{
    return;
}

inline Pothos::BufferChunk::BufferChunk(const BufferChunk &other):
    address(other.address),
    length(other.length),
    dtype(other.dtype),
    _buffer(other._buffer),
    _managedBuffer(other._managedBuffer)
{
    _incrNextBuffers();
}

inline Pothos::BufferChunk::BufferChunk(BufferChunk &&other):
    address(std::move(other.address)),
    length(std::move(other.length)),
    dtype(std::move(other.dtype)),
    _buffer(std::move(other._buffer)),
    _managedBuffer(std::move(other._managedBuffer)),
    _nextBuffers(std::move(other._nextBuffers))
{
    other._nextBuffers = 0;
}

inline Pothos::BufferChunk::~BufferChunk(void)
{
    _decrNextBuffers();
}

inline Pothos::BufferChunk &Pothos::BufferChunk::operator=(const BufferChunk &other)
{
    _decrNextBuffers();
    address = other.address;
    length = other.length;
    dtype = other.dtype;
    _buffer = other._buffer;
    _managedBuffer = other._managedBuffer;
    _incrNextBuffers();
    return *this;
}

inline Pothos::BufferChunk &Pothos::BufferChunk::operator=(BufferChunk &&other)
{
    _decrNextBuffers();
    address = std::move(other.address);
    length = std::move(other.length);
    dtype = std::move(other.dtype);
    _buffer = std::move(other._buffer);
    _managedBuffer = std::move(other._managedBuffer);
    _nextBuffers = std::move(other._nextBuffers);
    other._nextBuffers = 0;
    return *this;
}

inline void Pothos::BufferChunk::clear(void)
{
    _decrNextBuffers();
    address = 0;
    length = 0;
    dtype = Pothos::DType();
    _buffer = Pothos::SharedBuffer();
    _managedBuffer.reset();
    _nextBuffers = 0;
}

inline size_t Pothos::BufferChunk::elements(void) const
{
    return this->length/this->dtype.size();
}

inline void Pothos::BufferChunk::setElements(const size_t numElements)
{
    this->length = numElements*this->dtype.size();
}

inline const Pothos::SharedBuffer &Pothos::BufferChunk::getBuffer(void) const
{
    return _buffer;
}

inline const Pothos::ManagedBuffer &Pothos::BufferChunk::getManagedBuffer(void) const
{
    return _managedBuffer;
}

inline size_t Pothos::BufferChunk::getAlias(void) const
{
    if (_buffer.getAlias() == 0) return 0;
    if (address > _buffer.getAlias()) return address - _buffer.getLength();
    else return address + _buffer.getLength();
}

inline size_t Pothos::BufferChunk::getEnd(void) const
{
    return address + length;
}

template <typename ElementType>
ElementType Pothos::BufferChunk::as(void) const
{
    return reinterpret_cast<ElementType>(address);
}

inline Pothos::BufferChunk::operator bool(void) const
{
    return (address != 0) or bool(_buffer);
}

inline bool Pothos::BufferChunk::unique(void) const
{
    return this->useCount() == 1;
}

inline size_t Pothos::BufferChunk::useCount(void) const
{
    if (_managedBuffer) return _managedBuffer.useCount();
    return _buffer.useCount();
}