gloox 1.0
adhoc.h
00001 /*
00002   Copyright (c) 2004-2009 by Jakob Schroeter <js@camaya.net>
00003   This file is part of the gloox library. http://camaya.net/gloox
00004 
00005   This software is distributed under a license. The full license
00006   agreement can be found in the file LICENSE in this distribution.
00007   This software may not be copied, modified, sold or distributed
00008   other than expressed in the named license agreement.
00009 
00010   This software is distributed without any warranty.
00011 */
00012 
00013 
00014 
00015 #ifndef ADHOC_H__
00016 #define ADHOC_H__
00017 
00018 #include "dataform.h"
00019 #include "disco.h"
00020 #include "disconodehandler.h"
00021 #include "discohandler.h"
00022 #include "iqhandler.h"
00023 #include "stanzaextension.h"
00024 
00025 #include <string>
00026 #include <list>
00027 #include <map>
00028 
00029 namespace gloox
00030 {
00031 
00032   class ClientBase;
00033   class Stanza;
00034   class AdhocHandler;
00035   class AdhocCommandProvider;
00036 
00080   class GLOOX_API Adhoc : public DiscoNodeHandler, public DiscoHandler, public IqHandler
00081   {
00082     public:
00090       class GLOOX_API Command : public StanzaExtension
00091       {
00092         friend class Adhoc;
00093 
00094         public:
00095 
00099           enum Action
00100           {
00101             Execute       =  1,     
00103             Cancel        =  2,     
00104             Previous      =  4,     
00106             Next          =  8,     
00108             Complete      = 16,     
00109             InvalidAction = 32      
00110           };
00111 
00115           enum Status
00116           {
00117             Executing,              
00118             Completed,              
00119             Canceled,               
00120             InvalidStatus           
00121           };
00122 
00129           class GLOOX_API Note
00130           {
00131 
00132             friend class Command;
00133 
00134             public:
00138               enum Severity
00139               {
00140                 Info,               
00142                 Warning,            
00144                 Error,              
00146                 InvalidSeverity     
00147               };
00148 
00154               Note( Severity sev, const std::string& note )
00155                 : m_severity( sev ), m_note( note ) {}
00156 
00160               ~Note() {}
00161 
00166               Severity severity() const { return m_severity; }
00167 
00172               const std::string& content() const { return m_note; }
00173 
00178               Tag* tag() const;
00179 
00180             private:
00181 #ifdef ADHOC_COMMANDS_TEST
00182             public:
00183 #endif
00184 
00188               Note( const Tag* tag );
00189 
00190               Severity m_severity;      
00191               std::string m_note;       
00192           };
00193 
00197           typedef std::list<const Note*> NoteList;
00198 
00209           Command( const std::string& node, const std::string& sessionid, Action action,
00210                    DataForm* form = 0 );
00211 
00221           Command( const std::string& node, const std::string& sessionid, Status status,
00222                    DataForm* form = 0 );
00223 
00236           Command( const std::string& node, const std::string& sessionid, Status status,
00237                    Action executeAction, int allowedActions = Complete,
00238                    DataForm* form = 0 );
00239 
00249           Command( const std::string& node, Action action,
00250                    DataForm* form = 0 );
00251 
00256           Command( const Tag* tag = 0 );
00257 
00261           virtual ~Command();
00262 
00267           const std::string& node() const { return m_node; }
00268 
00273           const std::string& sessionID() const { return m_sessionid; }
00274 
00280           Status status() const { return m_status; }
00281 
00286           Action action() const { return m_action; }
00287 
00293           int actions() const { return m_actions; }
00294 
00299           const NoteList& notes() const { return m_notes; }
00300 
00306           void addNote( const Note* note ) { m_notes.push_back( note ); }
00307 
00312           const DataForm* form() const { return m_form; }
00313 
00314           // reimplemented from StanzaExtension
00315           virtual const std::string& filterString() const;
00316 
00317           // reimplemented from StanzaExtension
00318           virtual StanzaExtension* newInstance( const Tag* tag ) const
00319           {
00320             return new Command( tag );
00321           }
00322 
00323           // reimplemented from StanzaExtension
00324           virtual Tag* tag() const;
00325 
00326           // reimplemented from StanzaExtension
00327           virtual StanzaExtension* clone() const
00328           {
00329             Command* c = new Command();
00330 
00331             NoteList::const_iterator it = m_notes.begin();
00332             for( ; it != m_notes.end(); ++it )
00333               c->m_notes.push_back( new Note( *(*it) ) );
00334 
00335             c->m_node = m_node;
00336             c->m_sessionid = m_sessionid;
00337             c->m_form = m_form ? static_cast<DataForm*>( m_form->clone() ) : 0;
00338             c->m_action = m_action;
00339             c->m_status = m_status;
00340             c->m_actions = m_actions;
00341 
00342             return c;
00343           }
00344 
00345         private:
00346 #ifdef ADHOC_COMMANDS_TEST
00347         public:
00348 #endif
00349           NoteList m_notes;
00350 
00351           std::string m_node;
00352           std::string m_sessionid;
00353           DataForm* m_form;
00354           Action m_action;
00355           Status m_status;
00356           int m_actions;
00357       };
00358 
00364       Adhoc( ClientBase* parent );
00365 
00369       virtual ~Adhoc();
00370 
00376       void checkSupport( const JID& remote, AdhocHandler* ah );
00377 
00384       void getCommands( const JID& remote, AdhocHandler* ah );
00385 
00396       void execute( const JID& remote, const Adhoc::Command* command, AdhocHandler* ah );
00397 
00410       void respond( const JID& remote, const Adhoc::Command* command, const Error* error = 0 );
00411 
00419       void registerAdhocCommandProvider( AdhocCommandProvider* acp, const std::string& command,
00420                                          const std::string& name );
00421 
00427       void removeAdhocCommandProvider( const std::string& command );
00428 
00429       // reimplemented from DiscoNodeHandler
00430       virtual StringList handleDiscoNodeFeatures( const JID& from, const std::string& node );
00431 
00432       // reimplemented from DiscoNodeHandler
00433       virtual Disco::IdentityList handleDiscoNodeIdentities( const JID& from,
00434           const std::string& node );
00435 
00436       // reimplemented from DiscoNodeHandler
00437       virtual Disco::ItemList handleDiscoNodeItems( const JID& from, const JID& to, const std::string& node );
00438 
00439       // reimplemented from IqHandler
00440       virtual bool handleIq( const IQ& iq );
00441 
00442       // reimplemented from IqHandler
00443       virtual void handleIqID( const IQ& iq, int context );
00444 
00445       // reimplemented from DiscoHandler
00446       virtual void handleDiscoInfo( const JID& from, const Disco::Info& info, int context );
00447 
00448       // reimplemented from DiscoHandler
00449       virtual void handleDiscoItems( const JID& from, const Disco::Items& items, int context );
00450 
00451       // reimplemented from DiscoHandler
00452       virtual void handleDiscoError( const JID& from, const Error* error, int context );
00453 
00454     private:
00455 #ifdef ADHOC_TEST
00456     public:
00457 #endif
00458       typedef std::map<const std::string, AdhocCommandProvider*> AdhocCommandProviderMap;
00459       AdhocCommandProviderMap m_adhocCommandProviders;
00460 
00461       enum AdhocContext
00462       {
00463         CheckAdhocSupport,
00464         FetchAdhocCommands,
00465         ExecuteAdhocCommand
00466       };
00467 
00468       struct TrackStruct
00469       {
00470         JID remote;
00471         AdhocContext context;
00472         std::string session;
00473         AdhocHandler* ah;
00474       };
00475       typedef std::map<std::string, TrackStruct> AdhocTrackMap;
00476       AdhocTrackMap m_adhocTrackMap;
00477 
00478       ClientBase* m_parent;
00479 
00480       StringMap m_items;
00481       StringMap m_activeSessions;
00482 
00483   };
00484 
00485 }
00486 
00487 #endif // ADHOC_H__