res_source_info.hpp

Go to the documentation of this file.

//
// Copyright 2019 Ettus Research, a National Instruments Brand
//
// SPDX-License-Identifier: GPL-3.0-or-later
//
 
#pragma once
 
#include <uhd/exception.hpp>
#include <cstdint>
#include <string>
 
namespace uhd { namespace rfnoc {
 
struct res_source_info
{
    enum source_t {
        USER, 
        INPUT_EDGE, 
        OUTPUT_EDGE, 
        FRAMEWORK 
    };
 
    // No default ctor: The source type must be specified
    res_source_info() = delete;
 
    res_source_info(source_t source_type, size_t instance_ = 0)
        : type(source_type), instance(instance_)
    {
        // nop
    }
 
    source_t type;
 
    size_t instance = 0;
 
    bool operator==(const res_source_info& rhs) const
    {
        return rhs.type == type && rhs.instance == instance;
    }
 
    bool operator!=(const res_source_info& rhs) const
    {
        return !(*this == rhs);
    }
 
    std::string to_string() const
    {
        const std::string type_repr = type == USER          ? "USER"
                                      : type == INPUT_EDGE  ? "INPUT_EDGE"
                                      : type == OUTPUT_EDGE ? "OUTPUT_EDGE"
                                                            : "INVALID";
        return type_repr + ":" + std::to_string(instance);
    }
 
    static source_t invert_edge(const source_t edge_direction)
    {
        UHD_ASSERT_THROW(edge_direction == INPUT_EDGE || edge_direction == OUTPUT_EDGE);
        return edge_direction == INPUT_EDGE ? OUTPUT_EDGE : INPUT_EDGE;
    }
};
 
}} /* namespace uhd::rfnoc */
 
namespace std {
template <>
struct hash<uhd::rfnoc::res_source_info>
{
    size_t operator()(const uhd::rfnoc::res_source_info& src_info) const
    {
        const size_t hash_type = std::hash<size_t>{}(src_info.type);
        const size_t hash_inst = std::hash<size_t>{}(src_info.instance);
        return hash_type ^ (hash_inst << 1);
    }
};
} // namespace std