sid.hpp

Go to the documentation of this file.

//
// Copyright 2014-2016 Ettus Research LLC
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//

#ifndef INCLUDED_UHD_TYPES_SID_HPP
#define INCLUDED_UHD_TYPES_SID_HPP

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

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 = (sid_t &sid) {
            set_sid(sid.get_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 */
// vim: sw=4 et: