property_tree.hpp

Go to the documentation of this file.

//
// Copyright 2011,2014-2016 Ettus Research
// Copyright 2018 Ettus Research, a National Instruments Company
//
// SPDX-License-Identifier: GPL-3.0-or-later
//

#ifndef INCLUDED_UHD_PROPERTY_TREE_HPP
#define INCLUDED_UHD_PROPERTY_TREE_HPP

#include <uhd/config.hpp>
#include <boost/utility.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/function.hpp>
#include <vector>

namespace uhd{

template <typename T> class property : boost::noncopyable{
public:
    typedef boost::function<void(const T &)> subscriber_type;
    typedef boost::function<T(void)> publisher_type;
    typedef boost::function<T(const T &)> coercer_type;

    virtual ~property<T>(void) = 0;

    virtual property<T> &set_coercer(const coercer_type &coercer) = 0;

    virtual property<T> &set_publisher(const publisher_type &publisher) = 0;

    virtual property<T> &add_desired_subscriber(const subscriber_type &subscriber) = 0;

    virtual property<T> &add_coerced_subscriber(const subscriber_type &subscriber) = 0;

    virtual property<T> &update(void) = 0;

    virtual property<T> &set(const T &value) = 0;

    virtual property<T> &set_coerced(const T &value) = 0;

    virtual const T get(void) const = 0;

    virtual const T get_desired(void) const = 0;

    virtual bool empty(void) const = 0;
};

template <typename T>
property<T>::~property(void){
    /* NOP */
}

struct fs_path : std::string{
    UHD_API fs_path(void);
    UHD_API fs_path(const char *);
    UHD_API fs_path(const std::string &);
    UHD_API std::string leaf(void) const;
    UHD_API fs_path branch_path(void) const;
};

UHD_API fs_path operator/(const fs_path &, const fs_path &);
UHD_API fs_path operator/(const fs_path &, size_t);

class UHD_API property_tree : boost::noncopyable{
public:
    typedef boost::shared_ptr<property_tree> sptr;

    enum coerce_mode_t { AUTO_COERCE, MANUAL_COERCE };

    virtual ~property_tree(void) = 0;

    static sptr make(void);

    virtual sptr subtree(const fs_path &path) const = 0;

    virtual void remove(const fs_path &path) = 0;

    virtual bool exists(const fs_path &path) const = 0;

    virtual std::vector<std::string> list(const fs_path &path) const = 0;

    template <typename T> property<T> &create(
        const fs_path &path,
        coerce_mode_t coerce_mode = AUTO_COERCE);

    template <typename T> property<T> &access(const fs_path &path);

private:
    virtual void _create(const fs_path &path, const boost::shared_ptr<void> &prop) = 0;

    virtual boost::shared_ptr<void> &_access(const fs_path &path) const = 0;

};

} //namespace uhd

#include <uhd/property_tree.ipp>

#endif /* INCLUDED_UHD_PROPERTY_TREE_HPP */