node_ctrl_base.hpp

Go to the documentation of this file.

//
// Copyright 2014-2016 Ettus Research LLC
// Copyright 2018 Ettus Research, a National Instruments Company
//
// SPDX-License-Identifier: GPL-3.0-or-later
//

#ifndef INCLUDED_LIBUHD_NODE_CTRL_BASE_HPP
#define INCLUDED_LIBUHD_NODE_CTRL_BASE_HPP

#include <uhd/rfnoc/constants.hpp>
#include <uhd/types/device_addr.hpp>
#include <uhd/utils/log.hpp>
#include <uhd/utils/noncopyable.hpp>
#include <stdint.h>
#include <boost/enable_shared_from_this.hpp>
#include <boost/function.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/utility.hpp>
#include <map>
#include <set>

namespace uhd { namespace rfnoc {

#define UHD_RFNOC_BLOCK_TRACE() UHD_LOGGER_TRACE("RFNOC")

class UHD_RFNOC_API node_ctrl_base;
class node_ctrl_base : uhd::noncopyable,
                       public boost::enable_shared_from_this<node_ctrl_base>
{
public:
    /***********************************************************************
     * Types
     **********************************************************************/
    typedef boost::shared_ptr<node_ctrl_base> sptr;
    typedef boost::weak_ptr<node_ctrl_base> wptr;
    typedef std::map<size_t, wptr> node_map_t;
    typedef std::pair<size_t, wptr> node_map_pair_t;

    /***********************************************************************
     * Node control
     **********************************************************************/
    virtual std::string unique_id() const;

    /***********************************************************************
     * Connections
     **********************************************************************/
    virtual void clear();

    node_map_t list_downstream_nodes()
    {
        return _downstream_nodes;
    };
    node_map_t list_upstream_nodes()
    {
        return _upstream_nodes;
    };

    void disconnect();

    void disconnect_output_port(const size_t output_port);

    void disconnect_input_port(const size_t input_port);

    // TODO we need a more atomic connect procedure, this is too error-prone.

    void set_downstream_port(const size_t this_port, const size_t remote_port);

    size_t get_downstream_port(const size_t this_port);

    void set_upstream_port(const size_t this_port, const size_t remote_port);

    size_t get_upstream_port(const size_t this_port);

    template <typename T>
    UHD_INLINE std::vector<boost::shared_ptr<T> > find_downstream_node(
        bool active_only = false)
    {
        return _find_child_node<T, true>(active_only);
    }

    template <typename T>
    UHD_INLINE std::vector<boost::shared_ptr<T> > find_upstream_node(
        bool active_only = false)
    {
        return _find_child_node<T, false>(active_only);
    }

    template <typename T, typename value_type>
    UHD_INLINE value_type find_downstream_unique_property(
        boost::function<value_type(boost::shared_ptr<T> node, size_t port)> get_property,
        value_type null_value,
        const std::set<boost::shared_ptr<T> >& exclude_nodes =
            std::set<boost::shared_ptr<T> >())
    {
        return _find_unique_property<T, value_type, true>(
            get_property, null_value, exclude_nodes);
    }

    template <typename T, typename value_type>
    UHD_INLINE value_type find_upstream_unique_property(
        boost::function<value_type(boost::shared_ptr<T> node, size_t port)> get_property,
        value_type null_value,
        const std::set<boost::shared_ptr<T> >& exclude_nodes =
            std::set<boost::shared_ptr<T> >())
    {
        return _find_unique_property<T, value_type, false>(
            get_property, null_value, exclude_nodes);
    }

protected:
    /***********************************************************************
     * Structors
     **********************************************************************/
    node_ctrl_base(void) : _num_input_ports(0), _num_output_ports(0) {}
    virtual ~node_ctrl_base()
    {
        disconnect();
    }

    /***********************************************************************
     * Protected members
     **********************************************************************/

    uhd::device_addr_t _args;

    // TODO make these private

    node_map_t _upstream_nodes;

    node_map_t _downstream_nodes;

    size_t _num_input_ports;

    size_t _num_output_ports;

    std::map<size_t, bool> _rx_streamer_active;

    std::map<size_t, bool> _tx_streamer_active;

    /***********************************************************************
     * Connections
     **********************************************************************/
    virtual void _register_downstream_node(
        node_ctrl_base::sptr downstream_node, size_t port);

    virtual void _register_upstream_node(node_ctrl_base::sptr upstream_node, size_t port);

private:
    template <typename T, bool downstream>
    std::vector<boost::shared_ptr<T> > _find_child_node(bool active_only = false);

    template <typename T, typename value_type, bool downstream>
    value_type _find_unique_property(
        boost::function<value_type(boost::shared_ptr<T>, size_t)> get_property,
        value_type NULL_VALUE,
        const std::set<boost::shared_ptr<T> >& exclude_nodes);

    std::map<size_t, size_t> _upstream_ports;

    std::map<size_t, size_t> _downstream_ports;

}; /* class node_ctrl_base */

}} /* namespace uhd::rfnoc */

#include <uhd/rfnoc/node_ctrl_base.ipp>

#endif /* INCLUDED_LIBUHD_NODE_CTRL_BASE_HPP */