device3.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_UHD_DEVICE3_HPP
#define INCLUDED_UHD_DEVICE3_HPP

#include <uhd/device.hpp>
#include <uhd/rfnoc/block_ctrl_base.hpp>
#include <uhd/rfnoc/graph.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/units/detail/utility.hpp>
#include <vector>

namespace uhd {

class UHD_API device3 : public uhd::device
{
public:
    typedef boost::shared_ptr<device3> sptr;

    static sptr make(const device_addr_t& hint, const size_t which = 0);

    virtual rfnoc::graph::sptr create_graph(const std::string& name = "") = 0;

    void clear();

    bool has_block(const rfnoc::block_id_t& block_id) const;

    template <typename T> bool has_block(const rfnoc::block_id_t& block_id) const
    {
        if (has_block(block_id)) {
            return bool(boost::dynamic_pointer_cast<T>(get_block_ctrl(block_id)));
        } else {
            return false;
        }
    }

    rfnoc::block_ctrl_base::sptr get_block_ctrl(const rfnoc::block_id_t& block_id) const;

    template <typename T>
    boost::shared_ptr<T> get_block_ctrl(const rfnoc::block_id_t& block_id) const
    {
        boost::shared_ptr<T> blk =
            boost::dynamic_pointer_cast<T>(get_block_ctrl(block_id));
        if (blk) {
            return blk;
        } else {
            throw uhd::lookup_error(str(
                boost::format("This device does not have a block of type %s with ID: %s")
                % boost::units::detail::demangle(typeid(T).name())
                % block_id.to_string()));
        }
    }

    std::vector<rfnoc::block_id_t> find_blocks(const std::string& block_id_hint) const;

    template <typename T>
    std::vector<rfnoc::block_id_t> find_blocks(const std::string& block_id_hint) const
    {
        std::vector<rfnoc::block_id_t> all_block_ids = find_blocks(block_id_hint);
        std::vector<rfnoc::block_id_t> filt_block_ids;
        for (size_t i = 0; i < all_block_ids.size(); i++) {
            if (has_block<T>(all_block_ids[i])) {
                filt_block_ids.push_back(all_block_ids[i]);
            }
        }
        return filt_block_ids;
    }

protected:
    //  It is the responsibility of the deriving class to make
    //  sure this gets correctly populated.
    std::vector<rfnoc::block_ctrl_base::sptr> _rfnoc_block_ctrl;
    boost::mutex _block_ctrl_mutex;
};

} // namespace uhd

#endif /* INCLUDED_UHD_DEVICE3_HPP */