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>

namespace Pothos {

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);

    size_t address;

    size_t length;

    DType dtype;

    size_t elements(void) const;

    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;

    pothos_explicit operator bool(void) const;

    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;

private:
    SharedBuffer _buffer;
    ManagedBuffer _managedBuffer;
};

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)
{
    return;
}

inline size_t Pothos::BufferChunk::elements(void) const
{
    return this->length/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
{
    //dont count the copy held by the managed buffer
    if (_managedBuffer)
    {
        assert(_buffer.useCount() >= 2);
        return _buffer.useCount() - 1;
    }
    return _buffer.useCount();
}