sid.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_TYPES_SID_HPP
#define INCLUDED_UHD_TYPES_SID_HPP

#include <uhd/config.hpp>
#include <stdint.h>
#include <iostream>

namespace uhd {
class UHD_API sid_t
{
public:
    sid_t();
    sid_t(uint32_t sid);
    sid_t(uint8_t src_addr, uint8_t src_ep, uint8_t dst_addr, uint8_t dst_ep);
    sid_t(const std::string&);

    std::string to_pp_string() const;
    std::string to_pp_string_hex() const;

    bool is_set() const
    {
        return _set;
    };

    // Getters
    //
    inline uint32_t get() const
    {
        return get_sid();
    };
    inline uint32_t get_sid() const
    {
        return _set ? _sid : 0;
    };
    inline uint32_t get_src() const
    {
        return (_sid >> 16) & 0xFFFF;
    }
    inline uint32_t get_dst() const
    {
        return _sid & 0xFFFF;
    }
    inline uint32_t get_src_addr() const
    {
        return (get_src() >> 8) & 0xFF;
    }
    inline uint32_t get_src_endpoint() const
    {
        return get_src() & 0xFF;
    }
    inline uint32_t get_src_xbarport() const
    {
        return (get_src_endpoint() >> 4) & 0xF;
    }
    inline uint32_t get_src_blockport() const
    {
        return (get_src_endpoint()) & 0xF;
    }
    inline uint32_t get_dst_addr() const
    {
        return (get_dst() >> 8) & 0xFF;
    }
    inline uint32_t get_dst_endpoint() const
    {
        return get_dst() & 0xFF;
    }
    inline uint32_t get_dst_xbarport() const
    {
        return (get_dst_endpoint() >> 4) & 0xF;
    }
    inline uint32_t get_dst_blockport() const
    {
        return (get_dst_endpoint()) & 0xF;
    }

    // Setters

    void set(uint32_t new_sid)
    {
        set_sid(new_sid);
    };
    // Throws uhd::value_error if the string is not a valid SID
    // representation.
    void set_from_str(const std::string&);
    void set_sid(uint32_t new_sid);
    //  (the first 16 Bits)
    void set_src(uint32_t new_addr);
    //  (the last 16 Bits)
    void set_dst(uint32_t new_addr);
    void set_src_addr(uint32_t new_addr);
    void set_src_endpoint(uint32_t new_addr);
    void set_dst_addr(uint32_t new_addr);
    void set_dst_endpoint(uint32_t new_addr);
    void set_dst_xbarport(uint32_t new_xbarport);
    void set_dst_blockport(uint32_t new_blockport);

    // Manipulators

    sid_t reversed() const;

    void reverse();

    // Overloaded operators

    sid_t operator=(const uint32_t new_sid)
    {
        set_sid(new_sid);
        return *this;
    }

    sid_t operator=(const sid_t& sid)
    {
        set_sid(sid.get_sid());
        return *this;
    }

    sid_t operator=(const std::string& sid_str)
    {
        set_from_str(sid_str);
        return *this;
    }

    bool operator==(const sid_t& sid) const
    {
        return (not _set and not sid.is_set()) or (_sid == sid.get_sid());
    }

    bool operator==(uint32_t sid) const
    {
        return _set and _sid == sid;
    }

    bool operator==(const std::string& sid_str) const
    {
        sid_t rhs(sid_str);
        return *this == rhs;
    }

    // overloaded type casts are tricky, but for now we'll need them
    // for backward compatibility. consider them deprecated.

    //  Use is_set() to check if the return value is valid.
    operator uint32_t() const
    {
        return get();
    }

    operator bool() const
    {
        return _set;
    }

private:
    uint32_t _sid;
    bool _set;
};

inline std::ostream& operator<<(std::ostream& out, const sid_t& sid)
{
    std::ios_base::fmtflags ff = out.flags();
    if (ff & std::ios::hex) {
        out << sid.to_pp_string_hex();
    } else {
        out << sid.to_pp_string();
    }
    return out;
}

} // namespace uhd

#endif /* INCLUDED_UHD_TYPES_SID_HPP */