h1. SimpleChat made easy - Part 1

Currently the situation with Wt's Comet is that you have to track the sessions you want to push data to yourself.
I have written some classes that help dealing with this issue and simplifies building the simple chat example.
We start with coding a new application type that is derived from Wt application, a Wt application that uses my comet example should use this application class instead of the normal WApplication class.

h2. CometApplication.hpp

#ifndef CometApplication_HPP
#define CometApplication_HPP

//
#include
#include
#include
//

//
#include
//

//
#include
#include
//

namespace UI
{
namespace Widgets
{
// Forward declerations
class CometWidget;

    template <class>
    class CometWidgetFactory;
}

namespace Application
{
    class CometApplication : public Wt::WApplication
    {
    public:
        CometApplication(const Wt::WEnvironment &env); // Ctor, passes enviorment variables to WApplication
        ~CometApplication(); // Dtor

        friend class Widgets::CometWidget; // Befriending with CometWidget so it can access the widget map

        template <class>
        friend class Widgets::CometWidgetFactory; // Same here
    private:
        typedef std::pair<int, Wt::WWidget *> WidgetEntryType;
        typedef boost::unordered_multimap<CometApplication *, WidgetEntryType > WidgetMapType;
        typedef boost::unordered_multimap<CometApplication *, WidgetEntryType >::iterator WidgetMapIteratorType;
        typedef std::pair<WidgetMapIteratorType, WidgetMapIteratorType> WidgetRangeType;

        static WidgetMapType widgets;

        // Pushes a new widget to the current session with group id and the widget itself
        inline void registerWidget(unsigned long int id, Wt::WWidget *w)
        {
            boost::mutex::scoped_lock  lock(CometMutex);

            widgets.insert(WidgetMapType::value_type(this, WidgetEntryType(id, w)));
        }

        // Searches for the widget of the group id for the current session and erases it
        inline void unregisterWidget(unsigned long int id)
        {
            boost::mutex::scoped_lock  lock(CometMutex);

            WidgetRangeType range = widgets.equal_range(this);

            for ( WidgetMapIteratorType iter = range.first; iter != range.second; ++iter )
            {
                if ( iter->second.first == id )
                {
                    widgets.erase(iter);
                    break;
                }
            }
        }

        // Searches for a widget in the current session, casts it to the right widget type and returns it
        template <class T>
        inline T *getWidget(unsigned long int id)
        {
            boost::mutex::scoped_lock  lock(CometMutex);

            WidgetRangeType range = widgets.equal_range(this);

            for ( WidgetMapIteratorType iter = range.first; iter != range.second; ++iter )
                if ( iter->second.first == id )
                    return dynamic_cast<T *>(iter->second.second);

            return NULL;
        }

        static boost::mutex CometMutex;
    };
}

}

#endif

h2. CometApplication.cpp

#include "CometApplication.hpp"

namespace UI
{
namespace Application
{
CometApplication::CometApplication(const Wt::WEnvironment &env)
: WApplication(env)
{
enableUpdates(); // Enables ajax-push for the current session
}

    CometApplication::~CometApplication()
    {
        boost::mutex::scoped_lock  lock(CometMutex);

        if ( widgets.find(this) != widgets.end() ) // Erases the current session from the widget map
            widgets.erase(this);
    }

    CometApplication::WidgetMapType CometApplication::widgets;
    CometApplication::boost::mutex CometMutex;
}

}

h3. Code Review

I have created an unordered multimap that might look a little strange to you guys but I'm going to elaborate about it in a minute.

The multimap key is the pointer to the current session which is represented by CometApplication, because as you guys already know, a session is an application instance. That way I can access the current session's widgets using this or iterate through all sessions.¶

The value of the multimap is a pair of a group id and a widget. Different widgets in different sessions with the same group id can be accessed this way.¶

As you can see the CometApplication instance only refers to this, which means only to the current session.
I have befriended all other classes because registerWidget, unregisterWidget and getWidget should only be accessed by those classes.
This doesn't indicate that my code has a design problem in my opinion.
Sometimes you actually have to use class friendship.
It makes sense that the end user will not control anything related to registering/unregistering widgets as you will see.

After that we create a factory which will instanciate a widget for each session.
Here the magic is introduced into the system.

h2. CometWidgetFactory.hpp

#ifndef CometWidgetFactory_HPP
#define CometWidgetFactory_HPP

#include
#include

#include

#include "CometApplication.hpp"

namespace UI
{
namespace Widgets
{
// CometWidgetFactory creates a widget of type WidgetType, WidgetType is derived from CometWidget
template
class CometWidgetFactory
{
private:
static unsigned long int idCounter; // Counts how many ids there are

        unsigned long int id; // Group id
    public:
        CometWidgetFactory()
        : id(idCounter)
        {
            idCounter++; // New factory instance has been created.
        }

        ~CometWidgetFactory()
        {
            idCounter--; // New factory instance has been destroyed
        }

        void create()
        {
            WidgetType *w = new WidgetType; // Creates a new widget
            w->id = id; // Assigns the group id

            // Registers the widget to the current session
            dynamic_cast<UI::Application::CometApplication *>(wApp)->registerWidget(id, w); 
        }

        void destroy()
        {
            // Unregisters the widget from the current session
            dynamic_cast<UI::Application::CometApplication *>(wApp)->unregisterWidget(id);
        }

        // Those operator overloadings make the factory "point" to the current widget we're refering to in the current session
        WidgetType *operator->()
        {
            return dynamic_cast<UI::Application::CometApplication *>(wApp)->getWidget<WidgetType>(id);
        }

        operator Wt::WWidget *()
        {
            return dynamic_cast<UI::Application::CometApplication *>(wApp)->getWidget<WidgetType>(id);
        }
    };

    template <class T>
    unsigned long int CometWidgetFactory<T>::idCounter = 0;
}

}

#endif

h3. Code Review

This class looks very simple but it has a trick.
If you declare it as static on your target widget it will create a group id for a certain type of widgets for all sessions.
For example:

class someWidget : public CometWidgetWt::LineEdit
{
//...
};

class MyPage : Wt::WContainer
{
private:
static CometWidgetFactory myWidget;
public:
MyPage()
{
myWidget.create(); // Creates a widget on the same group id
}

~MyPage()
{
myWidget.destroy();
}
};

For each session a someWidget will be created and you can access the widget on the current session.

h2. CometWidget.hpp

#ifndef CometWidget_HPP
#define CometWidget_HPP

#include

#include

#include

#include "CometApplication.hpp"

namespace UI
{
namespace Widgets
{
template
class CometWidget : public WidgetType
{
protected:
virtual void updateOthers()
{
boost::mutex::scoped_lock lock(CometMutex);

            for ( Application::CometApplication::WidgetMapIteratorType iter = Application::CometApplication::widgets.begin(); iter != Application::CometApplication::widgets.end(); ++iter )
            {
                Application::CometApplication::WidgetRangeType range = Application::CometApplication::widgets.equal_range(iter->first);

                for ( Application::CometApplication::WidgetMapIteratorType iter2 = range.first; iter2 != range.second; ++iter2 )
                {
                    if ( iter2->second.first == id )
                    {
                        Wt::WApplication::UpdateLock uiLock = iter->first->getUpdateLock();
                        dynamic_cast<CometWidget *>(iter2->second.second)->updateWidget();
                        iter->first->triggerUpdate();
                    }
                }
            }
        }

        virtual void updateWidget() = 0; // TBD: Convert this to a signal/slot instead of a virtual function

        template <class>
        friend class CometWidgetFactory;
    private:
        unsigned long int id; // Group ID

        boost::mutex CometMutex;
    };
}

}

#endif

h3. Code Review

updateOthers() updates each widget in the widget group and it should be called whenever a change was made in the widget.
updateWidget should be a slot that will be connected to signals that update the widget itself.

In the next part of the article I will demonstrate how to re-write the SimpleChat example very simply.