block_id.hpp

Go to the documentation of this file.

// Copyright 2014 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_BLOCK_ID_HPP
#define INCLUDED_UHD_TYPES_BLOCK_ID_HPP

#include <uhd/config.hpp>
#include <boost/cstdint.hpp>
#include <boost/shared_ptr.hpp>
#include <iostream>
#include <string>

namespace uhd {
    struct fs_path;

    namespace rfnoc {

    class UHD_RFNOC_API block_id_t
    {
    public:
        block_id_t();
        block_id_t(const std::string &block_str);
        block_id_t(const size_t device_no, const std::string &block_name, const size_t block_ctr=0);

        std::string to_string() const;

        //
        // Note: This only applies to the block *name*, not the entire block ID.
        // Examples:
        // * is_valid_blockname("FFT") will return true.
        // * is_valid_blockname("FIR_Filter") will return false, because an underscore
        //   is not allowed in a block name.
        //
        // Internally, this matches the string with uhd::rfnoc::VALID_BLOCKNAME_REGEX.
        static bool is_valid_blockname(const std::string &block_name);

        //
        // Note: This does necessary require a complete complete ID. If this returns
        // true, then it is a valid input for block_id_t::match().
        //
        // Examples:
        // * is_valid_block_id("FFT") will return true.
        // * is_valid_block_id("0/Filter_1") will return true.
        // * is_valid_block_id("0/Filter_Foo") will return false.
        //
        // Internally, this matches the string with uhd::rfnoc::VALID_BLOCKID_REGEX.
        static bool is_valid_block_id(const std::string &block_id);

        //
        // A match is a less strict version of equality.
        // Less specific block IDs will match more specific ones,
        // e.g. "FFT" will match "0/FFT_1", "1/FFT_2", etc.
        // "FFT_1" will only match the former, etc.
        bool match(const std::string &block_str);

        // Getters

        std::string get() const { return to_string(); };

        std::string get_local() const;

        uhd::fs_path get_tree_root() const;

        size_t get_device_no() const { return _device_no; };

        size_t get_block_count() const { return _block_ctr; };

        std::string get_block_name() const { return _block_name; };

        // Setters

        //  Returns true if successful (i.e. if string valid)
        bool set(const std::string &new_name);

        //  and set_block_count() one after another, only if \p block_name is invalid, stops
        //  and returns false before chaning anything
        bool set(const size_t device_no, const std::string &block_name, const size_t block_ctr=0);

        void set_device_no(size_t device_no) { _device_no = device_no; };

        bool set_block_name(const std::string &block_name);

        void set_block_count(size_t count) { _block_ctr = count; };

        // Overloaded operators

        block_id_t operator = (const std::string &new_name) {
            set(new_name);
            return *this;
        }

        bool operator == (const block_id_t &block_id) const {
            return (_device_no == block_id.get_device_no())
                and (_block_name == block_id.get_block_name())
                and (_block_ctr == block_id.get_block_count());
        }

        bool operator != (const block_id_t &block_id) const {
            return not (*this == block_id);
        }

        bool operator < (const block_id_t &block_id) const {
            return (
                _device_no < block_id.get_device_no()
                or (_device_no == block_id.get_device_no() and _block_name < block_id.get_block_name())
                or (_device_no == block_id.get_device_no() and _block_name == block_id.get_block_name() and _block_ctr < block_id.get_block_count())
           );
        }

        bool operator > (const block_id_t &block_id) const {
            return (
                _device_no > block_id.get_device_no()
                or (_device_no == block_id.get_device_no() and _block_name > block_id.get_block_name())
                or (_device_no == block_id.get_device_no() and _block_name == block_id.get_block_name() and _block_ctr > block_id.get_block_count())
           );
        }

        bool operator == (const std::string &block_id_str) const {
            return get() == block_id_str;
        }

        bool operator == (const char *block_id_str) const {
            std::string comp = std::string(block_id_str);
            return *this == comp;
        }

        operator std::string() const {
            return to_string();
        }

        block_id_t operator++() {
            _block_ctr++;
            return *this;
        }

        block_id_t operator++(int) {
            _block_ctr++;
            return *this;
        }

    private:
        size_t _device_no;
        std::string _block_name;
        size_t _block_ctr;
    };

    inline std::ostream& operator<< (std::ostream& out, block_id_t block_id) {
        out << block_id.to_string();
        return out;
    }

}} //namespace uhd::rfnoc

#endif /* INCLUDED_UHD_TYPES_BLOCK_ID_HPP */
// vim: sw=4 et: