property_tree.hpp

Go to the documentation of this file.

//
// Copyright 2011,2014-2016 Ettus Research
// Copyright 2018 Ettus Research, a National Instruments Company
// Copyright 2019 Ettus Research, a National Instruments Brand
//
// SPDX-License-Identifier: GPL-3.0-or-later
//
 
#pragma once
 
#include <uhd/config.hpp>
#include <uhd/utils/noncopyable.hpp>
#include <functional>
#include <memory>
#include <string>
#include <vector>
 
namespace uhd {
 
class UHD_API property_iface {
public:
    virtual ~property_iface() = default;
};
 
template <typename T>
class UHD_API_HEADER property : uhd::noncopyable, public property_iface
{
public:
    typedef std::function<void(const T&)> subscriber_type;
    typedef std::function<T(void)> publisher_type;
    typedef std::function<T(const T&)> coercer_type;
 
    virtual ~property(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 UHD_API_HEADER 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 : uhd::noncopyable
{
public:
    typedef std::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);
 
    template <typename T>
    std::shared_ptr<property<T>> pop(const fs_path& path);
 
private:
    virtual std::shared_ptr<property_iface> _pop(const fs_path& path) = 0;
 
    virtual void _create(const fs_path& path,
        const std::shared_ptr<property_iface>& prop) = 0;
 
    virtual std::shared_ptr<property_iface>& _access(const fs_path& path) const = 0;
};
 
} // namespace uhd
 
#include <uhd/property_tree.ipp>