object.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-3.0-or-later OR BSD-3-Clause
/***************************************************************************
 *   Copyright (C) 2009,2010 by Rick L. Vinyard, Jr.                       *
 *   rvinyard@cs.nmsu.edu                                                  *
 *   Copyright (C) 2019 by Robert Middleton                                *
 *   robert.middleton@rm5248.com                                           *
 *                                                                         *
 *   This file is part of the dbus-cxx library.                            *
 ***************************************************************************/
#include <dbus-cxx/signal.h>
#include <dbus-cxx/interface.h>
#include <dbus-cxx/dbus-cxx-config.h>
#include <dbus-cxx/property.h>
#include <map>
#include <memory>
#include <mutex>
#include <shared_mutex>
#include <thread>
#include <string>
#include "enums.h"
#include <sigc++/sigc++.h>
 
#ifndef DBUSCXXOBJECT_H
#define DBUSCXXOBJECT_H
 
namespace DBus {
class Connection;
class Interface;
class Message;
template <typename T_type> class Method;
 
class Object {
protected:
 
    Object( const std::string& path );
 
public:
    typedef std::map<std::string, std::shared_ptr<Interface> > Interfaces;
 
    typedef std::map<std::string, std::shared_ptr<Object>> Children;
 
    static std::shared_ptr<Object> create( const std::string& path = std::string() );
 
    virtual ~Object();
 
    const Path& path() const;
 
    std::weak_ptr<Connection> connection() const;
 
    bool unregister();
 
    sigc::signal<void( std::shared_ptr<Connection> ) >& signal_registered();
 
    sigc::signal<void( std::shared_ptr<Connection> ) >& signal_unregistered();
 
    void set_connection( std::shared_ptr<Connection> conn );
 
    const Interfaces& interfaces() const;
 
    std::shared_ptr<Interface> interface_by_name( const std::string& name ) const;
 
    bool add_interface( std::shared_ptr<Interface> interface_by_name );
 
    std::shared_ptr<Interface> create_interface( const std::string& name );
 
    template <typename T_type>
    std::shared_ptr<Method<T_type> >
    create_method( const std::string& method_name, sigc::slot<T_type> slot ) {
        if( !default_interface() ) {
            this->create_interface( "" );
            this->set_default_interface( "" );
        }
 
        // TODO throw an error if the default interface still doesn't exist
 
        std::shared_ptr< Method<T_type> > method;
        method = default_interface()->create_method<T_type>( method_name );
        method->set_method( slot );
        return method;
    }
 
    template <typename T_type>
    std::shared_ptr<Method<T_type> >
    create_method( const std::string& interface_name, const std::string& method_name, sigc::slot<T_type> slot ) {
        std::shared_ptr<Interface> interface_ptr;
        interface_ptr = this->interface_by_name( interface_name );
 
        if( !interface_ptr ) { interface_ptr = this->create_interface( interface_name ); }
 
        // TODO throw an error if the interface still doesn't exist
 
        std::shared_ptr< Method<T_type> > method;
        method = interface_ptr->create_method<T_type>( method_name );
        method->set_method( slot );
        return method;
    }
 
    template <typename T_type>
    std::shared_ptr<Property<T_type>>
    create_property( const std::string& interface_name,
                     const std::string& property_name,
                     PropertyAccess access_type = PropertyAccess::ReadWrite,
                     PropertyUpdateType update_type = PropertyUpdateType::Updates ){
        std::shared_ptr<Interface> interface_ptr;
        interface_ptr = this->interface_by_name( interface_name );
 
        if( !interface_ptr ) { interface_ptr = this->create_interface( interface_name ); }
 
        return interface_ptr->create_property<T_type>( property_name, access_type, update_type );
    }
 
    void remove_interface( const std::string& name );
 
    bool has_interface( const std::string& name );
 
    std::shared_ptr<Interface> default_interface() const;
 
    bool set_default_interface( const std::string& new_default_name );
 
    bool set_default_interface( std::shared_ptr<Interface> interface_by_name );
 
    void remove_default_interface();
 
    template <class... T_type>
    std::shared_ptr<Signal<T_type...> >
    create_signal( const std::string& name ) {
        std::shared_ptr<DBus::Signal<T_type...> > sig;
        std::shared_ptr<Interface> iface = this->default_interface();
 
        if( !iface ) { iface = this->create_interface( "" ); }
 
        sig = iface->create_signal<T_type...>( name );
        return sig;
    }
 
    template <class... T_type>
    std::shared_ptr<Signal<T_type...> >
    create_signal( const std::string& iface, const std::string& name ) {
        std::shared_ptr<DBus::Signal<T_type...> > sig;
 
        if( !has_interface( iface ) ) { this->create_interface( iface ); }
 
        sig = this->interface_by_name( iface )->create_signal<T_type...>( name );
        return sig;
    }
 
    const Children& children() const;
 
    std::shared_ptr<Object> child( const std::string& name ) const;
 
    bool add_child( const std::string& name, std::shared_ptr<Object> child, bool force = false );
 
    bool remove_child( const std::string& name );
 
    bool has_child( const std::string& name ) const;
    bool has_child( std::shared_ptr<Object> child ) const;
 
    std::string introspect( int space_depth = 0 ) const;
 
    sigc::signal<void( std::shared_ptr<Interface> ) > signal_interface_added();
 
    sigc::signal<void( std::shared_ptr<Interface> ) > signal_interface_removed();
 
    sigc::signal<void( std::shared_ptr<Interface> /*old default*/, std::shared_ptr<Interface> /*new default*/ )> signal_default_interface_changed();
 
    HandlerResult handle_message( std::shared_ptr<const Message> msg );
 
    void set_handling_thread( std::thread::id thr );
    std::thread::id handling_thread();
 
    bool is_lightweight() const;
 
    static std::shared_ptr<Object> create_lightweight( const std::string& path = std::string() );
 
    bool has_objectmanager() const;
 
    void set_has_objectmanager( bool objectmanager );
 
private:
    void handle_objectmanager( ObjectManagerObjects* ret );
    std::map<std::string,std::map<std::string,DBus::Variant>> interfaces_and_properties();
    void child_interface_removed( std::shared_ptr<DBus::Interface> iface );
    void child_interface_added( std::shared_ptr<DBus::Interface> iface );
    void add_self_to_objectmanager( DBus::Object* obj_manager );
 
private:
    class priv_data;
 
    DBUS_CXX_PROPAGATE_CONST( std::unique_ptr<priv_data> ) m_priv;
};
 
}
#endif