rostermanager.h

/*
  Copyright (c) 2004-2009 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 ROSTERMANAGER_H__
#define ROSTERMANAGER_H__

#include "subscriptionhandler.h"
#include "privatexmlhandler.h"
#include "iqhandler.h"
#include "presencehandler.h"
#include "rosterlistener.h"

#include <map>
#include <string>
#include <list>

namespace gloox
{

  class ClientBase;
  class Stanza;
  class PrivateXML;
  class RosterItem;

   class GLOOX_API RosterManager : public IqHandler, public PresenceHandler, public SubscriptionHandler,
                                   public PrivateXMLHandler
  {
    public:
      RosterManager( ClientBase* parent );

      virtual ~RosterManager();

      void fill();

      Roster* roster();

      void subscribe( const JID& jid, const std::string& name = EmptyString,
                      const StringList& groups = StringList(),
                      const std::string& msg = EmptyString );

      void synchronize();

      void add( const JID& jid, const std::string& name, const StringList& groups );

      void unsubscribe( const JID& jid, const std::string& msg = EmptyString );

      void cancel( const JID& jid, const std::string& msg = EmptyString );

      void remove( const JID& jid );

      void ackSubscriptionRequest( const JID& to, bool ack );

      const std::string& delimiter() const { return m_delimiter; }

      void setDelimiter( const std::string& delimiter );

      RosterItem* getRosterItem( const JID& jid );

      void registerRosterListener( RosterListener* rl, bool syncSubscribeReq = true );

      void removeRosterListener();

      // reimplemented from IqHandler.
      virtual bool handleIq( const IQ& iq );

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

      // reimplemented from PresenceHandler.
      virtual void handlePresence( const Presence& presence );

      // reimplemented from SubscriptionHandler.
      virtual void handleSubscription( const Subscription& subscription );

      // reimplemented from PrivateXMLHandler
      virtual void handlePrivateXML( const Tag* xml );

      // reimplemented from PrivateXMLHandler
      virtual void handlePrivateXMLResult( const std::string& uid, PrivateXMLResult pxResult );

    private:
#ifdef ROSTERMANAGER_TEST
    public:
#endif
      typedef std::list<RosterItemData*> RosterData;

      class Query : public StanzaExtension
      {
        public:
          Query( const JID& jid, const std::string& name, const StringList& groups );

          Query( const JID& jid );

          Query( const Tag* tag = 0 );

          ~Query();

          const RosterData& roster() const { return m_roster; }

          // reimplemented from StanzaExtension
          virtual const std::string& filterString() const;

          // reimplemented from StanzaExtension
          virtual StanzaExtension* newInstance( const Tag* tag ) const
          {
            return new Query( tag );
          }

          // reimplemented from StanzaExtension
          virtual Tag* tag() const;

          // reimplemented from StanzaExtension
          virtual StanzaExtension* clone() const;

        private:
          RosterData m_roster;

      };

      void mergePush( const RosterData& data );
      void mergeRoster( const RosterData& data );

      RosterListener* m_rosterListener;
      Roster m_roster;
      ClientBase* m_parent;
      PrivateXML* m_privateXML;
      RosterItem* m_self;

      std::string m_delimiter;
      bool m_syncSubscribeReq;

      enum RosterContext
      {
        RequestRoster,
        AddRosterItem,
        RemoveRosterItem,
        SynchronizeRoster
      };

  };

}

#endif // ROSTER_H__