rfnoc: Add properties, nodes, and accessors

Adds the following classes:
- uhd::rfnoc::node_t, the base class for RFNoC nodes
- uhd::rfnoc::node_accessor_t, a class to access private properties
- uhd::rfnoc::res_source_info, a struct that identifies where properties
  come from
- uhd::rfnoc::property_t, and property_base_t (its parent)
- uhd::rfnoc::prop_accessor_t, a class to access properties

Add always dirty property (dirtifier).

Also adds unit tests for properties.

2 files changed, 180 insertions, 0 deletions

diff --git a/host/lib/include/uhdlib/rfnoc/node_accessor.hpp b/host/lib/include/uhdlib/rfnoc/node_accessor.hpp
new file mode 100644
index 000000000..26e6a5607
--- /dev/null
+++ b/host/lib/include/uhdlib/rfnoc/node_accessor.hpp
@@ -0,0 +1,84 @@
+//
+// Copyright 2019 Ettus Research, a National Instruments Brand
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+//
+
+#ifndef INCLUDED_LIBUHD_NODE_ACCESSOR_HPP
+#define INCLUDED_LIBUHD_NODE_ACCESSOR_HPP
+
+#include <uhd/rfnoc/node.hpp>
+#include <functional>
+
+namespace uhd { namespace rfnoc {
+
+//! Special class which may access nodes
+//
+// For the sake of property resolution, we require access to certain private
+// members of nodes. Instead of giving the entire graph
+// access to everything, we create this accessor class which is not available
+// in the public API.
+class node_accessor_t
+{
+public:
+    using prop_ptrs_t = node_t::prop_ptrs_t;
+
+    /*! Initializes the properties of a node. See node_t::init_props() for
+     * details.
+     */
+    void init_props(node_t* node)
+    {
+        node->init_props();
+    }
+
+    /*! Does a local resolution of properties on \p node.
+     *
+     * See node_t::resolve_props for details.
+     */
+    void resolve_props(node_t* node)
+    {
+        node->resolve_props();
+    }
+
+    /*! Returns a filtered list of properties.
+     *
+     * The return list contains all properties that match a given predicate.
+     */
+    template <typename PredicateType>
+    node_t::prop_ptrs_t filter_props(node_t* node, PredicateType&& predicate)
+    {
+        return node->filter_props(std::forward<PredicateType>(predicate));
+    }
+
+    /*! Mark all properties on this node as clean
+     *
+     * See node_t::clean_props() for details.
+     */
+    void clean_props(node_t* node)
+    {
+        node->clean_props();
+    }
+
+    /*! Set a resolver callback for the node
+     *
+     * See node_t::set_resolve_all_callback() for details.
+     */
+    void set_resolve_all_callback(node_t* node, node_t::resolve_callback_t&& resolver)
+    {
+        node->set_resolve_all_callback(std::move(resolver));
+    }
+
+    /*! Forward an edge property to \p dst_node
+     *
+     * See node_t::forward_edge_property() for details.
+     */
+    void forward_edge_property(node_t* dst_node, property_base_t* incoming_prop)
+    {
+        dst_node->forward_edge_property(incoming_prop);
+    }
+};
+
+
+}} /* namespace uhd::rfnoc */
+
+#endif /* INCLUDED_LIBUHD_NODE_ACCESSOR_HPP */
diff --git a/host/lib/include/uhdlib/rfnoc/prop_accessor.hpp b/host/lib/include/uhdlib/rfnoc/prop_accessor.hpp
new file mode 100644
index 000000000..a62f54620
--- /dev/null
+++ b/host/lib/include/uhdlib/rfnoc/prop_accessor.hpp
@@ -0,0 +1,96 @@
+//
+// Copyright 2019 Ettus Research, a National Instruments Brand
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+//
+
+#ifndef INCLUDED_LIBUHD_PROP_ACCESSOR_HPP
+#define INCLUDED_LIBUHD_PROP_ACCESSOR_HPP
+
+#include <uhd/rfnoc/property.hpp>
+#include <uhd/utils/scope_exit.hpp>
+#include <functional>
+
+namespace uhd { namespace rfnoc {
+
+//! Special class which may access properties
+//
+// For the sake of property resolution, we require access to certain private
+// members of properties. Instead of giving the entire graph access to
+// everything, we create this accessor class which is not available
+// in the public API.
+class prop_accessor_t
+{
+public:
+    //! Clear the dirty bit on a property
+    void mark_clean(property_base_t& prop)
+    {
+        prop.mark_clean();
+    }
+
+    //! Set the access mode on a property
+    void set_access(property_base_t& prop, const property_base_t::access_t access)
+    {
+        prop._access_mode = access;
+    }
+
+    //! Set the access mode on a property
+    void set_access(property_base_t* prop, const property_base_t::access_t access)
+    {
+        prop->_access_mode = access;
+    }
+
+    //! RAII-Style access mode setter
+    //
+    // This will return an object which will set the access mode on a property
+    // only for the duration of its own lifetime. Use this in situations where
+    // you want to guarantee a certain read-write mode of a property, even when
+    // an exception is thrown.
+    //
+    // \param prop A reference to the property
+    // \param access The temporary access mode which will be set as long as the
+    //               scope_exit object is alive
+    // \param default_access The access mode which will be set once the
+    //                       scope_exit object will be destroyed
+    uhd::utils::scope_exit::uptr get_scoped_prop_access(property_base_t& prop,
+        property_base_t::access_t access,
+        property_base_t::access_t default_access = property_base_t::RO)
+    {
+        prop._access_mode = access;
+        return uhd::utils::scope_exit::make(
+            [&prop, default_access]() { prop._access_mode = default_access; });
+    }
+
+    /*! Forward the value from \p source to \p dst
+     *
+     * Note: This method will grant temporary write access to the destination
+     * property!
+     * If \p safe is set to true, it'll only allow RWLOCKED forwarding, i.e., 
+     * the new value cannot be different.
+     *
+     * \throws uhd::type_error if types mismatch
+     */
+    template <bool safe>
+    void forward(property_base_t* source, property_base_t* dst)
+    {
+        const auto w_access_type = (safe && dst->is_dirty()) ? property_base_t::RWLOCKED
+                                                             : property_base_t::RW;
+        auto read_access = get_scoped_prop_access(
+            *source, property_base_t::RO, source->get_access_mode());
+        auto write_access =
+            get_scoped_prop_access(*dst, w_access_type, dst->get_access_mode());
+        source->forward(dst);
+    }
+
+    /*! Returns true if \p source and \p dst are of the same type
+     */
+    bool are_compatible(property_base_t* source, property_base_t* dst)
+    {
+        return source->is_type_equal(dst);
+    }
+};
+
+
+}} /* namespace uhd::rfnoc */
+
+#endif /* INCLUDED_LIBUHD_PROP_ACCESSOR_HPP */