pubsubmanager.h

/*
  Copyright (c) 2007-2008 by Jakob Schroeter <js@camaya.net>
  This file is part of the gloox library. http://camaya.net/gloox

  This software is distributed under a license. The full license
  agreement can be found in the file LICENSE in this distribution.
  This software may not be copied, modified, sold or distributed
  other than expressed in the named license agreement.

  This software is distributed without any warranty.
*/

#ifndef PUBSUBMANAGER_H__
#define PUBSUBMANAGER_H__

#include "pubsub.h"
#include "iqhandler.h"

#include <map>
#include <string>

namespace gloox
{

  class ClientBase;
  class DataForm;

  namespace PubSub
  {

    class EventHandler;
    class ResultHandler;

    class GLOOX_API Manager : public IqHandler
    {
      public:

        Manager( ClientBase* parent );

        virtual ~Manager() {}

        void subscribe( const JID& service, const std::string& node,
                        ResultHandler* handler, const JID& jid = JID(),
                        SubscriptionObject type = SubscriptionNodes,
                        int depth = 1 );

        void unsubscribe( const JID& service,
                          const std::string& node,
                          ResultHandler* handler,
                          const JID& jid = JID() );

        void getSubscriptions( const JID& service, ResultHandler* handler );

        void getAffiliations( const JID& service, ResultHandler* handler );

private:
        void subscriptionOptions( const JID& service,
                                  const JID& jid,
                                  const std::string& node,
                                  ResultHandler* handler,
                                  const DataForm* df );

public:
        void getSubscriptionOptions( const JID& service,
                                     const JID& jid,
                                     const std::string& node,
                                     ResultHandler* handler)
          { subscriptionOptions( service, jid, node, handler, 0 ); }

        void setSubscriptionOptions( const JID& service,
                                     const JID& jid,
                                     const std::string& node,
                                     const DataForm& df,
                                     ResultHandler* handler )
          { subscriptionOptions( service, jid, node, handler, &df ); }

        void getAffiliations( const JID& service,
                              const std::string& node,
                              ResultHandler* handler );

        void publishItem( const JID& service,
                          const std::string& node,
                          Tag* item,
                          ResultHandler* handler );

        void deleteItem( const JID& service,
                         const std::string& node,
                         const std::string& item,
                         ResultHandler* handler );

        void getItems( const JID& service,
                       const std::string& node,
                       ResultHandler* handler );

        void createNode( NodeType type, const JID& service,
                                        const std::string& node,
                                        ResultHandler* handler,
                                        const std::string& name = EmptyString,
                                        const std::string& parent = EmptyString,
                                        AccessModel access = AccessDefault,
                                        const StringMap* config = 0 );

        void createLeafNode( const JID& service,
                             const std::string& node,
                             ResultHandler* handler,
                             const std::string& name,
                             const std::string& parent = EmptyString,
                             AccessModel access = AccessDefault,
                             const StringMap* config = 0 )
          { createNode( NodeLeaf, service, node, handler, name, parent, access, config ); }

        void createCollectionNode( const JID& service,
                                   const std::string& node,
                                   ResultHandler* handler,
                                   const std::string& name,
                                   const std::string& parent = EmptyString,
                                   AccessModel access = AccessDefault,
                                   const StringMap* config = 0 )
          { createNode( NodeCollection, service, node, handler, name, parent, access, config ); }

        void deleteNode( const JID& service,
                         const std::string& node,
                         ResultHandler* handler );

/*
        void associateNode( const JID& service,
                            const std::string& node,
                            const std::string& collection );

        void disassociateNode( const JID& service,
                               const std::string& node,
                               const std::string& collection );
*/
        void getDefaultNodeConfig( const JID& service,
                                   NodeType type,
                                   ResultHandler* handler );

        void purgeNode( const JID& service,
                        const std::string& node,
                        ResultHandler* handler );

        void getSubscribers( const JID& service,
                             const std::string& node,
                             ResultHandler* handler )
          { subscriberList( service, node, 0, handler ); }

        void setSubscribers( const JID& service,
                             const std::string& node,
                             const SubscriberList& list,
                             ResultHandler* handler )
          { subscriberList( service, node, &list, handler ); }

        void getAffiliates( const JID& service,
                            const std::string& node,
                            ResultHandler* handler )
          { affiliateList( service, node, 0, handler ); }

        void setAffiliates( const JID& service,
                            const std::string& node,
                            const AffiliateList& list,
                            ResultHandler* handler )
          { affiliateList( service, node, &list, handler ); }

        void getNodeConfig( const JID& service,
                            const std::string& node,
                            ResultHandler* handler )
          { nodeConfig( service, node, 0, handler ); }

        void setNodeConfig( const JID& service,
                            const std::string& node,
                            const DataForm& config,
                            ResultHandler* handler  )
          { nodeConfig( service, node, &config, handler ); }

        void registerEventHandler( EventHandler* handler )
          { m_eventHandlerList.push_back( handler ); }

        void removeEventHandler( EventHandler* handler )
          { m_eventHandlerList.remove( handler ); }

        // reimplemented from DiscoHandler
        void handleDiscoInfoResult( IQ* iq, int context );
        void handleDiscoItemsResult( IQ* iq, int context );
        void handleDiscoError( IQ* iq, int context );
        bool handleDiscoSet( IQ* ) { return 0; }

        // reimplemented from IqHandler.
        virtual bool handleIq( const IQ& iq ) { (void)iq; return false; }

        // reimplemented from IqHandler.
        virtual void handleIqID( const IQ& iq, int context );

      private:

        void nodeConfig( const JID& service, const std::string& node,
                         const DataForm* config, ResultHandler* handler );

        void subscriberList( const JID& service,
                             const std::string& node,
                             const SubscriberList* config,
                             ResultHandler* handler );

        void affiliateList( const JID& service,
                            const std::string& node,
                            const AffiliateList* config,
                            ResultHandler* handler );

        typedef std::pair< std::string, std::string > TrackedItem;
        typedef std::map < std::string, TrackedItem > ItemOperationTrackMap;
        typedef std::map < std::string, std::string > NodeOperationTrackMap;

        typedef std::map < std::string, ResultHandler* > ResultHandlerTrackMap;
        typedef std::list< EventHandler* > EventHandlerList;

        ClientBase* m_parent;

        ItemOperationTrackMap  m_iopTrackMap;
        NodeOperationTrackMap  m_nopTrackMap;

        ResultHandlerTrackMap  m_resultHandlerTrackMap;
        EventHandlerList       m_eventHandlerList;
    };

  }

}

#endif // PUBSUBMANAGER_H__

---