interface.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-3.0-or-later OR BSD-3-Clause
/***************************************************************************
 *   Copyright (C) 2019 by Robert Middleton                                *
 *   robert.middleton@rm5248.com                                           *
 *                                                                         *
 *   This file is part of the dbus-cxx library.                            *
 ***************************************************************************/
#include "enums.h"
#include "path.h"
#include <dbus-cxx/methodbase.h>
#include <dbus-cxx/signal.h>
#include <dbus-cxx/dbus-cxx-config.h>
#include <dbus-cxx/property.h>
#include <sigc++/sigc++.h>
#include <set>
#include <map>
#include <mutex>
#include <shared_mutex>
 
#ifndef DBUSCXX_INTERFACE_H
#define DBUSCXX_INTERFACE_H
 
namespace DBus {
class CallMessage;
class Connection;
class Object;
class SignalBase;
 
class Interface {
protected:
    Interface( const std::string& name );
 
public:
    typedef std::map<std::string, std::shared_ptr<MethodBase>> Methods;
 
    typedef std::set<std::shared_ptr<SignalBase>> Signals;
 
    static std::shared_ptr<Interface> create( const std::string& name = std::string() );
 
    virtual ~Interface();
 
    HandlerResult handle_call_message( std::shared_ptr<Connection> conn, std::shared_ptr<const CallMessage> message );
 
    HandlerResult handle_properties_message( std::shared_ptr<Connection> conn, std::shared_ptr<const CallMessage> message );
 
    const std::string& name() const;
 
    Path path() const;
 
    const Methods& methods() const;
 
    std::shared_ptr<MethodBase> method( const std::string& name ) const;
 
    template <typename T_type>
    std::shared_ptr<Method<T_type> >
    create_method( const std::string& name ) {
        std::shared_ptr< Method<T_type> > method;
        method = Method<T_type>::create( name );
        this->add_method( method );
        return method;
    }
 
    template <typename T_type>
    std::shared_ptr<Method<T_type> >
    create_method( const std::string& name, sigc::slot<T_type> slot ) {
        std::shared_ptr< Method<T_type> > method;
        method = Method<T_type>::create( name );
        method->set_method( slot );
        this->add_method( method );
        return method;
    }
 
    template <typename T_type>
    std::shared_ptr<Property<T_type>>
    create_property( const std::string& name,
                     PropertyAccess access_type = PropertyAccess::ReadWrite,
                     PropertyUpdateType update_type = PropertyUpdateType::Updates ) {
        std::shared_ptr<Property<T_type>> prop = Property<T_type>::create( name, access_type, update_type );
        add_property( prop );
        return prop;
    }
 
    bool add_property( std::shared_ptr<PropertyBase> prop );
 
    bool has_property( const std::string& name ) const;
 
    bool add_method( std::shared_ptr<MethodBase> method );
 
    bool remove_method( const std::string& name );
 
    bool remove_method( std::shared_ptr<MethodBase> method );
 
    bool has_method( const std::string& name ) const;
 
    bool add_signal( std::shared_ptr<SignalBase> signal );
 
    bool remove_signal( std::shared_ptr<SignalBase> signal );
 
    bool remove_signal( const std::string& name );
 
    bool has_signal( std::shared_ptr<SignalBase> signal ) const;
 
    bool has_signal( const std::string& name ) const;
 
    template <class... T_type>
    std::shared_ptr<Signal<T_type...> >
    create_signal( const std::string& member ) {
        std::shared_ptr<DBus::Signal<T_type...> > sig;
        sig = DBus::Signal<T_type...>::create( path(), name(), member );
 
        if( this->add_signal( sig ) ) { return sig; }
 
        return std::shared_ptr<DBus::Signal<T_type...> >();
    }
 
    const Signals& signals();
 
    const std::set<std::shared_ptr<PropertyBase>>& properties();
 
    std::shared_ptr<SignalBase> signal( const std::string& signal_name );
 
    sigc::signal<void( std::shared_ptr<MethodBase> )> signal_method_added();
 
    sigc::signal<void( std::shared_ptr<MethodBase> )> signal_method_removed();
 
    std::string introspect( int space_depth = 0 ) const;
 
private:
    void set_path( const std::string& new_path );
    void property_updated( DBus::PropertyBase* prop );
    void set_connection( std::weak_ptr<Connection> conn );
 
private:
    class priv_data;
 
    DBUS_CXX_PROPAGATE_CONST( std::unique_ptr<priv_data> ) m_priv;
 
    friend class Object;
    friend class PropertyBase;
};
 
} /* namespace DBus */
 
#endif /* DBUS_CXX_INTERFACE_H */