src/semaine/cms/message/SEMAINEMessage.h

Go to the documentation of this file.

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


#ifndef SEMAINE_CMS_MESSAGE_SEMAINEMESSAGE_H
#define SEMAINE_CMS_MESSAGE_SEMAINEMESSAGE_H

#include <typeinfo>

#include <semaine/config.h>

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

#include <cms/Message.h>
#include <cms/TextMessage.h>
#include <cms/BytesMessage.h>
#include <cms/Destination.h>
#include <cms/Topic.h>

using namespace cms;

namespace semaine {
namespace cms {
namespace message {

class SEMAINEMessage
{
public:
        static const std::string USERTIME;
        static const std::string DATATYPE;
        static const std::string SOURCE;
        static const std::string EVENT;
        static const std::string PERIOD;

        static const std::string CONTENT_ID;

        static const std::string CONTENT_CREATION_TIME;

        static const std::string CONTENT_TYPE;

        static const std::string CONTENT_TYPE_UTTERANCE;

        static const std::string CONTENT_TYPE_LISTENERVOCALISATION;

        static const std::string CONTENT_TYPE_VISUALONLY;

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

        virtual ~SEMAINEMessage();

        long long getUsertime() throw(CMSException)
        {
                return message->getLongProperty(USERTIME);
        }

        std::string getDatatype() throw(CMSException)
        {
                return message->getStringProperty(DATATYPE);
        }

        std::string getSource() throw(CMSException)
        {
                return message->getStringProperty(SOURCE);
        }

        bool isPeriodic() throw(CMSException)
        {
                return message->propertyExists(PERIOD);
        }

        bool isEventBased() throw(CMSException)
        {
                return message->propertyExists(EVENT);
        }

        std::string getEventType() throw (CMSException, semaine::cms::exceptions::MessageFormatException)
        {
                if (!message->propertyExists(EVENT))
                        throw semaine::cms::exceptions::MessageFormatException("Message is not event-based, cannot provide event type");
                std::string eventString = message->getStringProperty(EVENT);
                return eventString;
        }

        int getPeriod() throw (CMSException, semaine::cms::exceptions::MessageFormatException)
        {
                if (!message->propertyExists(PERIOD))
                        throw semaine::cms::exceptions::MessageFormatException("Message is not periodic, cannot provide period length");
                return message->getIntProperty(PERIOD);
        }

        std::string getContentID() throw (CMSException)
        {
                if (message->propertyExists(CONTENT_ID)) {
                        return message->getStringProperty(CONTENT_ID);
                }
                return "";
        }

        std::string getContentType() throw (CMSException)
        {
                if (message->propertyExists(CONTENT_TYPE)) {
                        return message->getStringProperty(CONTENT_TYPE);
                }
                return "";
        }

        long long getContentCreationTime() throw (CMSException)
        {
                if (message->propertyExists(CONTENT_CREATION_TIME)) {
                        return message->getLongProperty(CONTENT_CREATION_TIME);
                }
                return -1;
        }

        bool isTextMessage()
        {
                return dynamic_cast<const TextMessage*>(message) != NULL;
        }

        bool isBytesMessage()
        {
                return dynamic_cast<const BytesMessage*>(message) != NULL;
        }

        std::string getText() throw(CMSException, semaine::cms::exceptions::MessageFormatException)
        {
                const TextMessage * tm = dynamic_cast<const TextMessage*>(message);
                if (tm == NULL) {
                        throw semaine::cms::exceptions::MessageFormatException(std::string("Cannot get text for a message of type ")+typeid(*message).name());
                }
                return tm->getText();
        }

        std::string getTopicName() throw(CMSException)
        {
                const Destination * dest = message->getCMSDestination();
                if (dest == NULL) return std::string("unknown");
                const Topic * topic = dynamic_cast<const Topic *>(dest);
                if (topic == NULL) return std::string("unknown");
                return topic->getTopicName();
        }

        const Message * getMessage()
        {
                return message;
        }




protected:
        const Message * message;

private:
        void verifyProperties() throw(semaine::cms::exceptions::MessageFormatException);



};


} // namespace message
} // namespace cms
} // namespace semaine



#endif

---