conversation.cpp

Go to the documentation of this file.

/*
 * conversation.cpp
 *
 * Copyright (C) 2008  Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

// includes -------------------------------------------------------------------
#include "conversation.h"               // always include our own header first!

#include "threadsafe/threadsafe_map.h"


namespace converse {


/// \ingroup conversation
/*@{*/

// public interface destructor implementation
ConversationHost::~ConversationHost(void) throw() { }
ConversationRouter::~ConversationRouter(void) throw() { }
ConversationManager::~ConversationManager(void) throw() { }


////////////////////////////////////////////////////////////////////////////////
//
//      ConversationHost -- base class implementation
//
////////////////////////////////////////////////////////////////////////////////

bool
ConversationHost::updateState
(
void
)
{
        // default implementation: do nothing, assume nothing changed
        return false;
}



////////////////////////////////////////////////////////////////////////////////
//
//      ConMgr -- object that implements the ConversationManager interface
//
//      NOTE: all public entry points must be threadsafe!
//      Private helper methods are not threadsafe.
//
////////////////////////////////////////////////////////////////////////////////

class ConMgr : public ConversationManager {
public:
        ConMgr(void) throw();
        ~ConMgr(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(IN ConversationRouter * router);

        // converse::ConversationManager class interface methods ---------------
        bool updateConversationTS(IN const char * guid,
                                IN conn_id_t conn_id,
                                IN int playerId,
                                IN smart_ptr<ConversationHost> host);

        bool handleDialogReplyTS(IN const char * guid,
                                IN int dialogId,
                                IN conn_id_t conn_id,
                                IN int playerId,
                                IN const Datahash * reply);

        bool deleteConversationTS(IN const char * guid);

        void updateAll(void);

private:
        // private typedefs ----------------------------------------------------
        struct conv_rec_t {
                // constructor, manipulators
                conv_rec_t(void) throw() { this->clear(); }
                void clear(void) throw() {
                                guid = "";
                                dialogId = 0;
                                connId = 0;
                                playerId = 0;
                                host = NULL;
                        }

                // data fields
                std::string             guid;           ///< conversation guid
                int                     dialogId;       ///< current dialog
                conn_id_t               connId;         ///< connection
                int                     playerId;       ///< local ID on host
                smart_ptr<ConversationHost> host;       ///< host object
        };

        typedef threadsafe_map<std::string, conv_rec_t> conversation_map_t;

        // private helper functions --------------------------------------------
        bool deleteConversation(IN const char * guid);
        bool updateDialogId(IN const char * guid,
                                IN conv_rec_t& cr,
                                IN int dialogId);
        void route(IN conv_rec_t& cr);

        // private member data -------------------------------------------------
        conversation_map_t      m_conversations;// all registered conversations
        ConversationRouter *    m_router;       // weak ref to router
};



ConMgr::ConMgr(void)
throw()
{
        m_router = NULL;                // weak ref, do not delete!
}



void
ConMgr::initialize
(
IN ConversationRouter * router
)
{
        ASSERT(router, "null");

        ASSERT(!m_router, "already have a router?");
        m_router = router;
}



////////////////////////////////////////////////////////////////////////////////
//
//      ConMgr -- converse::ConversationManager class interface methods
//
//      All methods should be threadsafe, hence the TS suffix.
//
////////////////////////////////////////////////////////////////////////////////

bool
ConMgr::updateConversationTS
(
IN const char * guid,
IN conn_id_t connId,
IN int playerId,
IN smart_ptr<ConversationHost> host
)
{
        ASSERT(guid, "null");
        // ASSERT(connId, "null"); -- we don't care!
        ASSERT(playerId > 0, "Bad player id: %d", playerId);
        ASSERT(host, "null");

        // see if there is already a conversation with this guid
        conv_rec_t cr;
        if (m_conversations.lookup(guid, cr)) {
                // validate with existing conversation
                if (cr.playerId != playerId) {
                        DPRINTF("Player ID does not match");
                        return false;
                }
                if (cr.connId != connId) {
                        DPRINTF("Connection ID does not match");
                        return false;
                }

                // do NOT switch to new host!  We respect dialogs
                //    already in progress...
                // cr.host = host;
        } else {
                // conversation does not already exist!  Create a record for it
                //DPRINTF("Adding conversation with guid='%s'", guid);

                // create conversation record
                cr.guid = guid;
                cr.connId = connId;
                cr.playerId = playerId;
                cr.host = host;

                // add to our map
                m_conversations.insert(guid, cr);
        }

        // tell the host that the conversation has started
        int newId = host->getCurrentDialogIdTS();
        this->updateDialogId(guid, cr, newId);

        // router should now route dialog
        this->route(cr);

        // all done!
        return true;
}



bool
ConMgr::handleDialogReplyTS
(
IN const char * guid,
IN int dialogId,
IN conn_id_t conn_id,
IN int playerId,
IN const Datahash * reply
)
{
        ASSERT(guid, "null");
        ASSERT(dialogId > 0, "Bad dialog id: %d", dialogId);
//      ASSERT(conn_id, "null");        -- we don't care!
        ASSERT(playerId > 0, "Bad player id: %d", playerId);
        ASSERT(reply, "null");

        //DPRINTF("handleDialogReplyTS  guid='%s'  dialog=%d",
        //    guid, dialogId);

        conv_rec_t cr;
        if (!m_conversations.lookup(guid, cr)) {
                DPRINTF("Unrecognized conversation: %s", guid);
                return false;
        }
        ASSERT(cr.host, "null host");

        if (cr.connId != conn_id) {
                // weird!  either spoofing or a networking error
                DPRINTF("Connection ID does not match");
                return false;
        }

        if (cr.playerId != playerId) {
                // spoofing?
                DPRINTF("Player ID does not match");
                return false;
        }

        if (cr.dialogId != dialogId) {
                // out of sync?  Client should refresh
                DPRINTF("Dialog ID does not match");
                DPRINTF("  Local id: %d", cr.dialogId);
                DPRINTF("  Remote id:%d", dialogId);
                DPRINTF("  Forcing a refresh to the client...");
                int newId = cr.host->getCurrentDialogIdTS();
                this->updateDialogId(guid, cr, newId);
                this->route(cr);
                return false;
        }

        // seems like a valid reply!  Forward to host of conversation
        cr.host->handleReplyTS(dialogId, reply);
        int newId = cr.host->getCurrentDialogIdTS();
        if (this->updateDialogId(guid, cr, newId)) {
                //DPRINTF("Dialog changed!  refreshing...");
                this->route(cr);
        }

        // all done
        return true;
}



void
ConMgr::updateAll
(
void
)
{
        conversation_map_t::iterator_t i;
        m_conversations.getIterator(i);
        std::string guidstr;
        conv_rec_t cr;
        while (m_conversations.getNextElement(i, guidstr, cr)) {
                ASSERT(cr.host, "null");
                if (cr.host->updateState() &&
                    cr.host->getCurrentDialogIdTS()) {
                        // host has asked that it be refreshed!
                        this->updateConversationTS(cr.guid.c_str(), cr.connId,
                            cr.playerId, cr.host);
                }
        }
}



////////////////////////////////////////////////////////////////////////////////
//
//      ConMgr -- private helper methods
//
////////////////////////////////////////////////////////////////////////////////

bool
ConMgr::deleteConversation
(
IN const char * guid
)
{
        ASSERT(guid, "null");
        DPRINTF("Deleting conversation: '%s'", guid);

        conv_rec_t cr;
        if (!m_conversations.lookup(guid, cr)) {
                return false;
        }

        // route so that router can destroy conversation
        std::string myGuid = guid;      // copy
        cr.dialogId = 0;
        this->route(cr);
        if (!m_conversations.remove(myGuid)) {
                DPRINTF("WARNING: failed to remove conversation!");
                DPRINTF("  guid='%s'", myGuid.c_str());
                return false;
        }
        return true;
}



bool
ConMgr::updateDialogId
(
IN const char * guid,
IN conv_rec_t& cr,
IN int dialogId
)
{
        ASSERT(guid, "null");
        ASSERT(dialogId >= 0, "bad dialog ID: %d", dialogId);

        if (!dialogId) {
                DPRINTF("Host has requested this conversation end: %s", guid);
                this->deleteConversation(guid);
                return false;   // does not count as a change!
        } else if (cr.dialogId != dialogId) {
                DPRINTF("Host has changed dialogs in conversation");
                DPRINTF("  old dialog: %d", cr.dialogId);
                DPRINTF("  new dialog: %d", dialogId);

                cr.dialogId = dialogId;

                // re-insert
                m_conversations.insert(guid, cr);

                return true;    // dialog ID changed
        }

        return false;           // no change
}



void
ConMgr::route
(
IN conv_rec_t& cr
)
{
        ASSERT(cr.playerId > 0, "Bad player id: %d", cr.playerId);
        // ASSERT(connId) -- don't care!
        ASSERT(cr.host, "null");
        ASSERT(m_router, "null");

        std::string data = cr.host->getDialogDataTS();
        m_router->routeConversationTS(cr.guid.c_str(), cr.dialogId,
            cr.playerId, cr.connId, data.c_str());
}



////////////////////////////////////////////////////////////////////////////////
//
//      public API
//
////////////////////////////////////////////////////////////////////////////////

smart_ptr<ConversationManager>
ConversationManager::create
(
IN ConversationRouter * router
)
{
        ASSERT(router, "null");

        smart_ptr<ConMgr> local = new ConMgr;
        ASSERT(local, "out of memory");

        local->initialize(router);

        return local;
}



};      // converse namespace