objectproxy.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                                                  *
 *                                                                         *
 *   This file is part of the dbus-cxx library.                            *
 ***************************************************************************/
#include <dbus-cxx/signalproxy.h>
#include <dbus-cxx/interfaceproxy.h>
#include <dbus-cxx/dbus-cxx-config.h>
#include <dbus-cxx/propertyproxy.h>
#include <map>
#include <memory>
#include <mutex>
#include <shared_mutex>
#include <string>
#include "path.h"
#include <sigc++/sigc++.h>
 
#ifndef DBUSCXX_OBJECTPROXY_H
#define DBUSCXX_OBJECTPROXY_H
 
namespace DBus {
 
class Connection;
class CallMessage;
class InterfaceProxy;
class MethodProxyBase;
class PendingCall;
class ReturnMessage;
template <typename signature> class MethodProxy;
class PeerInterfaceProxy;
class IntrospectableInterfaceProxy;
class PropertiesInterfaceProxy;
class ObjectManagerProxy;
 
class ObjectProxy {
protected:
 
    ObjectProxy( std::shared_ptr<Connection> conn, const std::string& destination, const std::string& path );
 
public:
    static std::shared_ptr<ObjectProxy> create( const std::string& path );
 
    static std::shared_ptr<ObjectProxy> create( const std::string& destination, const std::string& path );
 
    static std::shared_ptr<ObjectProxy> create( std::shared_ptr<Connection> conn, const std::string& path );
 
    static std::shared_ptr<ObjectProxy> create( std::shared_ptr<Connection> conn, const std::string& destination, const std::string& path );
 
    virtual ~ObjectProxy();
 
    std::weak_ptr<Connection> connection() const;
 
    void set_connection( std::shared_ptr<Connection> conn );
 
    const std::string& destination() const;
 
    void set_destination( const std::string& destination );
 
    const Path& path() const;
 
    void set_path( const std::string& path );
 
    typedef std::map<std::string, std::shared_ptr<InterfaceProxy>> Interfaces;
 
    const Interfaces& interfaces() const;
 
    std::shared_ptr<InterfaceProxy> interface_by_name( const std::string& name ) const;
 
    bool add_interface( std::shared_ptr<InterfaceProxy> interface_ptr );
 
    std::shared_ptr<InterfaceProxy> create_interface( const std::string& name );
 
    void remove_interface( const std::string& name );
 
    void remove_interface( std::shared_ptr<InterfaceProxy> interface_ptr );
 
    bool has_interface( const std::string& name ) const;
 
    bool has_interface( std::shared_ptr<InterfaceProxy> interface_ptr ) const;
 
    bool add_method( const std::string& interface_name, std::shared_ptr<MethodProxyBase> method );
 
    std::shared_ptr<CallMessage> create_call_message( const std::string& interface_name, const std::string& method_name ) const;
 
    std::shared_ptr<CallMessage> create_call_message( const std::string& method_name ) const;
 
    std::shared_ptr<const ReturnMessage> call( std::shared_ptr<const CallMessage>, int timeout_milliseconds = -1 ) const;
 
    std::shared_ptr<const ReturnMessage> call_notimeout( std::shared_ptr<const CallMessage> ) const;
 
    template <class T_type>
    std::shared_ptr<MethodProxy<T_type>>
    create_method( const std::string& interface_name, const std::string& method_name ) {
        std::shared_ptr<InterfaceProxy> interface_ptr = this->interface_by_name( interface_name );
 
        if( !interface_ptr ) { interface_ptr = this->create_interface( interface_name ); }
 
        return interface_ptr->create_method<T_type>( method_name );
    }
 
    template <class T_type>
    std::shared_ptr<SignalProxy<T_type> >
    create_signal( const std::string& interface_name, const std::string& sig_name ) {
        std::shared_ptr<InterfaceProxy> interface_ptr = this->interface_by_name( interface_name );
 
        if( !interface_ptr ) { interface_ptr = this->create_interface( interface_name ); }
 
        return interface_ptr->create_signal<T_type>( sig_name );
    }
 
    template <class T_type>
    std::shared_ptr<PropertyProxy<T_type>>
    create_property( const std::string& interface_name,
                     const std::string& property_name,
                     PropertyAccess access_type = PropertyAccess::ReadWrite,
                     PropertyUpdateType update = PropertyUpdateType::Updates ) {
        std::shared_ptr<InterfaceProxy> 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, update );
    }
 
    sigc::signal<void( std::shared_ptr<InterfaceProxy> )> signal_interface_added();
 
    sigc::signal<void( std::shared_ptr<InterfaceProxy> )> signal_interface_removed();
 
    std::shared_ptr<PeerInterfaceProxy> getPeerInterface();
 
    std::shared_ptr<IntrospectableInterfaceProxy> getIntrospectableInterface();
 
    std::shared_ptr<PropertiesInterfaceProxy> getPropertiesInterface();
 
    std::shared_ptr<ObjectManagerProxy> getObjectManagerInterface();
 
private:
    class priv_data;
 
    DBUS_CXX_PROPAGATE_CONST( std::unique_ptr<priv_data> ) m_priv;
};
 
}
 
#endif