conversation.h

Go to the documentation of this file.

#ifndef FIPA_ACL_CONVERSATION_H
#define FIPA_ACL_CONVERSATION_H

#include <vector>
#include <list>
#include <boost/shared_ptr.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread/condition.hpp>
#include <fipa_acl/message_generator/acl_message.h>
#include <fipa_acl/conversation_monitor/transition.h>
#include <fipa_acl/conversation_monitor/statemachine_factory.h>
#include <base/Time.hpp>

namespace fipa {
namespace acl {

class ConversationObserver;
class ConversationObservable;

typedef boost::shared_ptr<ConversationObserver> ConversationObserverPtr;
typedef boost::shared_ptr<ConversationObservable> ConversationObservablePtr;
typedef std::vector<ConversationObserverPtr> ConversationObserverList;

namespace conversation {
    enum EventType { UNKNOWN, START_OF_CONVERSATION, INTERMEDIATE_UPDATE, END_OF_CONVERSATION, FAILURE };

    enum Status { UNINITIALIZED, RUNNING, ENDED, FAILED };

    static const std::string EventTypeTxt[] = { "UNKNOWN", "START_OF_CONVERSATION", "INTERMEDIATE_UPDATE", "END_OF_CONVERSATION", "FAILURE" };
    static const std::string StatusTxt[] = { "UNINITIALIZED", "RUNNING", "ENDED", "FAILED" };

    struct Event
    {
        Event();

        Event(const fipa::acl::ACLMessage& _msg, EventType _type);

        fipa::acl::ACLMessage msg;
        EventType type;
        base::Time timestamp;
    };

    struct ProtocolException : public std::runtime_error
    {
        ProtocolException()
            : std::runtime_error("fipa::acl::conversation::ProtocolException")
        {}
    
        ProtocolException(const std::string& msg)
            : std::runtime_error("fipa::acl::conversation::ProtocolException: '" + msg + "'" )
        {}
    
    };

    struct InvalidOperation : public std::runtime_error
    {
        InvalidOperation()
            : std::runtime_error("fipa::acl::conversation::InvalidOperation")
        {}
    
        InvalidOperation(const std::string& msg)
            : std::runtime_error("fipa::acl::conversation::InvalidOperation: '" + msg + "'" )
        {}
    
    };
}

struct NullDeleter
{
    void operator()(void const *) const {}
};

class ConversationObserver
{
    friend class ConversationObservable;
public:
    ConversationObserver();

    virtual ~ConversationObserver() {}

    bool hasEvents() const;

    conversation::Event waitForNextEvent();

    bool getNextEvent(conversation::Event& msg);

    std::vector<fipa::acl::ConversationID> getConversationIdsOfObservables() const;

private:
    void update(const conversation::Event& event);

    void registerObservable(const ConversationObservablePtr& observable);

    // Condition to wait for new event, when operating in a blocking fashion
    boost::condition mCondition;
    mutable boost::mutex mEventsMutex;

    // List of events this observer has been notified on 
    // events are stored in incoming order (however conversation::Event also contains
    // a timestamp)
    std::vector<conversation::Event> mEvents;

    mutable boost::mutex mObservablesMutex;
    // List of observables this observer is attached to
    std::vector<ConversationObservablePtr> mObservables;
};

class ConversationObservable
{
public:
    ConversationObservable(); 

    ConversationObservable(const ConversationObservable& other);

    ConversationObservable(const fipa::acl::ConversationID& conversationId);

    virtual ~ConversationObservable() {}

    void setConversationId(const fipa::acl::ConversationID& conversationId) { mConversationId = conversationId; }

    fipa::acl::ConversationID getConversationId() const;

    void addObserver(const ConversationObserverPtr& observer); 

    void removeObserver(const ConversationObserverPtr& observer);

    void notify(const fipa::acl::ACLMessage& msg, conversation::EventType eventType);

    conversation::Status getStatus() const;

    ConversationObserverList getObservers() const;

    void detachObservers();

    bool hasObservers() const;

protected:
    fipa::acl::ConversationID mConversationId;

private:
    mutable boost::mutex mObserverMutex;
    conversation::Status mStatus;

    ConversationObserverList mObservers;
};


class Conversation : public ConversationObservable
{
public:

    Conversation(const std::string& owner, const fipa::acl::ConversationID& conversationId = fipa::acl::ConversationID());

    Conversation(const std::string& owner, const fipa::acl::ACLMessage& initiator);

    Conversation(const Conversation& other);

    virtual ~Conversation();

    void setProtocol(const fipa::acl::Protocol& protocol) { mProtocol = protocol; }

    fipa::acl::Protocol getProtocol() const { return mProtocol; }

    void setContentLanguage(const fipa::acl::ContentLanguage& language) { mContentLanguage = language; }

    fipa::acl::ContentLanguage getContentLanguage() const;
    
    void setNumberOfSubConversations(int amount) { mNumberOfSubConversations = amount; }

    void update(const fipa::acl::ACLMessage& msg);

    std::vector<fipa::acl::ACLMessage> getMessages() const { return mMessages; }

    fipa::acl::ACLMessage getLastMessage() const;

    bool hasEnded() const;

    bool hasMessages() const;

    std::string getOwner() const;

    static fipa::acl::ConversationID generateConversationID(const std::string& topic = "");

    static std::string toString(const std::vector<fipa::acl::ACLMessage>& messages);

    std::string toString() const;

private:
    
    void notifyAll(const fipa::acl::ACLMessage& msg, bool newConversation);
    
    std::string mOwner;

    fipa::acl::Protocol mProtocol;

    fipa::acl::ContentLanguage mContentLanguage;

    int mNumberOfSubConversations;
    
    std::vector<fipa::acl::ACLMessage> mMessages;

    mutable boost::mutex mMutex;
    
    fipa::acl::StateMachine mStateMachine;

    static fipa::acl::StateMachineFactory msStateMachineFactory;

};

typedef boost::shared_ptr<Conversation> ConversationPtr;

} // end namespace acl
} // end namespace fipa
#endif //FIPA_ACL_CONVERSATION_H