src/semaine/cms/receiver/Receiver.h

Go to the documentation of this file.

/*
 *  Receiver.h
 *  semaine
 *
 *  Created by Marc Schröder on 09.09.08.
 *  Copyright 2008 DFKI GmbH. All rights reserved.
 *
 */

#ifndef SEMAINE_CMS_RECEIVER_RECEIVER_H
#define SEMAINE_CMS_RECEIVER_RECEIVER_H

#include <semaine/config.h>

#include <cms/MessageListener.h>

#include <decaf/util/concurrent/Concurrent.h>
#include <decaf/util/concurrent/Mutex.h>


#include <semaine/cms/IOBase.h>
#include <semaine/cms/CMSLogger.h>
#include <semaine/cms/SEMAINEMessageAvailableListener.h>
#include <semaine/cms/message/SEMAINEMessage.h>

#include <semaine/cms/exceptions/MessageFormatException.h>
#include <semaine/cms/exceptions/SystemConfigurationException.h>

using namespace cms;
using namespace semaine::cms;
using namespace semaine::cms::message;


using namespace decaf;

namespace semaine {
        namespace cms {
                namespace receiver {
                        class Receiver : public IOBase, public MessageListener
                        {
                        public:
                                Receiver(const std::string & topicName) throw (CMSException);

                                Receiver(const std::string & topicName, const std::string & messageSelector) throw (CMSException);

                                Receiver(const std::string & cmsUrl, const std::string & cmsUser, const std::string & cmsPassword,
                                        const std::string & topicName)
                                throw (CMSException);

                                Receiver(const std::string & cmsUrl, const std::string & cmsUser, const std::string & cmsPassword,
                                        const std::string & topicName, const std::string & messageSelector)
                                throw (CMSException);

                                virtual ~Receiver();

                                std::string getMessageSelector()
                                throw(CMSException)
                                {
                                        return consumer->getMessageSelector();
                                }



                                SEMAINEMessage * receive() throw(CMSException, semaine::cms::exceptions::SystemConfigurationException);

                                SEMAINEMessage * receive(int timeout) throw(CMSException, semaine::cms::exceptions::SystemConfigurationException);

                                SEMAINEMessage * receiveNoWait() throw(CMSException, semaine::cms::exceptions::SystemConfigurationException);



                                void setMessageListener(SEMAINEMessageAvailableListener * aListener)
                                throw(CMSException);

                                SEMAINEMessageAvailableListener * getMessageListener()
                                {
                                        return listener;
                                }

                                virtual void onMessage(const Message * m);

                                SEMAINEMessage * getMessage();

                                bool notPickedUp();



                        protected:

                                MessageConsumer * consumer;
                                SEMAINEMessageAvailableListener * listener;
                                CMSLogger * log;
                                SEMAINEMessage * message;
                                decaf::util::concurrent::Mutex mutex;



                                virtual SEMAINEMessage * createSEMAINEMessage(const Message * message)
                                throw(semaine::cms::exceptions::MessageFormatException);



                        };

                } // namespace receiver
        } // namespace cms
} // namespace semaine



#endif

---