16#include <unordered_map> 
   17#include <unordered_set> 
   18#include <boost/graph/adjacency_list.hpp> 
   43        std::unordered_map<res_source_info, std::vector<res_source_info>>;
 
  127    template <
typename prop_data_t>
 
  129        const std::string& 
id, 
const prop_data_t& val, 
const size_t instance = 0);
 
  182    template <
typename prop_data_t>
 
  184        const std::string& 
id, 
const size_t instance = 0) ;
 
  342    template <
typename prop_data_t>
 
  344        const std::string& 
id, 
const prop_data_t& val, 
const res_source_info& src_info);
 
  357    template <
typename prop_data_t>
 
  461        const std::vector<size_t>& connected_outputs);
 
  498    template <
typename PredicateType>
 
  499    prop_ptrs_t filter_props(PredicateType&& predicate)
 
  502        for (
const auto& type_prop_pair : _props) {
 
  503            for (
const auto& prop : type_prop_pair.second) {
 
  504                if (predicate(prop)) {
 
  505                    filtered_props.push_back(prop);
 
  510        return filtered_props;
 
  520    property_base_t* inject_edge_property(
 
  521        property_base_t* blueprint, res_source_info new_src_info);
 
  561    void resolve_props();
 
  577    void set_resolve_all_callback(resolve_callback_t&& resolver)
 
  579        _resolve_all_cb = resolver;
 
  584    void clear_resolve_all_callback()
 
  586        _resolve_all_cb = _default_resolve_all_cb;
 
  592    void set_graph_mutex_callback(graph_mutex_callback_t&& mutex)
 
  594        _graph_mutex_cb = mutex;
 
  600    void clear_graph_mutex_callback()
 
  602        _graph_mutex_cb = NULL;
 
  639    void forward_edge_property(
 
  640        property_base_t* incoming_prop, 
const size_t incoming_port);
 
  648    void set_post_action_callback(action_handler_t&& post_handler)
 
  650        _post_action_cb = std::move(post_handler);
 
  661    void receive_action(
const res_source_info& src_info, action_info::sptr action);
 
  667    bool _has_port(
const res_source_info& port_info) 
const;
 
  670    template <
typename prop_data_t>
 
  672        const std::string& 
id, 
const prop_data_t& val, 
const res_source_info& src_info);
 
  678    mutable std::mutex _prop_mutex;
 
  681    std::unordered_map<res_source_info::source_t,
 
  682        std::vector<property_base_t*>,
 
  687    std::unordered_map<property_base_t*, resolve_callback_t> _clean_cb_registry;
 
  689    using property_resolver_t = std::tuple<prop_ptrs_t, prop_ptrs_t, resolver_fn_t>;
 
  691    std::vector<property_resolver_t> _prop_resolvers;
 
  696    graph_mutex_callback_t _graph_mutex_cb;
 
  700    resolve_callback_t _resolve_all_cb;
 
  704    const resolve_callback_t _default_resolve_all_cb = [
this]() {
 
  716    std::unordered_set<std::unique_ptr<property_base_t>> _dynamic_props;
 
  721    std::unordered_map<std::string, forwarding_policy_t> _prop_fwd_policies{
 
  722        {
"", forwarding_policy_t::ONE_TO_ONE}};
 
  725    forwarding_map_t _prop_fwd_map;
 
  730    mutable std::mutex _action_mutex;
 
  733    std::unordered_map<std::string, action_handler_t> _action_handlers;
 
  736    std::unordered_map<std::string, forwarding_policy_t> _action_fwd_policies{
 
  737        {
"", forwarding_policy_t::ONE_TO_ONE}};
 
  742    action_handler_t _post_action_cb = [](
const res_source_info&,
 
  743                                           action_info::sptr) {  };
 
  746    forwarding_map_t _action_fwd_map;
 
  751    std::vector<uhd::time_spec_t> _cmd_timespecs;
 
 
Definition device_addr.hpp:39
Definition dirtifier.hpp:19
virtual std::string get_unique_id() const
Return a unique identifier string for this node. In every RFNoC graph,.
std::vector< std::string > get_property_ids() const
const prop_data_t & get_property(const std::string &id, const size_t instance=0)
Definition node.ipp:53
void register_property(property_base_t *prop, resolve_callback_t &&clean_callback=nullptr)
void set_action_forwarding_policy(forwarding_policy_t policy, const std::string &action_key="")
void set_prop_forwarding_map(const forwarding_map_t &map)
std::vector< property_base_t * > prop_ptrs_t
Definition node.hpp:220
std::function< void(void)> resolver_fn_t
Definition node.hpp:37
std::function< void(void)> resolve_callback_t
Definition node.hpp:38
void register_action_handler(const std::string &id, action_handler_t &&handler)
virtual void set_command_time(uhd::time_spec_t time, const size_t instance)
void post_action(const res_source_info &edge_info, action_info::sptr action)
std::function< void(const res_source_info &, action_info::sptr)> action_handler_t
Definition node.hpp:40
void set_property(const std::string &id, const prop_data_t &val, const size_t instance=0)
Definition node.ipp:45
std::unordered_map< res_source_info, std::vector< res_source_info > > forwarding_map_t
Definition node.hpp:42
virtual bool check_topology(const std::vector< size_t > &connected_inputs, const std::vector< size_t > &connected_outputs)
virtual ~node_t()
Definition node.hpp:71
void set_action_forwarding_map(const forwarding_map_t &map)
virtual size_t get_num_output_ports() const =0
void set_properties(const uhd::device_addr_t &props, const size_t instance=0)
forwarding_policy_t
Types of property/action forwarding for those not defined by the block itself.
Definition node.hpp:46
@ ONE_TO_ONE
Forward the property/action to the opposite port with the same index.
Definition node.hpp:49
@ ONE_TO_ALL
Forward the property to all ports.
Definition node.hpp:57
@ USE_MAP
Forward the property based on a client-provided map.
Definition node.hpp:61
@ ONE_TO_ALL_OUT
Forward the property to all output ports.
Definition node.hpp:55
@ ONE_TO_ALL_IN
Forward the property to all input ports.
Definition node.hpp:53
@ DROP
Property propagation ends here.
Definition node.hpp:59
@ ONE_TO_FAN
Fan-out forwarding: Forward to all opposite ports.
Definition node.hpp:51
std::function< std::recursive_mutex &(void)> graph_mutex_callback_t
Definition node.hpp:39
virtual size_t get_num_input_ports() const =0
void add_property_resolver(prop_ptrs_t &&inputs, prop_ptrs_t &&outputs, resolver_fn_t &&resolver_fn)
friend class node_accessor_t
Definition node.hpp:477
virtual void clear_command_time(const size_t instance)
static dirtifier_t ALWAYS_DIRTY
A dirtifyer object, useful for properties that always need updating.
Definition node.hpp:474
virtual uhd::time_spec_t get_command_time(const size_t instance) const
static const size_t ANY_PORT
Definition node.hpp:64
void set_prop_forwarding_policy(forwarding_policy_t policy, const std::string &prop_id="")
Definition property.hpp:26
access_t
Definition property.hpp:28
Definition time_spec.hpp:31
std::unique_ptr< scope_exit > uptr
Definition scope_exit.hpp:26
#define UHD_API
Definition config.h:87
Definition actions.hpp:24
Definition build_info.hpp:12
std::shared_ptr< action_info > sptr
Definition actions.hpp:38
Definition res_source_info.hpp:18