node_ctrl_base.hpp

Go to the documentation of this file.

//
// Copyright 2014-2016 Ettus Research LLC
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//

#ifndef INCLUDED_LIBUHD_NODE_CTRL_BASE_HPP
#define INCLUDED_LIBUHD_NODE_CTRL_BASE_HPP

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

namespace uhd {
    namespace rfnoc {

#define UHD_RFNOC_BLOCK_TRACE() UHD_LOGV(never) << "[" << unique_id() << "] "

class UHD_RFNOC_API node_ctrl_base;
class node_ctrl_base : boost::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; };

    // 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()
    {
        return _find_child_node<T, true>();
    }

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

    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) {};
    virtual ~node_ctrl_base() {};

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

    uhd::device_addr_t _args;

    // TODO make these private

    node_map_t _upstream_nodes;

    node_map_t _downstream_nodes;

    /***********************************************************************
     * 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();

    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 */
// vim: sw=4 et: