// -*- c++ -*-
/* Do not edit! -- generated file */

#ifndef DBUSCXXOBJECT_H
#define DBUSCXXOBJECT_H

#include <sigc++/sigc++.h>

#include <string>
#include <map>

#include <dbus-cxx/objectpathhandler.h>
#include <dbus-cxx/interface.h>

namespace DBus
{
  /**
   * @example calculator_server.cpp
   *
   * This example is one part of three example applications that demonstrate
   * client, server and watcher applications that use adapters and proxies
   * generated by dbus-cxx-xml2cpp from a modified dbus introspection XML
   * document.
   *
   * These three examples are:
   * <ul>
   * <li> @c calculator_server.cpp
   * <li> @c calculator_client.cpp
   * <li> @c calculator_watcher.cpp
   * </ul>
   *
   * This particular piece is the server that uses the generated Object
   * derived class to provide an adapter interface for the Calculator
   * class.
   *
   * Here is the calculator class, which by itself knows nothing of dbus:
   *
   * @include xml2cpp/calculator/calculator.h
   * @include xml2cpp/calculator/calculator.cpp
   *
   * The adapter is generated with this command:
   * @code
   * dbus-cxx-xml2cpp --xml calculator.xml --adapter -f
   * @endcode
   *
   * The modified introspection XML document is here:
   * @include xml2cpp/calculator/calculator.xml
   *
   * Here is the generated adapter:
   * @include xml2cpp/calculator/calculator_adapter.h
   *
   * And here is the server application:
   *
   */

  /**
   * @defgroup local Local Objects
   *
   * This group contains objects which are natively local and
   * provide interfaces such as methods and signals that can
   * be exported to dbus.
   */

  /**
   * @defgroup objects Objects
   */

  class Connection;

  /**
   * @ingroup local
   * @ingroup objects
   *
   * @todo TODO rethink whether it might be beneficial to have multiple connections for one object
   * 
   * @author Rick L Vinyard Jr <rvinyard@cs.nmsu.edu>
   */
  class Object: public ObjectPathHandler
  {
    protected:

      Object( const std::string& path, PrimaryFallback pf=PRIMARY );

    public:

      typedef DBusCxxPointer<Object> pointer;

      typedef std::multimap<std::string, Interface::pointer> Interfaces;

      typedef std::map<std::string, Object::pointer> Children;

      static pointer create( const std::string& path = std::string(), PrimaryFallback pf=PRIMARY );

      virtual ~Object();

      /** Extends base version to include registering signals */
      virtual bool register_with_connection(DBusCxxPointer<Connection> conn);

      const Interfaces& interfaces() const;

      /** Returns the first interface with the given name */
      Interface::pointer interface( const std::string& name ) const;

      /** Adds the interface to this object */
      bool add_interface( Interface::pointer interface );

      /**
       * Creates and adds the named interface to this object
       *
       * @return the newly created interface
       */
      Interface::pointer create_interface( const std::string& name );

      /**
      * Creates a method with the given signature and adds it to the default interface
      */
      template <class T_return>
      DBusCxxPointer<Method<T_return> > create_method( const std::string& method_name, sigc::slot0<T_return> slot )
      {
        if ( not m_default_interface )
        {
          this->create_interface("");
          this->set_default_interface("");
        }
        // TODO throw an error if the default interface still doesn't exist
     
        DBusCxxPointer< Method<T_return> > method;
        method = m_default_interface->create_method<T_return>(method_name);
        method->set_method( slot );
        return method;
      }
      
                /**
      * Creates a method with the given signature and adds it to the default interface
      */
      template <class T_return, class T_arg1>
      DBusCxxPointer<Method<T_return, T_arg1> > create_method( const std::string& method_name, sigc::slot1<T_return, T_arg1> slot )
      {
        if ( not m_default_interface )
        {
          this->create_interface("");
          this->set_default_interface("");
        }
        // TODO throw an error if the default interface still doesn't exist
     
        DBusCxxPointer< Method<T_return, T_arg1> > method;
        method = m_default_interface->create_method<T_return, T_arg1>(method_name);
        method->set_method( slot );
        return method;
      }
      
                /**
      * Creates a method with the given signature and adds it to the default interface
      */
      template <class T_return, class T_arg1,class T_arg2>
      DBusCxxPointer<Method<T_return, T_arg1,T_arg2> > create_method( const std::string& method_name, sigc::slot2<T_return, T_arg1,T_arg2> slot )
      {
        if ( not m_default_interface )
        {
          this->create_interface("");
          this->set_default_interface("");
        }
        // TODO throw an error if the default interface still doesn't exist
     
        DBusCxxPointer< Method<T_return, T_arg1,T_arg2> > method;
        method = m_default_interface->create_method<T_return, T_arg1,T_arg2>(method_name);
        method->set_method( slot );
        return method;
      }
      
                /**
      * Creates a method with the given signature and adds it to the default interface
      */
      template <class T_return, class T_arg1,class T_arg2,class T_arg3>
      DBusCxxPointer<Method<T_return, T_arg1,T_arg2,T_arg3> > create_method( const std::string& method_name, sigc::slot3<T_return, T_arg1,T_arg2,T_arg3> slot )
      {
        if ( not m_default_interface )
        {
          this->create_interface("");
          this->set_default_interface("");
        }
        // TODO throw an error if the default interface still doesn't exist
     
        DBusCxxPointer< Method<T_return, T_arg1,T_arg2,T_arg3> > method;
        method = m_default_interface->create_method<T_return, T_arg1,T_arg2,T_arg3>(method_name);
        method->set_method( slot );
        return method;
      }
      
                /**
      * Creates a method with the given signature and adds it to the default interface
      */
      template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
      DBusCxxPointer<Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4> > create_method( const std::string& method_name, sigc::slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4> slot )
      {
        if ( not m_default_interface )
        {
          this->create_interface("");
          this->set_default_interface("");
        }
        // TODO throw an error if the default interface still doesn't exist
     
        DBusCxxPointer< Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4> > method;
        method = m_default_interface->create_method<T_return, T_arg1,T_arg2,T_arg3,T_arg4>(method_name);
        method->set_method( slot );
        return method;
      }
      
                /**
      * Creates a method with the given signature and adds it to the default interface
      */
      template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
      DBusCxxPointer<Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> > create_method( const std::string& method_name, sigc::slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> slot )
      {
        if ( not m_default_interface )
        {
          this->create_interface("");
          this->set_default_interface("");
        }
        // TODO throw an error if the default interface still doesn't exist
     
        DBusCxxPointer< Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> > method;
        method = m_default_interface->create_method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(method_name);
        method->set_method( slot );
        return method;
      }
      
                /**
      * Creates a method with the given signature and adds it to the default interface
      */
      template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
      DBusCxxPointer<Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> > create_method( const std::string& method_name, sigc::slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> slot )
      {
        if ( not m_default_interface )
        {
          this->create_interface("");
          this->set_default_interface("");
        }
        // TODO throw an error if the default interface still doesn't exist
     
        DBusCxxPointer< Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> > method;
        method = m_default_interface->create_method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(method_name);
        method->set_method( slot );
        return method;
      }
      
                /**
      * Creates a method with the given signature and adds it to the default interface
      */
      template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
      DBusCxxPointer<Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> > create_method( const std::string& method_name, sigc::slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> slot )
      {
        if ( not m_default_interface )
        {
          this->create_interface("");
          this->set_default_interface("");
        }
        // TODO throw an error if the default interface still doesn't exist
     
        DBusCxxPointer< Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> > method;
        method = m_default_interface->create_method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(method_name);
        method->set_method( slot );
        return method;
      }
      
          
      template <class T_return>
      DBusCxxPointer<Method<T_return> > create_method( const std::string& interface_name, const std::string& method_name, sigc::slot0<T_return> slot )
      {
        Interface::pointer interface;
        interface = this->interface(interface_name);
        if ( not interface ) interface = this->create_interface(interface_name);
        // TODO throw an error if the interface still doesn't exist
     
        DBusCxxPointer< Method<T_return> > method;
        method = interface->create_method<T_return>(method_name);
        method->set_method( slot );
        return method;
      }
      
                template <class T_return, class T_arg1>
      DBusCxxPointer<Method<T_return, T_arg1> > create_method( const std::string& interface_name, const std::string& method_name, sigc::slot1<T_return, T_arg1> slot )
      {
        Interface::pointer interface;
        interface = this->interface(interface_name);
        if ( not interface ) interface = this->create_interface(interface_name);
        // TODO throw an error if the interface still doesn't exist
     
        DBusCxxPointer< Method<T_return, T_arg1> > method;
        method = interface->create_method<T_return, T_arg1>(method_name);
        method->set_method( slot );
        return method;
      }
      
                template <class T_return, class T_arg1,class T_arg2>
      DBusCxxPointer<Method<T_return, T_arg1,T_arg2> > create_method( const std::string& interface_name, const std::string& method_name, sigc::slot2<T_return, T_arg1,T_arg2> slot )
      {
        Interface::pointer interface;
        interface = this->interface(interface_name);
        if ( not interface ) interface = this->create_interface(interface_name);
        // TODO throw an error if the interface still doesn't exist
     
        DBusCxxPointer< Method<T_return, T_arg1,T_arg2> > method;
        method = interface->create_method<T_return, T_arg1,T_arg2>(method_name);
        method->set_method( slot );
        return method;
      }
      
                template <class T_return, class T_arg1,class T_arg2,class T_arg3>
      DBusCxxPointer<Method<T_return, T_arg1,T_arg2,T_arg3> > create_method( const std::string& interface_name, const std::string& method_name, sigc::slot3<T_return, T_arg1,T_arg2,T_arg3> slot )
      {
        Interface::pointer interface;
        interface = this->interface(interface_name);
        if ( not interface ) interface = this->create_interface(interface_name);
        // TODO throw an error if the interface still doesn't exist
     
        DBusCxxPointer< Method<T_return, T_arg1,T_arg2,T_arg3> > method;
        method = interface->create_method<T_return, T_arg1,T_arg2,T_arg3>(method_name);
        method->set_method( slot );
        return method;
      }
      
                template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
      DBusCxxPointer<Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4> > create_method( const std::string& interface_name, const std::string& method_name, sigc::slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4> slot )
      {
        Interface::pointer interface;
        interface = this->interface(interface_name);
        if ( not interface ) interface = this->create_interface(interface_name);
        // TODO throw an error if the interface still doesn't exist
     
        DBusCxxPointer< Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4> > method;
        method = interface->create_method<T_return, T_arg1,T_arg2,T_arg3,T_arg4>(method_name);
        method->set_method( slot );
        return method;
      }
      
                template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
      DBusCxxPointer<Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> > create_method( const std::string& interface_name, const std::string& method_name, sigc::slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> slot )
      {
        Interface::pointer interface;
        interface = this->interface(interface_name);
        if ( not interface ) interface = this->create_interface(interface_name);
        // TODO throw an error if the interface still doesn't exist
     
        DBusCxxPointer< Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> > method;
        method = interface->create_method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(method_name);
        method->set_method( slot );
        return method;
      }
      
                template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
      DBusCxxPointer<Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> > create_method( const std::string& interface_name, const std::string& method_name, sigc::slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> slot )
      {
        Interface::pointer interface;
        interface = this->interface(interface_name);
        if ( not interface ) interface = this->create_interface(interface_name);
        // TODO throw an error if the interface still doesn't exist
     
        DBusCxxPointer< Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> > method;
        method = interface->create_method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(method_name);
        method->set_method( slot );
        return method;
      }
      
                template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
      DBusCxxPointer<Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> > create_method( const std::string& interface_name, const std::string& method_name, sigc::slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> slot )
      {
        Interface::pointer interface;
        interface = this->interface(interface_name);
        if ( not interface ) interface = this->create_interface(interface_name);
        // TODO throw an error if the interface still doesn't exist
     
        DBusCxxPointer< Method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> > method;
        method = interface->create_method<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(method_name);
        method->set_method( slot );
        return method;
      }
      
          
      /** Removes the first interface with the given name */
      void remove_interface( const std::string& name );

      bool has_interface( const std::string& name );

      Interface::pointer default_interface() const;

      bool set_default_interface( const std::string& new_default_name );

      void remove_default_interface();

      template <class T_return, class T_arg1=nil, class T_arg2=nil, class T_arg3=nil, class T_arg4=nil, class T_arg5=nil, class T_arg6=nil, class T_arg7=nil>
          DBusCxxPointer<signal<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> > create_signal( const std::string& name ) {
            DBusCxxPointer<DBus::signal<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> > sig;
            Interface::pointer iface = this->default_interface();

            if (not iface) iface = this->create_interface("");

            sig = iface->create_signal<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(name);

            return sig;
          }

      template <class T_return, class T_arg1=nil, class T_arg2=nil, class T_arg3=nil, class T_arg4=nil, class T_arg5=nil, class T_arg6=nil, class T_arg7=nil>
      DBusCxxPointer<signal<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> > create_signal( const std::string& iface, const std::string& name ) {
        DBusCxxPointer<DBus::signal<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> > sig;

        if ( not has_interface(iface) ) this->create_interface(iface);
        
        sig = this->interface(iface)->create_signal<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(name);

        return sig;
      }

      const Children& children() const;

      Object::pointer child(const std::string& name) const;

      bool add_child(const std::string& name, Object::pointer child);

      bool remove_child(const std::string& name);

      bool has_child(const std::string& name) const;

      /** Returns a DBus XML description of this interface */
      std::string introspect(int space_depth=0) const;

      sigc::signal<void,Interface::pointer> signal_interface_added();

      sigc::signal<void,Interface::pointer> signal_interface_removed();

      sigc::signal<void,Interface::pointer/*old default*/,Interface::pointer/*new default*/> signal_default_interface_changed();

      virtual HandlerResult handle_message( DBusCxxPointer<Connection>, Message::const_pointer );

    protected:

      Children m_children;
      
      mutable pthread_rwlock_t m_interfaces_rwlock;

      pthread_mutex_t m_name_mutex;

      Interfaces m_interfaces;

      Interface::pointer m_default_interface;

      sigc::signal<void,Interface::pointer,Interface::pointer> m_signal_default_interface_changed;

      sigc::signal<void,Interface::pointer> m_signal_interface_added;

      sigc::signal<void,Interface::pointer> m_signal_interface_removed;

      typedef std::map<Interface::pointer,sigc::connection> InterfaceSignalNameConnections;

      InterfaceSignalNameConnections m_interface_signal_name_connections;

      void on_interface_name_changed(const std::string& oldname, const std::string& newname, Interface::pointer interface);

  };

}

#endif