Signal.h

Go to the documentation of this file.

/*
 * Copyright (C) 2018 Istituto Italiano di Tecnologia (IIT)
 * All rights reserved.
 *
 * This software may be modified and distributed under the terms of the
 * GNU Lesser General Public License v2.1 or any later version.
 */

#ifndef BLOCKFACTORY_CORE_SIGNAL_H
#define BLOCKFACTORY_CORE_SIGNAL_H

#include "BlockFactory/Core/Port.h"

#include <memory>

namespace blockfactory {
    namespace core {
        class Signal;
    } // namespace core
} // namespace blockfactory

class blockfactory::core::Signal
{
public:
    enum class DataFormat
    {
        NONCONTIGUOUS = 0,

        CONTIGUOUS = 1,

        CONTIGUOUS_ZEROCOPY = 2
    };

    Signal(const DataFormat& dataFormat = DataFormat::CONTIGUOUS_ZEROCOPY,
           const Port::DataType& dataType = Port::DataType::DOUBLE);
    ~Signal();

    Signal(const Signal& other);
    Signal& operator=(const Signal& other) = delete;

    Signal(Signal&& other);
    Signal& operator=(Signal&& other) = delete;

    bool initializeBufferFromContiguous(const void* buffer, size_t len);

    bool initializeBufferFromContiguousZeroCopy(const void* buffer, size_t len);

    bool initializeBufferFromNonContiguous(const void* const* bufferPtrs, size_t len);

    bool isValid() const;

    size_t getWidth() const;

    Port::DataType getPortDataType() const;

    DataFormat getDataFormat() const;

    template <typename T>
    T* getBuffer();

    template <typename T>
    const T* getBuffer() const;

    template <typename T>
    T get(const size_t i) const;

    bool set(const size_t index, const double data);

    template <typename T>
    bool setBuffer(const T* data, const size_t length);

#ifndef DOXYGEN_SHOULD_SKIP_THIS
private:
    size_t m_width = 0;
    const Port::DataType m_portDataType;
    const DataFormat m_dataFormat;
    void* m_bufferPtr = nullptr;

    template <typename T>
    T* getBufferImpl() const;

    void deleteBuffer();
    void allocateBuffer(const void* const bufferInput, void*& bufferOutput, size_t length);
#endif
};

// Explicit declaration of templates for all the supported types
// =============================================================

// TODO: for the time being, only DOUBLE is allowed. The toolbox has an almost complete support to
//       many other data types, but they need to be tested.

namespace blockfactory {
    namespace core {
        // DataType::DOUBLE
        extern template double* Signal::getBuffer<double>();
        extern template const double* Signal::getBuffer<double>() const;
        extern template double Signal::get<double>(const size_t i) const;
        extern template bool Signal::setBuffer<double>(const double* data, const size_t length);
    } // namespace core
} // namespace blockfactory

#endif // BLOCKFACTORY_CORE_SIGNAL_H